zeroc-ice 3.8.1 → 3.8.2

data/dist/ice/cpp/include/generated/IceLocatorDiscovery/Lookup.h

@@ -1,6 +1,6 @@
 // Copyright (c) ZeroC, Inc.
 
-// slice2cpp version 3.8.1
+// slice2cpp version 3.8.2
 // <auto-generated>Generated from Slice file 'Lookup.ice'.</auto-generated>
 // clang-format off
 
@@ -18,7 +18,7 @@
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 1
+#   if ICE_INT_VERSION % 100 < 2
 #       error Ice patch level mismatch!
 #   endif
 #endif

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

@@ -107,13 +107,15 @@ CollocatedRequestHandler::invokeAsyncRequest(OutgoingAsyncBase* outAsync, int ba
             //
             outAsync->cancelable(shared_from_this());
 
+            auto outAsyncPtr = outAsync->shared_from_this();
+
             if (_response)
             {
                 requestId = ++_requestId;
-                _asyncRequests.insert(make_pair(requestId, outAsync->shared_from_this()));
+                _asyncRequests.insert(make_pair(requestId, outAsyncPtr));
             }
 
-            _sendAsyncRequests.insert(make_pair(outAsync->shared_from_this(), requestId));
+            _sendAsyncRequests.insert(make_pair(outAsyncPtr, requestId));
         }
 
         OutputStream* os = outAsync->getOs();
@@ -348,7 +350,7 @@ CollocatedRequestHandler::sendResponse(OutgoingResponse response)
                     is.swap(*q->second->getIs());
                     if (q->second->response())
                     {
-                        outAsync = q->second;
+                        outAsync = std::move(q->second);
                     }
                     _asyncRequests.erase(q);
                 }

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

@@ -12,7 +12,8 @@
 #include "Ice/Properties.h"
 #include "IdleTimeoutTransceiverDecorator.h"
 #include "Instance.h"
-#include "ObjectAdapterI.h"   // For getThreadPool()
+#include "ObjectAdapterI.h" // For getThreadPool()
+#include "OutgoingResponseInternal.h"
 #include "ReferenceFactory.h" // For createProxy().
 #include "RequestHandler.h"   // For RetryException
 #include "ThreadPool.h"
@@ -1012,7 +1013,7 @@ Ice::ConnectionI::setAdapter(const ObjectAdapterPtr& adapter)
     {
         // Go through the adapter to set the adapter on this connection
         // to ensure the object adapter is still active.
-        dynamic_pointer_cast<ObjectAdapterI>(adapter)->setAdapterOnConnection(shared_from_this());
+        static_pointer_cast<ObjectAdapterI>(adapter)->setAdapterOnConnection(shared_from_this());
     }
     else
     {
@@ -2717,7 +2718,7 @@ Ice::ConnectionI::sendNextMessages(vector<OutgoingMessage>& callbacks)
                 _writeStream.swap(*message->stream);
                 if (message->sent())
                 {
-                    callbacks.push_back(*message);
+                    callbacks.push_back(std::move(*message));
                 }
             }
             _sendStreams.pop_front();
@@ -2850,7 +2851,7 @@ Ice::ConnectionI::sendMessage(OutgoingMessage& message)
     // message was queued.
     if (!_sendStreams.empty())
     {
-        _sendStreams.push_back(message);
+        _sendStreams.push_back(std::move(message));
         _sendStreams.back().adopt(nullptr);
         return AsyncStatusQueued;
     }
@@ -2895,7 +2896,7 @@ Ice::ConnectionI::sendMessage(OutgoingMessage& message)
             return status;
         }
 
-        _sendStreams.push_back(message);
+        _sendStreams.push_back(std::move(message));
         _sendStreams.back().adopt(&stream);
     }
     else
@@ -2945,7 +2946,7 @@ Ice::ConnectionI::sendMessage(OutgoingMessage& message)
             return status;
         }
 
-        _sendStreams.push_back(message);
+        _sendStreams.push_back(std::move(message));
         _sendStreams.back().adopt(nullptr); // Adopt the stream.
 #ifdef ICE_HAS_BZIP2
     }
@@ -3260,6 +3261,22 @@ Ice::ConnectionI::parseMessage(int32_t& upcallCount, function<bool(InputStream&)
                             "received batch request with " + to_string(requestCount) + " batches"};
                     }
 
+                    // A batched request occupies at least 12 bytes on the wire (a 2-byte identity, a
+                    // 1-byte facet path, a 1-byte operation name, a 1-byte operation mode, a 1-byte
+                    // context, and a 6-byte parameters encapsulation). Reject a count larger than the
+                    // remaining message data could possibly hold. The message size is already capped
+                    // at Ice.MessageSizeMax (<= INT32_MAX bytes), so this also keeps requestCount well
+                    // within range when it is accumulated into the dispatch counters below.
+                    constexpr int32_t minBatchRequestSize = 12;
+                    if (requestCount > (stream.b.end() - stream.i) / minBatchRequestSize)
+                    {
+                        throw MarshalException{
+                            __FILE__,
+                            __LINE__,
+                            "received batch request with " + to_string(requestCount) +
+                                " batches, more than the message can contain"};
+                    }
+
                     upcall = [self = shared_from_this(), requestCount, adapter, compress](InputStream& messageStream)
                     {
                         self->dispatchAll(messageStream, requestCount, requestId, compress, adapter);
@@ -3297,7 +3314,7 @@ Ice::ConnectionI::parseMessage(int32_t& upcallCount, function<bool(InputStream&)
 
                 if (q != _asyncRequests.end())
                 {
-                    auto outAsync = q->second;
+                    auto outAsync = std::move(q->second);
 
                     if (q == _asyncRequestsHint)
                     {
@@ -3437,9 +3454,10 @@ Ice::ConnectionI::dispatchAll(
             {
                 // Received request on a connection without an object adapter.
                 sendResponse(
-                    makeOutgoingResponse(
+                    makeOutgoingResponseCore(
                         make_exception_ptr(ObjectNotExistException{__FILE__, __LINE__}),
-                        request.current()),
+                        request.current(),
+                        _instance.get()),
                     0);
             }
 

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

@@ -72,7 +72,7 @@ namespace Ice
     public:
         std::shared_ptr<ConnectionI> shared_from_this()
         {
-            return std::dynamic_pointer_cast<ConnectionI>(IceInternal::EventHandler::shared_from_this());
+            return std::static_pointer_cast<ConnectionI>(IceInternal::EventHandler::shared_from_this());
         }
 
         struct OutgoingMessage

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

@@ -195,34 +195,6 @@ IceInternal::mkdir(const string& path, int)
     return ::_wmkdir(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
 }
 
-FILE*
-IceInternal::fopen(const string& path, const string& mode)
-{
-    //
-    // Don't need to use a wide string converter, the wide strings are directly passed
-    // to Windows API.
-    //
-    const Ice::StringConverterPtr converter = Ice::getProcessStringConverter();
-    return ::_wfopen(stringToWstring(path, converter).c_str(), stringToWstring(mode, converter).c_str());
-}
-
-int
-IceInternal::open(const string& path, int flags)
-{
-    //
-    // Don't need to use a wide string converter, the wide string is directly passed
-    // to Windows API.
-    //
-    if (flags & _O_CREAT)
-    {
-        return ::_wopen(stringToWstring(path, Ice::getProcessStringConverter()).c_str(), flags, _S_IREAD | _S_IWRITE);
-    }
-    else
-    {
-        return ::_wopen(stringToWstring(path, Ice::getProcessStringConverter()).c_str(), flags);
-    }
-}
-
 int
 IceInternal::getcwd(string& cwd)
 {
@@ -249,16 +221,6 @@ IceInternal::unlink(const string& path)
     return _wunlink(stringToWstring(path, Ice::getProcessStringConverter()).c_str());
 }
 
-int
-IceInternal::close(int fd)
-{
-#    ifdef _WIN32
-    return _close(fd);
-#    else
-    return ::close(fd);
-#    endif
-}
-
 IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
 {
     //
@@ -351,26 +313,6 @@ IceInternal::mkdir(const string& path, int perm)
     return ::mkdir(path.c_str(), static_cast<mode_t>(perm));
 }
 
-FILE*
-IceInternal::fopen(const string& path, const string& mode)
-{
-    return ::fopen(path.c_str(), mode.c_str());
-}
-
-int
-IceInternal::open(const string& path, int flags)
-{
-    if (flags & O_CREAT)
-    {
-        // By default, create with rw-rw-rw- modified by the user's umask (same as fopen).
-        return ::open(path.c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
-    }
-    else
-    {
-        return ::open(path.c_str(), flags);
-    }
-}
-
 int
 IceInternal::getcwd(string& cwd)
 {
@@ -389,15 +331,9 @@ IceInternal::unlink(const string& path)
     return ::unlink(path.c_str());
 }
 
-int
-IceInternal::close(int fd)
-{
-    return ::close(fd);
-}
-
 IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
 {
-    _fd = ::open(path.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+    _fd = ::open(path.c_str(), O_RDWR | O_CREAT | O_NOFOLLOW, S_IRUSR | S_IWUSR);
     if (_fd < 0)
     {
         throw FileLockException(__FILE__, __LINE__, errno, _path);
@@ -417,7 +353,7 @@ IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
     if (::fcntl(_fd, F_SETLK, &lock) == -1)
     {
         int err = errno;
-        close(_fd);
+        ::close(_fd);
         throw FileLockException(__FILE__, __LINE__, err, _path);
     }
 
@@ -436,7 +372,7 @@ IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
     if (write(_fd, os.str().c_str(), os.str().size()) == -1)
     {
         int err = errno;
-        close(_fd);
+        ::close(_fd);
         throw FileLockException(__FILE__, __LINE__, err, _path);
     }
 }

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

@@ -84,13 +84,10 @@ namespace IceInternal
     ICE_API int rmdir(const std::string&);
 
     ICE_API int mkdir(const std::string&, int);
-    ICE_API FILE* fopen(const std::string&, const std::string&);
     ICE_API FILE* freopen(const std::string&, const std::string&, FILE*);
-    ICE_API int open(const std::string&, int);
     ICE_API int getcwd(std::string&);
 
     ICE_API int unlink(const std::string&);
-    ICE_API int close(int);
 
     //
     // This class is used to implement process file locking. This class

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

@@ -419,6 +419,10 @@ IceInternal::IPEndpointI::IPEndpointI(ProtocolInstancePtr instance, InputStream*
     s->read(const_cast<string&>(_host), false);
     const_cast<string&>(_normalizedHost) = normalizeIPv6Address(_host);
     s->read(const_cast<int32_t&>(_port));
+    if (_port < 0 || _port > 65535)
+    {
+        throw MarshalException{__FILE__, __LINE__, "port value '" + to_string(_port) + "' is out of range"};
+    }
 }
 
 IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& instance)

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

@@ -428,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;
     }
 
     //
@@ -443,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;
 }
 
@@ -474,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
@@ -1142,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();
@@ -1916,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};
         }
@@ -2074,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/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);
     }