zeroc-ice 3.8.1 → 3.8.3

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

@@ -38,8 +38,8 @@ IceInternal::isAbsolutePath(const string& path)
     }
 
 #ifdef _WIN32
-    // We need at least 3 non whitespace character to have
-    // and absolute path
+    // We need at least 3 non whitespace characters to have
+    // an absolute path
     if (i + 3 > size)
     {
         return false;
@@ -195,39 +195,11 @@ 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)
 {
     //
-    // Don't need to use a wide string converter, the wide string come
+    // Don't need to use a wide string converter, the wide string comes
     // from Windows API.
     //
     wchar_t cwdbuf[_MAX_PATH];
@@ -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)
 {
     //
@@ -280,19 +242,19 @@ IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
         throw FileLockException(__FILE__, __LINE__, GetLastError(), _path);
     }
 
-    OVERLAPPED overlaped;
-    overlaped.Internal = 0;
-    overlaped.InternalHigh = 0;
-    overlaped.Offset = 0;
-    overlaped.OffsetHigh = 0;
+    OVERLAPPED overlapped;
+    overlapped.Internal = 0;
+    overlapped.InternalHigh = 0;
+    overlapped.Offset = 0;
+    overlapped.OffsetHigh = 0;
 
 #    if defined(_MSC_VER)
-    overlaped.hEvent = nullptr;
+    overlapped.hEvent = nullptr;
 #    else
-    overlaped.hEvent = 0;
+    overlapped.hEvent = 0;
 #    endif
 
-    if (::LockFileEx(_fd, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, 0, 0, &overlaped) == 0)
+    if (::LockFileEx(_fd, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, 0, 0, &overlapped) == 0)
     {
         ::CloseHandle(_fd);
         throw FileLockException(__FILE__, __LINE__, GetLastError(), _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);
     }
 
@@ -427,7 +363,7 @@ IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
     //
 
     //
-    // Now that we have acquire an exclusive write lock,
+    // Now that we have acquired an exclusive write lock,
     // write the process pid there.
     //
     ostringstream os;
@@ -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/FixedRequestHandler.cpp

@@ -28,7 +28,7 @@ FixedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync,
 }
 
 Ice::ConnectionIPtr
-FixedRequestHandler::getConnection()
+FixedRequestHandler::getConnection() noexcept
 {
     return _connection;
 }

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

@@ -18,7 +18,7 @@ namespace IceInternal
 
         void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) final;
 
-        Ice::ConnectionIPtr getConnection() final;
+        Ice::ConnectionIPtr getConnection() noexcept final;
 
     private:
         Ice::ConnectionIPtr _connection;

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

@@ -12,8 +12,6 @@
 
 namespace IceInternal
 {
-    std::vector<unsigned char> calcSHA1(const std::vector<unsigned char>&);
-
     using HeaderFields = std::map<std::string, std::pair<std::string, std::string>>;
 
     class WebSocketException

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/IdleTimeoutTransceiverDecorator.cpp

@@ -70,15 +70,18 @@ IdleTimeoutTransceiverDecorator::initialize(Buffer& readBuffer, Buffer& writeBuf
 
 IdleTimeoutTransceiverDecorator::~IdleTimeoutTransceiverDecorator()
 {
-    // Since ConnectionI is noexcept, decoratorInit always sets _heartbeatTimerTask.
-    assert(_heartbeatTimerTask);
-    _timer->cancel(_heartbeatTimerTask);
+    // _heartbeatTimerTask remains null when the connection creation fails before decoratorInit is called.
+    if (_heartbeatTimerTask)
+    {
+        _timer->cancel(_heartbeatTimerTask);
+    }
     disableIdleCheck();
 }
 
 void
 IdleTimeoutTransceiverDecorator::close()
 {
+    assert(_heartbeatTimerTask); // close is only called on a connection that completed decoratorInit.
     _timer->cancel(_heartbeatTimerTask);
     disableIdleCheck();
     _decoratee->close();

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

@@ -33,14 +33,12 @@ 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);
 
-    uint8_t mode;
-    inputStream.read(mode);
-    _current.mode = static_cast<OperationMode>(mode);
+    inputStream.read(_current.mode);
 
     int32_t sz = inputStream.readSize();
     while (sz--)

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

@@ -243,7 +243,8 @@ Ice::InputStream::startEncapsulation()
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if (i - sizeof(std::int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -305,7 +306,8 @@ Ice::InputStream::skipEmptyEncapsulation()
     {
         throw MarshalException{__FILE__, __LINE__, to_string(sz) + " is not a valid encapsulation size"};
     }
-    if (i - sizeof(std::int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -342,7 +344,8 @@ Ice::InputStream::readEncapsulation(const std::byte*& v, std::int32_t& sz)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if (i - sizeof(std::int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -368,7 +371,8 @@ Ice::InputStream::skipEncapsulation()
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if (i - sizeof(int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -428,26 +432,33 @@ 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;
     }
 
     //
     // If there isn't enough data to read on the stream for the sequence (and
     // possibly enclosed sequences), something is wrong with the marshaled
-    // data: it's claiming having more data that what is possible to read.
+    // data: it's claiming to have more data than 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 +485,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
@@ -599,7 +602,7 @@ Ice::InputStream::read(vector<int16_t>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int16_t) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(int16_t) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -609,7 +612,7 @@ Ice::InputStream::read(vector<int16_t>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -657,7 +660,7 @@ Ice::InputStream::read(vector<int32_t>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int32_t) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(int32_t) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -669,7 +672,7 @@ Ice::InputStream::read(vector<int32_t>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -725,7 +728,7 @@ Ice::InputStream::read(vector<int64_t>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int64_t) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(int64_t) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -741,7 +744,7 @@ Ice::InputStream::read(vector<int64_t>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -789,7 +792,7 @@ Ice::InputStream::read(vector<float>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(float) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(float) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -801,7 +804,7 @@ Ice::InputStream::read(vector<float>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -857,7 +860,7 @@ Ice::InputStream::read(vector<double>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(double) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(double) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -873,7 +876,7 @@ Ice::InputStream::read(vector<double>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -1142,6 +1145,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 a 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();
@@ -1454,7 +1464,7 @@ Ice::InputStream::EncapsDecoder10::read(PatchFunc patchFunc, void* patchAddr)
     //
     int32_t index;
     _stream->read(index);
-    if (index > 0)
+    if (index > 0 || index == INT32_MIN)
     {
         throw MarshalException(__FILE__, __LINE__, "invalid object id");
     }
@@ -1480,7 +1490,7 @@ Ice::InputStream::EncapsDecoder10::throwException(UserExceptionFactory exception
     assert(_sliceType == NoSlice);
 
     //
-    // User exception with the 1.0 encoding start with a boolean flag
+    // User exceptions with the 1.0 encoding start with a boolean flag
     // that indicates whether or not the exception has classes.
     //
     // This allows reading the pending values even if some part of
@@ -1916,7 +1926,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 +2088,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)
     {
@@ -2089,7 +2106,7 @@ Ice::InputStream::EncapsDecoder11::readInstance(int32_t index, const PatchFunc&
 
     //
     // Get the object ID before we start reading slices. If some
-    // slices are skiped, the indirect object table are still read and
+    // slices are skipped, the indirect object table is still read and
     // might read other instances.
     //
     index = ++_valueIdIndex;