zeroc-ice 3.8.1 → 3.8.2

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

@@ -2,9 +2,11 @@
 
 #include "Ice/OutgoingResponse.h"
 #include "Ice/Demangle.h"
+#include "Ice/Initialize.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/ObjectAdapter.h"
 #include "Ice/UserException.h"
+#include "OutgoingResponseInternal.h"
 #include "Protocol.h"
 
 #include <sstream>
@@ -30,131 +32,6 @@ namespace
         os << "dispatch failed with " << typeId << ": " << what;
         return os.str();
     }
-
-    // The "core" implementation of makeOutgoingResponse for exceptions. Note that it can throw an exception.
-    OutgoingResponse makeOutgoingResponseCore(std::exception_ptr exc, const Current& current)
-    {
-        assert(exc);
-        OutputStream ostr{currentProtocolEncoding};
-
-        if (current.requestId != 0)
-        {
-            ostr.writeBlob(replyHdr, sizeof(replyHdr));
-            ostr.write(current.requestId);
-        }
-        ReplyStatus replyStatus;
-        string exceptionId;
-        string exceptionDetails; // may include the stack trace.
-        string dispatchExceptionMessage;
-
-        try
-        {
-            rethrow_exception(exc);
-        }
-        catch (const UserException& ex)
-        {
-            // We keep exceptionId and exceptionDetails empty.
-
-            replyStatus = ReplyStatus::UserException;
-
-            if (current.requestId != 0)
-            {
-                ostr.write(replyStatus);
-                ostr.startEncapsulation(current.encoding, FormatType::SlicedFormat);
-                ostr.write(ex);
-                ostr.endEncapsulation();
-            }
-        }
-        catch (const DispatchException& ex)
-        {
-            exceptionId = ex.ice_id();
-            exceptionDetails = toString(ex); // can include a stack trace
-            replyStatus = ex.replyStatus();
-
-            if (replyStatus >= ReplyStatus::ObjectNotExist && replyStatus <= ReplyStatus::OperationNotExist)
-            {
-                if (current.requestId != 0) // only marshal response for two-way requests
-                {
-                    // The identity, facet, operation are often left unset at this point.
-                    Identity id;
-                    string facet;
-                    string operation;
-                    if (auto* rfe = dynamic_cast<const RequestFailedException*>(&ex))
-                    {
-                        id = rfe->id();
-                        facet = rfe->facet();
-                        operation = rfe->operation();
-                    }
-                    if (id.name.empty())
-                    {
-                        id = current.id;
-                        facet = current.facet;
-                    }
-                    if (operation.empty())
-                    {
-                        operation = current.operation;
-                    }
-
-                    ostr.write(replyStatus);
-                    ostr.write(id);
-
-                    if (facet.empty())
-                    {
-                        ostr.write(static_cast<string*>(nullptr), static_cast<string*>(nullptr));
-                    }
-                    else
-                    {
-                        ostr.write(&facet, &facet + 1);
-                    }
-                    ostr.write(operation, false);
-                }
-                // dispatchExceptionMessage remains empty: RequestFailedException does not carry a message and we
-                // don't include this message in OutgoingResponse.
-            }
-            else
-            {
-                dispatchExceptionMessage = ex.what();
-                // And marshal this exception after the last catch block.
-            }
-        }
-        catch (const LocalException& ex)
-        {
-            exceptionId = ex.ice_id();
-            exceptionDetails = toString(ex);
-            dispatchExceptionMessage = createDispatchExceptionMessage(exceptionId, ex.what());
-            replyStatus = ReplyStatus::UnknownLocalException;
-        }
-        catch (const std::exception& ex)
-        {
-            exceptionId = demangle(typeid(ex).name());
-            ostringstream str;
-            str << "c++ exception: " << ex.what();
-            exceptionDetails = str.str();
-            dispatchExceptionMessage = createDispatchExceptionMessage(exceptionId, ex.what());
-            replyStatus = ReplyStatus::UnknownException;
-        }
-        catch (...)
-        {
-            exceptionId = "unknown";
-            exceptionDetails = "c++ exception: unknown";
-            dispatchExceptionMessage = createDispatchExceptionMessage(exceptionId, "c++ exception");
-            replyStatus = ReplyStatus::UnknownException;
-        }
-
-        if (current.requestId != 0 && replyStatus > ReplyStatus::OperationNotExist)
-        {
-            // We can't use the generated code to marshal a possibly unknown reply status.
-            ostr.write(static_cast<uint8_t>(replyStatus));
-            ostr.write(dispatchExceptionMessage);
-        }
-
-        return OutgoingResponse{
-            replyStatus,
-            std::move(exceptionId),
-            std::move(exceptionDetails),
-            std::move(ostr),
-            current};
-    }
 } // anonymous namespace
 
 OutgoingResponse::OutgoingResponse(
@@ -264,13 +141,136 @@ Ice::makeOutgoingResponse(bool ok, pair<const byte*, const byte*> encapsulation,
 OutgoingResponse
 Ice::makeOutgoingResponse(std::exception_ptr exc, const Current& current) noexcept
 {
+    IceInternal::Instance* instance = getInstance(current.adapter->getCommunicator()).get();
+
     try
     {
-        return makeOutgoingResponseCore(exc, current);
+        return makeOutgoingResponseCore(exc, current, instance);
     }
     catch (...)
     {
         // This could throw again, but then it's either a bug or we can't allocate anything.
-        return makeOutgoingResponseCore(current_exception(), current);
+        return makeOutgoingResponseCore(current_exception(), current, instance);
     }
 }
+
+// The "core" implementation of makeOutgoingResponse for exceptions. Note that it can throw an exception.
+OutgoingResponse
+Ice::makeOutgoingResponseCore(std::exception_ptr exc, const Current& current, Instance* instance)
+{
+    assert(exc);
+    OutputStream ostr{instance, currentProtocolEncoding};
+
+    if (current.requestId != 0)
+    {
+        ostr.writeBlob(replyHdr, sizeof(replyHdr));
+        ostr.write(current.requestId);
+    }
+    ReplyStatus replyStatus;
+    string exceptionId;
+    string exceptionDetails; // may include the stack trace.
+    string dispatchExceptionMessage;
+
+    try
+    {
+        rethrow_exception(exc);
+    }
+    catch (const UserException& ex)
+    {
+        // We keep exceptionId and exceptionDetails empty.
+
+        replyStatus = ReplyStatus::UserException;
+
+        if (current.requestId != 0)
+        {
+            ostr.write(replyStatus);
+            ostr.startEncapsulation(current.encoding, FormatType::SlicedFormat);
+            ostr.write(ex);
+            ostr.endEncapsulation();
+        }
+    }
+    catch (const DispatchException& ex)
+    {
+        exceptionId = ex.ice_id();
+        exceptionDetails = toString(ex); // can include a stack trace
+        replyStatus = ex.replyStatus();
+
+        if (replyStatus >= ReplyStatus::ObjectNotExist && replyStatus <= ReplyStatus::OperationNotExist)
+        {
+            if (current.requestId != 0) // only marshal response for two-way requests
+            {
+                // The identity, facet, operation are often left unset at this point.
+                Identity id;
+                string facet;
+                string operation;
+                if (auto* rfe = dynamic_cast<const RequestFailedException*>(&ex))
+                {
+                    id = rfe->id();
+                    facet = rfe->facet();
+                    operation = rfe->operation();
+                }
+                if (id.name.empty())
+                {
+                    id = current.id;
+                    facet = current.facet;
+                }
+                if (operation.empty())
+                {
+                    operation = current.operation;
+                }
+
+                ostr.write(replyStatus);
+                ostr.write(id);
+
+                if (facet.empty())
+                {
+                    ostr.write(static_cast<string*>(nullptr), static_cast<string*>(nullptr));
+                }
+                else
+                {
+                    ostr.write(&facet, &facet + 1);
+                }
+                ostr.write(operation, false);
+            }
+            // dispatchExceptionMessage remains empty: RequestFailedException does not carry a message and we
+            // don't include this message in OutgoingResponse.
+        }
+        else
+        {
+            dispatchExceptionMessage = ex.what();
+            // And marshal this exception after the last catch block.
+        }
+    }
+    catch (const LocalException& ex)
+    {
+        exceptionId = ex.ice_id();
+        exceptionDetails = toString(ex);
+        dispatchExceptionMessage = createDispatchExceptionMessage(exceptionId, ex.what());
+        replyStatus = ReplyStatus::UnknownLocalException;
+    }
+    catch (const std::exception& ex)
+    {
+        exceptionId = demangle(typeid(ex).name());
+        ostringstream str;
+        str << "c++ exception: " << ex.what();
+        exceptionDetails = str.str();
+        dispatchExceptionMessage = createDispatchExceptionMessage(exceptionId, ex.what());
+        replyStatus = ReplyStatus::UnknownException;
+    }
+    catch (...)
+    {
+        exceptionId = "unknown";
+        exceptionDetails = "c++ exception: unknown";
+        dispatchExceptionMessage = createDispatchExceptionMessage(exceptionId, "c++ exception");
+        replyStatus = ReplyStatus::UnknownException;
+    }
+
+    if (current.requestId != 0 && replyStatus > ReplyStatus::OperationNotExist)
+    {
+        // We can't use the generated code to marshal a possibly unknown reply status.
+        ostr.write(static_cast<uint8_t>(replyStatus));
+        ostr.write(dispatchExceptionMessage);
+    }
+
+    return OutgoingResponse{replyStatus, std::move(exceptionId), std::move(exceptionDetails), std::move(ostr), current};
+}

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

@@ -0,0 +1,21 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_OUTGOING_RESPONSE_INTERNAL_H
+#define ICE_OUTGOING_RESPONSE_INTERNAL_H
+
+#include "Ice/OutgoingResponse.h"
+
+namespace Ice
+{
+    /// @private
+    /// The "core" implementation of makeOutgoingResponse for exceptions. Note that it can throw an exception.
+    /// @param exception The exception to marshal into the response.
+    /// @param current A reference to the Current object of the request. @c current.adapter can be null here; the
+    /// implementation uses @p instance instead.
+    /// @param instance The IceInternal::Instance object. Not null.
+    /// @return The new response.
+    OutgoingResponse
+    makeOutgoingResponseCore(std::exception_ptr exception, const Current& current, IceInternal::Instance* instance);
+}
+
+#endif

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

@@ -68,6 +68,10 @@ Ice::OutputStream::OutputStream(
       _format(format),
       _currentEncaps(nullptr)
 {
+    if (!_wstringConverter)
+    {
+        _wstringConverter = getProcessWstringConverter();
+    }
 }
 
 Ice::OutputStream::OutputStream(
@@ -85,6 +89,11 @@ Ice::OutputStream::OutputStream(
       _currentEncaps(nullptr)
 {
     b.reset();
+
+    if (!_wstringConverter)
+    {
+        _wstringConverter = getProcessWstringConverter();
+    }
 }
 
 Ice::OutputStream::OutputStream(const CommunicatorPtr& communicator, EncodingVersion encoding)
@@ -104,6 +113,7 @@ Ice::OutputStream::OutputStream(Instance* instance, EncodingVersion encoding)
           instance->getStringConverter(),
           instance->getWstringConverter())
 {
+    assert(_wstringConverter);
 }
 
 Ice::OutputStream::OutputStream(OutputStream&& other) noexcept
@@ -116,6 +126,7 @@ Ice::OutputStream::OutputStream(OutputStream&& other) noexcept
       _currentEncaps(other._currentEncaps)
 {
     // Reset other to its default state.
+    other._wstringConverter = getProcessWstringConverter();
     other._closure = nullptr;
     other._encoding = Encoding_1_1;
     other._format = FormatType::CompactFormat;
@@ -140,6 +151,7 @@ Ice::OutputStream::operator=(OutputStream&& other) noexcept
         _currentEncaps = other._currentEncaps;
 
         // Reset other to its default state.
+        other._wstringConverter = getProcessWstringConverter();
         other._closure = nullptr;
         other._encoding = Encoding_1_1;
         other._format = FormatType::CompactFormat;
@@ -703,13 +715,7 @@ Ice::OutputStream::write(const char*)
 void
 Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
 {
-    StringConverterPtr stringConverter = _stringConverter;
-    if (!stringConverter)
-    {
-        stringConverter = getProcessStringConverter();
-    }
-
-    if (!stringConverter)
+    if (!_stringConverter)
     {
         // No converter installed; write the string as-is (assumed to be UTF-8 already).
         writeSize(static_cast<int32_t>(vsize));
@@ -735,7 +741,7 @@ Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
             auto sizePos = startOneByteSize();
 
             StreamUTF8BufferI buffer(*this);
-            byte* lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
+            byte* lastByte = _stringConverter->toUTF8(vdata, vdata + vsize, buffer);
             if (lastByte != b.end())
             {
                 resize(static_cast<size_t>(lastByte - b.begin()));
@@ -750,7 +756,7 @@ Ice::OutputStream::writeConverted(const char* vdata, size_t vsize)
             auto sizePos = startSize();
 
             StreamUTF8BufferI buffer(*this);
-            byte* lastByte = stringConverter->toUTF8(vdata, vdata + vsize, buffer);
+            byte* lastByte = _stringConverter->toUTF8(vdata, vdata + vsize, buffer);
             if (lastByte != b.end())
             {
                 resize(static_cast<size_t>(lastByte - b.begin()));
@@ -788,68 +794,47 @@ Ice::OutputStream::write(wstring_view v)
         return;
     }
 
-    //
-    // What is the size of the resulting UTF-8 encoded string?
-    // Impossible to tell, so we guess. If we don't guess correctly,
-    // we'll have to fix the mistake afterwards
-    //
+    assert(_wstringConverter);
+
+    // The worst-case expansion for converting a wide string to UTF-8 is 3x or 4x depending on the platform.
+    const size_t factor = sizeof(wchar_t) == 2 ? 3 : 4;
+
     try
     {
-        auto guessedSize = static_cast<int32_t>(v.size());
-        writeSize(guessedSize); // writeSize() only writes the size; it does not reserve any buffer space.
-
-        size_t firstIndex = b.size();
-        StreamUTF8BufferI buffer(*this);
+        // (252 / 3 = 84, 252 / 4 = 63)
+        if (v.size() <= 252 / factor)
+        {
+            // The maximum UTF-8 size is v.size() * factor <= 252, which fits in a 1-byte size encoding.
+            // We use this upper bound to decide the size encoding:
+            //  - If v.size() <= 252 / factor, the converted string is at most 252 bytes, which always fits in a 1-byte
+            //   size.
+            //  - Otherwise, we use the 5-byte size encoding to avoid guessing and memmove fixups.
+            auto sizePos = startOneByteSize();
 
-        byte* lastByte = nullptr;
+            StreamUTF8BufferI buffer(*this);
+            byte* lastByte = _wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
+            if (lastByte != b.end())
+            {
+                resize(static_cast<size_t>(lastByte - b.begin()));
+            }
 
-        WstringConverterPtr wstringConverter = _wstringConverter;
-        if (!wstringConverter)
-        {
-            wstringConverter = getProcessWstringConverter();
+            endOneByteSize(sizePos);
+            return;
         }
-        assert(wstringConverter); // never null
-        lastByte = wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
-
-        if (lastByte != b.end())
+        else
         {
-            resize(static_cast<size_t>(lastByte - b.begin()));
-        }
-        size_t lastIndex = b.size();
-
-        auto actualSize = static_cast<int32_t>(lastIndex - firstIndex);
+            // Write the first byte of the 5-byte size encoding, followed by a 4-byte size placeholder.
+            write(uint8_t(255));
+            auto sizePos = startSize();
 
-        //
-        // Check against the guess
-        //
-        if (guessedSize != actualSize)
-        {
-            if (guessedSize <= 254 && actualSize > 254)
-            {
-                //
-                // Move the UTF-8 sequence 4 bytes further
-                // Use memmove instead of memcpy since the source and destination typically overlap.
-                //
-                resize(b.size() + 4);
-                memmove(b.begin() + firstIndex + 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
-            }
-            else if (guessedSize > 254 && actualSize <= 254)
+            StreamUTF8BufferI buffer(*this);
+            byte* lastByte = _wstringConverter->toUTF8(v.data(), v.data() + v.size(), buffer);
+            if (lastByte != b.end())
             {
-                //
-                // Move the UTF-8 sequence 4 bytes back
-                //
-                memmove(b.begin() + firstIndex - 4, b.begin() + firstIndex, static_cast<size_t>(actualSize));
-                resize(b.size() - 4);
+                resize(static_cast<size_t>(lastByte - b.begin()));
             }
 
-            if (guessedSize <= 254)
-            {
-                rewriteSize(actualSize, b.begin() + firstIndex - 1);
-            }
-            else
-            {
-                rewriteSize(actualSize, b.begin() + firstIndex - 1 - 4);
-            }
+            endSize(sizePos);
         }
     }
     catch (const Ice::IllegalConversionException& ex)

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

@@ -70,6 +70,7 @@ const PropertyArray PropertyNames::ThreadPoolProps
 const Property ObjectAdapterPropsData[] =
 {
     Property{"AdapterId", "", false, false, nullptr},
+    Property{"AllowedOrigins", "", false, false, nullptr},
     Property{"Connection", "", false, false, &PropertyNames::ConnectionProps},
     Property{"Endpoints", "", false, false, nullptr},
     Property{"Locator", "", false, false, &PropertyNames::ProxyProps},
@@ -89,7 +90,7 @@ const PropertyArray PropertyNames::ObjectAdapterProps
     .prefixOnly=true,
     .isOptIn=false,
     .properties=ObjectAdapterPropsData,
-    .length=12
+    .length=13
 };
 
 const Property IcePropsData[] =

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

@@ -53,8 +53,8 @@ Ice::proxyIdentityAndFacetLess(const optional<ObjectPrx>& lhs, const optional<Ob
 {
     if (lhs && rhs)
     {
-        Identity lhsIdentity = lhs->ice_getIdentity();
-        Identity rhsIdentity = rhs->ice_getIdentity();
+        const Identity& lhsIdentity = lhs->ice_getIdentity();
+        const Identity& rhsIdentity = rhs->ice_getIdentity();
 
         if (lhsIdentity < rhsIdentity)
         {
@@ -65,8 +65,8 @@ Ice::proxyIdentityAndFacetLess(const optional<ObjectPrx>& lhs, const optional<Ob
             return false;
         }
 
-        string lhsFacet = lhs->ice_getFacet();
-        string rhsFacet = rhs->ice_getFacet();
+        const string& lhsFacet = lhs->ice_getFacet();
+        const string& rhsFacet = rhs->ice_getFacet();
 
         return lhsFacet < rhsFacet;
     }

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

@@ -549,7 +549,7 @@ IceInternal::FixedReference::changeConnectionId(string) const
 ReferencePtr
 IceInternal::FixedReference::changeConnection(Ice::ConnectionIPtr newConnection) const
 {
-    FixedReferencePtr r = dynamic_pointer_cast<FixedReference>(clone());
+    FixedReferencePtr r = static_pointer_cast<FixedReference>(clone());
     r->_fixedConnection = std::move(newConnection);
     return r;
 }
@@ -787,7 +787,7 @@ IceInternal::RoutableReference::changeEncoding(Ice::EncodingVersion encoding) co
     ReferencePtr r = Reference::changeEncoding(encoding);
     if (r.get() != const_cast<RoutableReference*>(this))
     {
-        LocatorInfoPtr& locInfo = dynamic_pointer_cast<RoutableReference>(r)->_locatorInfo;
+        LocatorInfoPtr& locInfo = static_pointer_cast<RoutableReference>(r)->_locatorInfo;
         if (locInfo && locInfo->getLocator()->ice_getEncodingVersion() != encoding)
         {
             locInfo = getInstance()->locatorManager()->get(locInfo->getLocator()->ice_encodingVersion(encoding));
@@ -809,7 +809,7 @@ IceInternal::RoutableReference::changeCompress(bool newCompress) const
         {
             newEndpoints.push_back(endpoint->compress(newCompress));
         }
-        dynamic_pointer_cast<RoutableReference>(r)->_endpoints = newEndpoints;
+        static_pointer_cast<RoutableReference>(r)->_endpoints = std::move(newEndpoints);
     }
     return r;
 }
@@ -817,7 +817,7 @@ IceInternal::RoutableReference::changeCompress(bool newCompress) const
 ReferencePtr
 IceInternal::RoutableReference::changeEndpoints(vector<EndpointIPtr> newEndpoints) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_endpoints = std::move(newEndpoints);
     r->applyOverrides(r->_endpoints);
     r->_adapterId.clear();
@@ -827,7 +827,7 @@ IceInternal::RoutableReference::changeEndpoints(vector<EndpointIPtr> newEndpoint
 ReferencePtr
 IceInternal::RoutableReference::changeAdapterId(string newAdapterId) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_adapterId = std::move(newAdapterId);
     r->_endpoints.clear();
     return r;
@@ -837,7 +837,7 @@ ReferencePtr
 IceInternal::RoutableReference::changeLocator(optional<LocatorPrx> newLocator) const
 {
     LocatorInfoPtr newLocatorInfo = newLocator ? getInstance()->locatorManager()->get(newLocator.value()) : nullptr;
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_locatorInfo = std::move(newLocatorInfo);
     return r;
 }
@@ -846,7 +846,7 @@ ReferencePtr
 IceInternal::RoutableReference::changeRouter(optional<RouterPrx> newRouter) const
 {
     RouterInfoPtr newRouterInfo = newRouter ? getInstance()->routerManager()->get(newRouter.value()) : nullptr;
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_routerInfo = std::move(newRouterInfo);
     return r;
 }
@@ -854,7 +854,7 @@ IceInternal::RoutableReference::changeRouter(optional<RouterPrx> newRouter) cons
 ReferencePtr
 IceInternal::RoutableReference::changeCollocationOptimized(bool newCollocationOptimized) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_collocationOptimized = newCollocationOptimized;
     return r;
 }
@@ -862,7 +862,7 @@ IceInternal::RoutableReference::changeCollocationOptimized(bool newCollocationOp
 ReferencePtr
 IceInternal::RoutableReference::changeCacheConnection(bool newCache) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_cacheConnection = newCache;
     return r;
 }
@@ -870,7 +870,7 @@ IceInternal::RoutableReference::changeCacheConnection(bool newCache) const
 ReferencePtr
 IceInternal::RoutableReference::changeEndpointSelection(EndpointSelectionType newType) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_endpointSelection = newType;
     return r;
 }
@@ -878,7 +878,7 @@ IceInternal::RoutableReference::changeEndpointSelection(EndpointSelectionType ne
 ReferencePtr
 IceInternal::RoutableReference::changeLocatorCacheTimeout(chrono::milliseconds timeout) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_locatorCacheTimeout = timeout;
     return r;
 }
@@ -886,7 +886,7 @@ IceInternal::RoutableReference::changeLocatorCacheTimeout(chrono::milliseconds t
 ReferencePtr
 IceInternal::RoutableReference::changeConnectionId(string id) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_connectionId = id;
     if (!_endpoints.empty()) // Also override the connection id on the endpoints.
     {
@@ -896,7 +896,7 @@ IceInternal::RoutableReference::changeConnectionId(string id) const
         {
             newEndpoints.push_back(endpoint->connectionId(id));
         }
-        r->_endpoints = newEndpoints;
+        r->_endpoints = std::move(newEndpoints);
     }
     return r;
 }
@@ -1259,7 +1259,7 @@ IceInternal::RoutableReference::getConnectionAsync(
     if (_routerInfo)
     {
         // If we route, we send everything to the router's client proxy endpoints.
-        auto self = dynamic_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
+        auto self = static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
 
         _routerInfo->getClientEndpointsAsync(
             [self = std::move(self), response = std::move(response), exception](vector<EndpointIPtr> endpoints) mutable
@@ -1364,7 +1364,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfoAsync(
     if (_locatorInfo)
     {
         RoutableReferencePtr self =
-            dynamic_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
+            static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
         _locatorInfo->getEndpoints(
             self,
             _locatorCacheTimeout,