zeroc-ice 3.8.0 → 3.8.2

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

@@ -33,7 +33,7 @@ IncomingRequest::IncomingRequest(
         {
             throw MarshalException{__FILE__, __LINE__, "received facet path with more than one element"};
         }
-        _current.facet = facetPath[0];
+        _current.facet = std::move(facetPath[0]);
     }
 
     inputStream.read(_current.operation, false);

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

@@ -143,8 +143,6 @@ Ice::InputStream::operator=(InputStream&& other) noexcept
         _closure = other._closure;
         _startSeq = other._startSeq;
         _minSeqSize = other._minSeqSize;
-        _startSeq = -1;
-        _minSeqSize = 0;
         resetEncapsulation();
 
         // Reset other to its default state.
@@ -430,14 +428,19 @@ Ice::InputStream::readAndCheckSeqSize(int minSize)
     // the estimated remaining buffer size. This estimation is based on
     // the minimum size of the enclosing sequences, it's _minSeqSize.
     //
-    if (_startSeq == -1 || i > (b.begin() + _startSeq + _minSeqSize))
+    // 'sz' is peer-controlled (up to INT32_MAX), so we compute the minimum size of this sequence in
+    // 64-bit: 'sz * minSize' would otherwise overflow a 32-bit int and bypass the bounds check below.
+    int64_t minSeqSize = static_cast<int64_t>(sz) * minSize;
+
+    // '_startSeq + _minSeqSize' does not overflow: on the previous call, the bounds check below
+    // established this sum is <= b.size(), itself smaller than INT32_MAX.
+    if (_startSeq == -1 || (i - b.begin()) > _startSeq + _minSeqSize)
     {
         _startSeq = static_cast<int>(i - b.begin());
-        _minSeqSize = sz * minSize;
     }
     else
     {
-        _minSeqSize += sz * minSize;
+        minSeqSize += _minSeqSize;
     }
 
     //
@@ -445,11 +448,13 @@ Ice::InputStream::readAndCheckSeqSize(int minSize)
     // possibly enclosed sequences), something is wrong with the marshaled
     // data: it's claiming having more data that what is possible to read.
     //
-    if (_startSeq + _minSeqSize > static_cast<int>(b.size()))
+    if (_startSeq + minSeqSize > static_cast<int64_t>(b.size()))
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
 
+    // minSeqSize is now known to be <= b.size(), itself smaller than INT32_MAX.
+    _minSeqSize = static_cast<int>(minSeqSize);
     return sz;
 }
 
@@ -476,15 +481,7 @@ Ice::InputStream::read(std::vector<byte>& v)
 {
     std::pair<const byte*, const byte*> p;
     read(p);
-    if (p.first != p.second)
-    {
-        v.resize(static_cast<size_t>(p.second - p.first));
-        copy(p.first, p.second, v.begin());
-    }
-    else
-    {
-        v.clear();
-    }
+    v.assign(p.first, p.second);
 }
 
 void
@@ -1144,6 +1141,13 @@ Ice::InputStream::readOptImpl(int32_t readTag, OptionalFormat expectedFormat)
 
         auto format = static_cast<OptionalFormat>(v & 0x07); // First 3 bits.
         auto tag = static_cast<int32_t>(v >> 3);
+        if (tag > 30)
+        {
+            // We check for '> 30' instead of '> 29' because 30 is special sentinel tag, handled by the next block.
+            ostringstream os;
+            os << "invalid tag '" << tag << "': tags larger than 29 must be encoded as a size";
+            throw MarshalException(__FILE__, __LINE__, os.str());
+        }
         if (tag == 30)
         {
             tag = readSize();
@@ -1918,7 +1922,11 @@ Ice::InputStream::EncapsDecoder11::startSlice()
     if (_current->sliceFlags & FLAG_HAS_SLICE_SIZE)
     {
         _stream->read(_current->sliceSize);
-        if (_current->sliceSize < 4)
+        // A slice with optional members carries at least the 1-byte end marker in its body, so its
+        // size (which includes the 4-byte size field) must be >= 5. We rely on this in skipSlice's
+        // slice-preservation logic, which excludes the end marker by stepping back one byte.
+        int32_t minSliceSize = (_current->sliceFlags & FLAG_HAS_OPTIONAL_MEMBERS) ? 5 : 4;
+        if (_current->sliceSize < minSliceSize)
         {
             throw MarshalException{__FILE__, __LINE__, endOfBufferMessage};
         }
@@ -2076,7 +2084,10 @@ Ice::InputStream::EncapsDecoder11::readOptional(int32_t readTag, Ice::OptionalFo
 int32_t
 Ice::InputStream::EncapsDecoder11::readInstance(int32_t index, const PatchFunc& patchFunc, void* patchAddr)
 {
-    assert(index > 0);
+    if (index <= 0)
+    {
+        throw MarshalException(__FILE__, __LINE__, "invalid class instance index");
+    }
 
     if (index > 1)
     {

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

@@ -48,7 +48,7 @@
 #        endif
 #    endif
 
-#    if !defined(__FreeBSD__)
+#    if __has_include(<execinfo.h>)
 #        include <cstdint>
 #        include <execinfo.h>
 #        define ICE_BACKTRACE

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

@@ -570,6 +570,12 @@ Ice::TwowayOnlyException::ice_id() const noexcept
     return "::Ice::TwowayOnlyException";
 }
 
+const char*
+Ice::OnewayOnlyException::ice_id() const noexcept
+{
+    return "::Ice::OnewayOnlyException";
+}
+
 const char*
 Ice::PropertyException::ice_id() const noexcept
 {

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

@@ -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