zeroc-ice 3.8.2 → 3.8.3

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

@@ -48,6 +48,16 @@ namespace
     inline EndpointIPtr toEndpointI(const EndpointPtr& endp) { return dynamic_pointer_cast<EndpointI>(endp); }
 
     string emptyName{};
+
+    // Installed as the dispatch pipeline when the creation of the actual pipeline fails.
+    class FailedDispatchPipeline final : public Object
+    {
+    public:
+        void dispatch(IncomingRequest&, std::function<void(OutgoingResponse)>) final
+        {
+            throw UnknownException{__FILE__, __LINE__, "the object adapter could not create its dispatch pipeline"};
+        }
+    };
 }
 
 Ice::ObjectAdapter::~ObjectAdapter() = default; // avoid weak vtable
@@ -95,7 +105,7 @@ Ice::ObjectAdapterI::activate()
         //
         // One off initializations of the adapter: update the
         // locator registry and print the "adapter ready"
-        // message. We set set state to StateActivating to prevent
+        // message. We set state to StateActivating to prevent
         // deactivation from other threads while these one off
         // initializations are done.
         //
@@ -121,7 +131,7 @@ Ice::ObjectAdapterI::activate()
             //
             // If we couldn't update the locator registry, we let the
             // exception go through and don't activate the adapter to
-            // allow to user code to retry activating the adapter
+            // allow user code to retry activating the adapter
             // later.
             //
             {
@@ -535,11 +545,29 @@ Ice::ObjectAdapterI::dispatchPipeline() const noexcept
     lock_guard lock(_mutex);
     if (!_dispatchPipeline)
     {
-        _dispatchPipeline = _servantManager;
-        while (!_middlewareFactoryStack.empty())
+        try
+        {
+            ObjectPtr dispatchPipeline = _servantManager;
+            while (!_middlewareFactoryStack.empty())
+            {
+                dispatchPipeline = _middlewareFactoryStack.top()(std::move(dispatchPipeline));
+                _middlewareFactoryStack.pop();
+            }
+            _dispatchPipeline = std::move(dispatchPipeline);
+        }
+        catch (const std::exception& ex)
         {
-            _dispatchPipeline = _middlewareFactoryStack.top()(std::move(_dispatchPipeline));
-            _middlewareFactoryStack.pop();
+            Error out(_instance->initializationData().logger);
+            out << "failed to create the dispatch pipeline of object adapter '" << _name << "':\n" << ex;
+            _dispatchPipeline = make_shared<FailedDispatchPipeline>();
+            _middlewareFactoryStack = {};
+        }
+        catch (...)
+        {
+            Error out(_instance->initializationData().logger);
+            out << "failed to create the dispatch pipeline of object adapter '" << _name << "': unknown c++ exception";
+            _dispatchPipeline = make_shared<FailedDispatchPipeline>();
+            _middlewareFactoryStack = {};
         }
     }
     return _dispatchPipeline;
@@ -996,15 +1024,6 @@ Ice::ObjectAdapterI::initialize(optional<RouterPrx> router)
             // fill in the real port number.
             //
             vector<EndpointIPtr> endpoints = parseEndpoints(properties->getProperty(_name + ".Endpoints"), true);
-            for (const auto& endpoint : endpoints)
-            {
-                for (const auto& expanded : endpoint->expandHost())
-                {
-                    auto factory = make_shared<IncomingConnectionFactory>(_instance, expanded, shared_from_this());
-                    factory->initialize();
-                    _incomingConnectionFactories.push_back(factory);
-                }
-            }
             if (endpoints.empty())
             {
                 TraceLevelsPtr tl = _instance->traceLevels();
@@ -1014,6 +1033,24 @@ Ice::ObjectAdapterI::initialize(optional<RouterPrx> router)
                     out << "created adapter '" << _name << "' without endpoints";
                 }
             }
+            else
+            {
+                // An adapter with endpoints accepts incoming connections, and each connection needs the
+                // adapter's dispatch thread pool. Create it before the first connection factory: its
+                // on-demand creation reads the thread pool properties and can throw, and it must not fail
+                // once connections exist.
+                [[maybe_unused]] auto _ = getThreadPool();
+
+                for (const auto& endpoint : endpoints)
+                {
+                    for (const auto& expanded : endpoint->expandHost())
+                    {
+                        auto factory = make_shared<IncomingConnectionFactory>(_instance, expanded, shared_from_this());
+                        factory->initialize();
+                        _incomingConnectionFactories.push_back(factory);
+                    }
+                }
+            }
         }
 
         //
@@ -1317,7 +1354,7 @@ ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locator
         if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n";
+            out << "could not update object adapter '" + _id + "' endpoints with the locator registry:\n";
             out << "the object adapter is not known to the locator registry";
         }
 
@@ -1328,7 +1365,7 @@ ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locator
         if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n";
+            out << "could not update object adapter '" + _id + "' endpoints with the locator registry:\n";
             out << "the replica group '" << _replicaGroupId << "' is not known to the locator registry";
         }
 
@@ -1339,7 +1376,7 @@ ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locator
         if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n";
+            out << "could not update object adapter '" + _id + "' endpoints with the locator registry:\n";
             out << "the object adapter endpoints are already set";
         }
 
@@ -1358,7 +1395,7 @@ ObjectAdapterI::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locator
         if (_instance->traceLevels()->location >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->locationCat);
-            out << "couldn't update object adapter '" + _id + "' endpoints with the locator registry:\n" << ex;
+            out << "could not update object adapter '" + _id + "' endpoints with the locator registry:\n" << ex;
         }
         throw; // TODO: Shall we raise a special exception instead of a non obvious local exception?
     }

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

@@ -298,7 +298,7 @@ IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& ar
                     __LINE__,
                     "invalid type value '" + argument + "' in endpoint '" + endpoint + "'");
             }
-            else if (t < 0 || t > 65535)
+            else if (t < 0 || t > 32767)
             {
                 throw ParseException(
                     __FILE__,
@@ -322,17 +322,17 @@ IceInternal::OpaqueEndpointI::checkOption(const string& option, const string& ar
                     __LINE__,
                     "no argument provided for -v option in endpoint '" + endpoint + "'");
             }
-            for (char i : argument)
+            try
+            {
+                const_cast<vector<byte>&>(_rawBytes) = Base64::decode(argument);
+            }
+            catch (const std::invalid_argument& ex)
             {
-                if (!Base64::isBase64(i))
-                {
-                    ostringstream os;
-                    os << "invalid base64 character '" << i << "' (ordinal " << static_cast<int>(i) << ") in endpoint '"
-                       << endpoint << "'";
-                    throw ParseException(__FILE__, __LINE__, os.str());
-                }
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "invalid base64 value in endpoint '" + endpoint + "':\n" + ex.what());
             }
-            const_cast<vector<byte>&>(_rawBytes) = Base64::decode(argument);
             return true;
         }
 

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

@@ -51,7 +51,7 @@ IceInternal::Options::checkArgs(const string& shortOpt, const string& longOpt, b
         {
             string err = "'";
             err += shortOpt;
-            err += "': a short option cannot be `-'";
+            err += "': a short option cannot be '-'";
             throw invalid_argument(err);
         }
     }
@@ -69,7 +69,7 @@ IceInternal::Options::checkArgs(const string& shortOpt, const string& longOpt, b
         {
             string err = "'";
             err += longOpt;
-            err += "': a long option must not contain a leading `-'";
+            err += "': a long option must not contain a leading '-'";
             throw invalid_argument(err);
         }
     }
@@ -627,6 +627,11 @@ IceInternal::Options::parse(const StringVector& args)
                         argDone = true;
                         break;
                     }
+
+                    // This option is the last character in the cluster and its argument is the next argv element,
+                    // consumed by the "if (!argDone)" code below. Reset argDone in case a preceding no-argument
+                    // option in this cluster set it (for example "-dI dir").
+                    argDone = false;
                 }
                 else
                 {

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

@@ -481,7 +481,7 @@ ProxyOutgoingAsyncBase::invokeImpl(bool userThread)
             }
         }
     }
-    catch (const Exception&)
+    catch (...)
     {
         // If called from the user thread we re-throw, the exception will be caught by the caller and handled using
         // abort.

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

@@ -306,7 +306,7 @@ Ice::OutputStream::writeEncapsulation(const byte* v, int32_t sz)
 
     Container::size_type position = b.size();
     resize(position + static_cast<size_t>(sz));
-    memcpy(&b[position], &v[0], static_cast<size_t>(sz));
+    memcpy(&b[position], v, static_cast<size_t>(sz));
 }
 
 void
@@ -338,7 +338,7 @@ Ice::OutputStream::writeBlob(const vector<byte>& v)
     {
         Container::size_type pos = b.size();
         resize(pos + v.size());
-        memcpy(&b[pos], &v[0], v.size());
+        memcpy(&b[pos], v.data(), v.size());
     }
 }
 
@@ -1006,7 +1006,7 @@ void
 Ice::OutputStream::EncapsEncoder10::write(const UserException& v)
 {
     //
-    // User exception with the 1.0 encoding start with a boolean
+    // User exceptions with the 1.0 encoding start with a boolean
     // flag that indicates whether or not the exception uses
     // classes.
     //
@@ -1398,7 +1398,7 @@ Ice::OutputStream::EncapsEncoder11::writeInstance(const shared_ptr<Value>& v)
     assert(v);
 
     //
-    // If the instance was already marshaled, just write it's ID.
+    // If the instance was already marshaled, just write its ID.
     //
     auto q = _marshaledMap.find(v);
     if (q != _marshaledMap.end())

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

@@ -279,7 +279,13 @@ Ice::PluginManagerI::loadPlugin(PluginFactoryFunc factoryFunc, const string& nam
                 "invalid arguments for plug-in '" + name + "':\n" + string{ex.what()});
         }
 
-        assert(!args.empty());
+        if (args.empty())
+        {
+            throw PluginInitializationException(
+                __FILE__,
+                __LINE__,
+                "no entry point specified for plug-in '" + name + "'");
+        }
 
         //
         // Shift the arguments.

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

@@ -315,6 +315,7 @@ Ice::Properties::getPropertyAsListWithDefault(string_view key, const StringSeq&
         {
             Warning out(getProcessLogger());
             out << "mismatched quotes in property " << key << "'s value, returning default value";
+            return value;
         }
         if (result.size() == 0)
         {
@@ -359,27 +360,28 @@ Ice::Properties::setProperty(string_view key, string_view value)
     }
 
     // Check if the property is in an Ice property prefix. If so, check that it's a valid property.
-    if (auto propertyArray = findIcePropertyArray(key))
+    if (auto propertyArray = findIcePropertyArray(currentKey))
     {
         if (propertyArray->isOptIn &&
             find(_optInPrefixes.begin(), _optInPrefixes.end(), propertyArray->name) == _optInPrefixes.end())
         {
             ostringstream os;
-            os << "unable to set '" << key << "': property prefix '" << propertyArray->name
+            os << "unable to set '" << currentKey << "': property prefix '" << propertyArray->name
                << "' is opt-in and must be explicitly enabled.";
             throw PropertyException{__FILE__, __LINE__, os.str()};
         }
         string propertyPrefix{propertyArray->name};
-        auto prop = IceInternal::findProperty(key.substr(propertyPrefix.length() + 1), propertyArray);
+        auto prop =
+            IceInternal::findProperty(string_view{currentKey}.substr(propertyPrefix.length() + 1), propertyArray);
         if (!prop)
         {
-            throw PropertyException{__FILE__, __LINE__, "unknown Ice property: " + string{key}};
+            throw PropertyException{__FILE__, __LINE__, "unknown Ice property: " + currentKey};
         }
 
         // If the property is deprecated, log a warning.
         if (prop->deprecated)
         {
-            getProcessLogger()->warning("setting deprecated property: " + string{key});
+            getProcessLogger()->warning("setting deprecated property: " + currentKey);
         }
     }
 
@@ -495,7 +497,15 @@ Ice::Properties::load(string_view file)
                 DWORD keyType;
                 DWORD nameBufSize = static_cast<DWORD>(nameBuf.size());
                 DWORD dataBufSize = static_cast<DWORD>(dataBuf.size());
-                err = RegEnumValueW(iceKey, i, &nameBuf[0], &nameBufSize, nullptr, &keyType, &dataBuf[0], &dataBufSize);
+                err = RegEnumValueW(
+                    iceKey,
+                    i,
+                    nameBuf.data(),
+                    &nameBufSize,
+                    nullptr,
+                    &keyType,
+                    dataBuf.data(),
+                    &dataBufSize);
                 if (err != ERROR_SUCCESS || nameBufSize == 0)
                 {
                     ostringstream os;
@@ -503,7 +513,7 @@ Ice::Properties::load(string_view file)
                        << ":\n";
                     if (nameBufSize == 0)
                     {
-                        os << "property name can't be the empty string";
+                        os << "property name cannot be the empty string";
                     }
                     else
                     {
@@ -512,8 +522,7 @@ Ice::Properties::load(string_view file)
                     getProcessLogger()->warning(os.str());
                     continue;
                 }
-                string name =
-                    wstringToString(wstring(reinterpret_cast<wchar_t*>(&nameBuf[0]), nameBufSize), stringConverter);
+                string name = wstringToString(wstring(nameBuf.data(), nameBufSize), stringConverter);
                 if (keyType != REG_SZ && keyType != REG_EXPAND_SZ)
                 {
                     ostringstream os;
@@ -523,7 +532,8 @@ Ice::Properties::load(string_view file)
                 }
 
                 string value;
-                wstring valueW = wstring(reinterpret_cast<wchar_t*>(&dataBuf[0]), (dataBufSize / sizeof(wchar_t)) - 1);
+                wstring valueW =
+                    wstring(reinterpret_cast<wchar_t*>(dataBuf.data()), (dataBufSize / sizeof(wchar_t)) - 1);
                 if (keyType == REG_SZ)
                 {
                     value = wstringToString(valueW, stringConverter);
@@ -533,14 +543,14 @@ Ice::Properties::load(string_view file)
                     vector<wchar_t> expandedValue(1024);
                     DWORD sz = ExpandEnvironmentStringsW(
                         valueW.c_str(),
-                        &expandedValue[0],
+                        expandedValue.data(),
                         static_cast<DWORD>(expandedValue.size()));
                     if (sz >= expandedValue.size())
                     {
                         expandedValue.resize(sz + 1);
                         if (ExpandEnvironmentStringsW(
                                 valueW.c_str(),
-                                &expandedValue[0],
+                                expandedValue.data(),
                                 static_cast<DWORD>(expandedValue.size())) == 0)
                         {
                             ostringstream os;
@@ -551,7 +561,7 @@ Ice::Properties::load(string_view file)
                             continue;
                         }
                     }
-                    value = wstringToString(wstring(&expandedValue[0], sz - 1), stringConverter);
+                    value = wstringToString(wstring(expandedValue.data(), sz - 1), stringConverter);
                 }
                 setProperty(name, value);
             }
@@ -893,15 +903,15 @@ Ice::Properties::loadConfig()
     {
 #ifdef _WIN32
         vector<wchar_t> v(256);
-        DWORD ret = GetEnvironmentVariableW(L"ICE_CONFIG", &v[0], static_cast<DWORD>(v.size()));
+        DWORD ret = GetEnvironmentVariableW(L"ICE_CONFIG", v.data(), static_cast<DWORD>(v.size()));
         if (ret >= v.size())
         {
             v.resize(ret + 1);
-            ret = GetEnvironmentVariableW(L"ICE_CONFIG", &v[0], static_cast<DWORD>(v.size()));
+            ret = GetEnvironmentVariableW(L"ICE_CONFIG", v.data(), static_cast<DWORD>(v.size()));
         }
         if (ret > 0)
         {
-            value = wstringToString(wstring(&v[0], ret), getProcessStringConverter());
+            value = wstringToString(wstring(v.data(), ret), getProcessStringConverter());
         }
         else
         {

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

@@ -82,7 +82,7 @@ IceInternal::validatePropertiesWithPrefix(
     PropertyDict props = properties->getPropertiesForPrefix(string{prefix} + ".");
     for (const auto& p : props)
     {
-        // Plus one to include the dot.
+        // Plus one to skip the dot.
         if (!findProperty(p.first.substr(prefix.size() + 1), propertyArray))
         {
             unknownProps.push_back(p.first);

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

@@ -136,17 +136,6 @@ IceInternal::ProtocolInstance::defaultSourceAddress() const
     return instance->defaultsAndOverrides()->defaultSourceAddress;
 }
 
-const EncodingVersion&
-IceInternal::ProtocolInstance::defaultEncoding() const
-{
-    InstancePtr instance = _instance.lock();
-    if (!instance)
-    {
-        throw CommunicatorDestroyedException{__FILE__, __LINE__};
-    }
-    return instance->defaultsAndOverrides()->defaultEncoding;
-}
-
 NetworkProxyPtr
 IceInternal::ProtocolInstance::networkProxy() const
 {

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

@@ -45,7 +45,6 @@ namespace IceInternal
         [[nodiscard]] ProtocolSupport protocolSupport() const;
         [[nodiscard]] const std::string& defaultHost() const;
         [[nodiscard]] const Address& defaultSourceAddress() const;
-        [[nodiscard]] const Ice::EncodingVersion& defaultEncoding() const;
         [[nodiscard]] NetworkProxyPtr networkProxy() const;
         [[nodiscard]] std::int32_t messageSizeMax() const;
 
@@ -60,7 +59,7 @@ namespace IceInternal
         ProtocolInstance(const InstancePtr&, std::int16_t, std::string, bool);
         friend class Instance;
         // Use a weak pointer to avoid circular references. The communicator owns the endpoint factory, which in
-        // turn own this protocol instance.
+        // turn owns this protocol instance.
         const std::weak_ptr<Instance> _instance;
         const int _traceLevel;
         const std::string _traceCategory;

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

@@ -207,7 +207,15 @@ Ice::ObjectPrx::ice_isFixed() const noexcept
 ConnectionPtr
 Ice::ObjectPrx::ice_getCachedConnection() const noexcept
 {
-    return _requestHandlerCache->getCachedConnection();
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        return fixedReference->fixedConnection();
+    }
+    else
+    {
+        return _requestHandlerCache->getCachedConnection();
+    }
 }
 
 CommunicatorPtr

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

@@ -6,10 +6,15 @@
 #include "CollocatedRequestHandler.h"
 #include "ConnectionI.h"
 #include "Ice/InputStream.h"
+#include "Ice/LoggerUtil.h"
 #include "Ice/OutgoingAsync.h"
 #include "Ice/OutputStream.h"
 #include "Ice/Proxy.h"
+#include "Instance.h"
+#include "Reference.h"
 #include "ReferenceFactory.h"
+#include "RequestHandler.h"
+#include "ThreadPool.h"
 
 using namespace std;
 using namespace Ice;
@@ -77,7 +82,20 @@ namespace IceInternal
             : ProxyGetConnection(std::move(proxy)),
               LambdaInvoke(std::move(ex), std::move(sent))
         {
-            _response = [&, response = std::move(response)](bool) { response(getConnection()); };
+            _response = [this, response = std::move(response)](bool)
+            {
+                if (response)
+                {
+                    try
+                    {
+                        response(getConnection());
+                    }
+                    catch (...)
+                    {
+                        warning("response", std::current_exception());
+                    }
+                }
+            };
         }
     };
 
@@ -172,13 +190,14 @@ namespace IceInternal
             {
                 _response = [this, response = std::move(response)](bool ok)
                 {
-                    if (this->_is.b.empty())
+                    R v = this->_is.b.empty() ? R{ok, {}} : this->_read(ok, &this->_is);
+                    try
                     {
-                        response(R{ok, {}});
+                        response(std::move(v));
                     }
-                    else
+                    catch (...)
                     {
-                        response(this->_read(ok, &this->_is));
+                        this->warning("response", std::current_exception());
                     }
                 };
             }
@@ -282,6 +301,18 @@ ProxyGetConnection::ProxyGetConnection(ObjectPrx proxy) : ProxyOutgoingAsyncBase
 AsyncStatus
 ProxyGetConnection::invokeRemote(const ConnectionIPtr& connection, bool, bool)
 {
+    // A fixed proxy never reaches the invocation machinery: invoke returns its bound connection directly.
+    assert(!_proxy.ice_isFixed());
+    try
+    {
+        connection->throwException();
+    }
+    catch (const Ice::LocalException&)
+    {
+        // The connection is closed: throw RetryException so that the caller clears the cached request handler
+        // and calls invokeRemote again with a new connection.
+        throw RetryException(current_exception());
+    }
     _cachedConnection = connection;
     if (responseImpl(true, true))
     {
@@ -602,7 +633,15 @@ Ice::ObjectPrx::ice_invokeAsync(
 Ice::ConnectionPtr
 Ice::ObjectPrx::ice_getConnection() const
 {
-    return ice_getConnectionAsync().get();
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        return fixedReference->fixedConnection();
+    }
+    else
+    {
+        return ice_getConnectionAsync().get();
+    }
 }
 
 std::function<void()>
@@ -611,18 +650,76 @@ Ice::ObjectPrx::ice_getConnectionAsync(
     std::function<void(std::exception_ptr)> ex,
     std::function<void(bool)> sent) const
 {
-    using LambdaOutgoing = ProxyGetConnectionLambda;
-    auto outAsync = std::make_shared<LambdaOutgoing>(*this, std::move(response), std::move(ex), std::move(sent));
-    _iceI_getConnection(outAsync);
-    return [outAsync]() { outAsync->cancel(); };
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state. The response
+    // callback is executed from the thread pool that services this connection (or by the executor, if set). Like for
+    // the response callback of a lambda invocation, an exception thrown by the callback is logged as an
+    // Ice.Warn.AMICallback warning.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        if (response)
+        {
+            InstancePtr instance = fixedReference->getInstance();
+            ConnectionIPtr connection = fixedReference->fixedConnection();
+            connection->getThreadPool()->execute(
+                [response = std::move(response), connection, instance = std::move(instance)]()
+                {
+                    try
+                    {
+                        response(connection);
+                    }
+                    catch (...)
+                    {
+                        if (instance->initializationData().properties->getIcePropertyAsInt("Ice.Warn.AMICallback") > 0)
+                        {
+                            Warning out(instance->initializationData().logger);
+                            try
+                            {
+                                throw;
+                            }
+                            catch (const Ice::Exception& e)
+                            {
+                                out << "Ice::Exception raised by response callback:\n" << e;
+                            }
+                            catch (const std::exception& e)
+                            {
+                                out << "std::exception raised by response callback:\n" << e.what();
+                            }
+                            catch (...)
+                            {
+                                out << "unknown exception raised by response callback";
+                            }
+                        }
+                    }
+                },
+                connection);
+        }
+        return [] {};
+    }
+    else
+    {
+        using LambdaOutgoing = ProxyGetConnectionLambda;
+        auto outAsync = std::make_shared<LambdaOutgoing>(*this, std::move(response), std::move(ex), std::move(sent));
+        _iceI_getConnection(outAsync);
+        return [outAsync]() { outAsync->cancel(); };
+    }
 }
 
 std::future<Ice::ConnectionPtr>
 Ice::ObjectPrx::ice_getConnectionAsync() const
 {
-    auto outAsync = std::make_shared<ProxyGetConnectionPromise>(*this);
-    _iceI_getConnection(outAsync);
-    return outAsync->getFuture();
+    // A fixed proxy is bound to a single connection: return this connection as is, whatever its state.
+    if (auto fixedReference = dynamic_pointer_cast<FixedReference>(_reference))
+    {
+        promise<Ice::ConnectionPtr> p;
+        p.set_value(fixedReference->fixedConnection());
+        return p.get_future();
+    }
+    else
+    {
+        auto outAsync = std::make_shared<ProxyGetConnectionPromise>(*this);
+        _iceI_getConnection(outAsync);
+        return outAsync->getFuture();
+    }
 }
 
 void