zeroc-ice 3.8.1 → 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.
@@ -817,7 +817,7 @@ OutgoingAsync::prepare(string_view operation, OperationMode mode, const Context&
     }
     else
     {
-        string facet = ref->getFacet();
+        const string& facet = ref->getFacet();
         _os.write(&facet, &facet + 1);
     }
 

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