zeroc-ice 3.8.2 → 3.8.3

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

@@ -0,0 +1,40 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TCP_BUF_SIZE_H
+#define ICE_TCP_BUF_SIZE_H
+
+#include "Ice/Properties.h"
+
+#include <cstdint>
+
+namespace IceInternal
+{
+    // The TCP send and receive buffer sizes, as configured by the Ice.TCP.SndSize and Ice.TCP.RcvSize properties.
+    class TcpBufSize
+    {
+    public:
+        // Reads the Ice.TCP.RcvSize and Ice.TCP.SndSize properties. Throws PropertyException if a value is not a
+        // valid integer.
+        explicit TcpBufSize(const Ice::PropertiesPtr& properties)
+            : _rcvSize(properties->getPropertyAsIntWithDefault("Ice.TCP.RcvSize", dfltBufSize)),
+              _sndSize(properties->getPropertyAsIntWithDefault("Ice.TCP.SndSize", dfltBufSize))
+        {
+        }
+
+        [[nodiscard]] std::int32_t rcvSize() const noexcept { return _rcvSize; }
+        [[nodiscard]] std::int32_t sndSize() const noexcept { return _sndSize; }
+
+    private:
+        // By default, on Windows we use a 128KB buffer size. On Unix platforms, we use the system defaults.
+#ifdef _WIN32
+        static constexpr std::int32_t dfltBufSize = 128 * 1024;
+#else
+        static constexpr std::int32_t dfltBufSize = 0;
+#endif
+
+        std::int32_t _rcvSize;
+        std::int32_t _sndSize;
+    };
+}
+
+#endif

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

@@ -22,7 +22,9 @@ using namespace IceInternal;
 TransceiverPtr
 IceInternal::TcpConnector::connect()
 {
-    return make_shared<TcpTransceiver>(_instance, make_shared<StreamSocket>(_instance, _proxy, _addr, _sourceAddr));
+    return make_shared<TcpTransceiver>(
+        _instance,
+        make_shared<StreamSocket>(_instance, _proxy, _addr, _sourceAddr, _bufSize));
 }
 
 int16_t
@@ -120,7 +122,8 @@ IceInternal::TcpConnector::TcpConnector(
       _proxy(std::move(proxy)),
       _sourceAddr(sourceAddr),
       _timeout(timeout),
-      _connectionId(std::move(connectionId))
+      _connectionId(std::move(connectionId)),
+      _bufSize(_instance->properties())
 {
 }
 

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

@@ -6,6 +6,7 @@
 #include "Connector.h"
 #include "Network.h"
 #include "ProtocolInstanceF.h"
+#include "TcpBufSize.h"
 #include "TransceiverF.h"
 
 namespace IceInternal
@@ -30,6 +31,7 @@ namespace IceInternal
         const Address _sourceAddr;
         const std::int32_t _timeout;
         const std::string _connectionId;
+        const TcpBufSize _bufSize;
     };
 }
 

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

@@ -113,6 +113,10 @@ IceInternal::TcpTransceiver::getInfo(bool incoming, string adapterName, string c
         string remoteAddress;
         int remotePort;
         fdToAddressAndPort(_stream->fd(), localAddress, localPort, remoteAddress, remotePort);
+
+        int rcvSize = getRecvBufferSizeNoThrow(_stream->fd());
+        int sndSize = getSendBufferSizeNoThrow(_stream->fd());
+
         return make_shared<TCPConnectionInfo>(
             incoming,
             std::move(adapterName),
@@ -121,8 +125,8 @@ IceInternal::TcpTransceiver::getInfo(bool incoming, string adapterName, string c
             localPort,
             std::move(remoteAddress),
             remotePort,
-            getRecvBufferSize(_stream->fd()),
-            getSendBufferSize(_stream->fd()));
+            rcvSize,
+            sndSize);
     }
 }
 

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

@@ -468,12 +468,6 @@ IceInternal::ThreadPool::joinWithAllThreads()
     _selector.destroy();
 }
 
-string
-IceInternal::ThreadPool::prefix() const
-{
-    return _prefix;
-}
-
 void
 IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
 {
@@ -554,7 +548,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                 {
                     //
                     // If the handler called ioCompleted(), we re-enable the handler in
-                    // case it was disabled and we decrease the number of thread in use.
+                    // case it was disabled and we decrease the number of threads in use.
                     //
                     if (_serialize && current._handler.get() != _workQueue.get())
                     {
@@ -805,7 +799,7 @@ IceInternal::ThreadPool::ioCompleted(ThreadPoolCurrent& current)
         }
     }
 
-    return _serialize && current._handler.get() != _workQueue.get();
+    return _sizeMax > 1 && _serialize && current._handler.get() != _workQueue.get();
 }
 
 #if defined(ICE_USE_IOCP)

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

@@ -73,8 +73,6 @@ namespace IceInternal
 
         void joinWithAllThreads();
 
-        [[nodiscard]] std::string prefix() const;
-
     private:
         ThreadPool(const InstancePtr&, std::string, int);
         void initialize();

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

@@ -19,6 +19,10 @@ Timer::destroy()
     {
         throw std::runtime_error("a timer task cannot destroy the timer");
     }
+    // Destroy the tasks after the lock is released and the worker joined: a task's destructor can re-enter the timer
+    // via cancel() (e.g. when it holds the last reference to a connection), which would deadlock while _mutex is held.
+    std::set<Token> tokens;
+    std::map<TimerTaskPtr, std::chrono::steady_clock::time_point> tasks;
     {
         std::lock_guard lock(_mutex);
         if (_destroyed)
@@ -26,8 +30,8 @@ Timer::destroy()
             return;
         }
         _destroyed = true;
-        _tasks.clear();
-        _tokens.clear();
+        tokens.swap(_tokens);
+        tasks.swap(_tasks);
         _condition.notify_one();
     }
     _worker.join();
@@ -135,7 +139,7 @@ Timer::run()
             {
                 // If the task is not a repeated task, clear the task reference now rather than
                 // in the synchronization block above. Clearing the task reference might end up
-                // calling user code which could trigger a deadlock. See also issue #352.
+                // calling user code which could trigger a deadlock.
                 token.task = nullptr;
             }
         }

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

@@ -2,8 +2,7 @@
 
 #include "Ice/UUID.h"
 
-// We use a high quality random number generator
-// (std::random_device) to generate "version 4" UUIDs, as described in
+// We use the operating system's CSPRNG (see Random.h) to generate "version 4" UUIDs, as described in
 // http://www.ietf.org/internet-drafts/draft-mealling-uuid-urn-00.txt
 #include "Random.h"
 

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

@@ -227,7 +227,10 @@ IceInternal::UdpEndpointI::options() const
     if (_mcastInterface.length() > 0)
     {
         s << " --interface ";
-        bool addQuote = _mcastInterface.find(':') != string::npos;
+        // Quote the interface if it contains a character that would be re-parsed as a separator: whitespace, on
+        // which the endpoint parser splits options (e.g. a Windows adapter name like "Ethernet 2"), or ':', on
+        // which the proxy-string parser splits endpoints (e.g. an IPv6 interface address).
+        bool addQuote = _mcastInterface.find_first_of(" :\t\n\r") != string::npos;
         if (addQuote)
         {
             s << "\"";

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

@@ -69,36 +69,49 @@ IceInternal::UdpTransceiver::closing(bool, exception_ptr)
 void
 IceInternal::UdpTransceiver::close()
 {
-    assert(_fd != INVALID_SOCKET);
-    SOCKET fd = _fd;
-    _fd = INVALID_SOCKET;
-    closeSocket(fd);
+    // _fd can be INVALID_SOCKET when bind failed: the bind/setup helper that threw already closed the socket, and
+    // bind()'s catch reset _fd.
+    if (_fd != INVALID_SOCKET)
+    {
+        closeSocketNoThrow(_fd);
+        _fd = INVALID_SOCKET;
+    }
 }
 
 EndpointIPtr
 IceInternal::UdpTransceiver::bind()
 {
-    if (isMulticast(_addr))
+    try
     {
-        // Set SO_REUSEADDR socket option to allow multiple sockets to bind to the same multicast address.
-        setReuseAddress(_fd, true);
-        _mcastAddr = _addr;
+        if (isMulticast(_addr))
+        {
+            // Set SO_REUSEADDR socket option to allow multiple sockets to bind to the same multicast address.
+            setReuseAddress(_fd, true);
+            _mcastAddr = _addr;
 
 #ifdef _WIN32
-        // Windows does not allow binding to the mcast address itself so we bind to INADDR_ANY instead.
-        const_cast<Address&>(_addr) = getAddressForServer("", _port, getProtocolSupport(_addr), false, false);
+            // Windows does not allow binding to the mcast address itself so we bind to INADDR_ANY instead.
+            const_cast<Address&>(_addr) = getAddressForServer("", _port, getProtocolSupport(_addr), false, false);
 #endif
 
-        const_cast<Address&>(_addr) = doBind(_fd, _addr, _mcastInterface);
-        if (getPort(_mcastAddr) == 0)
+            const_cast<Address&>(_addr) = doBind(_fd, _addr, _mcastInterface);
+            if (getPort(_mcastAddr) == 0)
+            {
+                setPort(_mcastAddr, getPort(_addr));
+            }
+            setMcastGroup(_fd, _mcastAddr, _mcastInterface);
+        }
+        else
         {
-            setPort(_mcastAddr, getPort(_addr));
+            const_cast<Address&>(_addr) = doBind(_fd, _addr);
         }
-        setMcastGroup(_fd, _mcastAddr, _mcastInterface);
     }
-    else
+    catch (...)
     {
-        const_cast<Address&>(_addr) = doBind(_fd, _addr);
+        // setReuseAddress/doBind/setMcastGroup close the socket before throwing, so reset _fd to avoid a double
+        // close when close() runs during cleanup. Mirrors TcpAcceptor::listen.
+        _fd = INVALID_SOCKET;
+        throw;
     }
 
     _bound = true;
@@ -173,6 +186,18 @@ repeat:
             return SocketOperationWrite;
         }
 
+#ifndef _WIN32
+        // ENOBUFS means the local send buffer is momentarily full. This is routine on macOS/BSD during bursts
+        // and is a transient local condition rather than a connection failure. UDP is best-effort, so drop this
+        // datagram instead of throwing (throwing would needlessly close the connection). Limited to non-Windows:
+        // there noBuffers() also matches WSAEFAULT, which must not be silently dropped.
+        if (noBuffers())
+        {
+            buf.i = buf.b.end();
+            return SocketOperationNone;
+        }
+#endif
+
         throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
@@ -561,10 +586,73 @@ IceInternal::UdpTransceiver::checkSendSize(const Buffer& buf)
     }
 }
 
+//
+// Set UDP receive and send buffer sizes.
+//
 void
 IceInternal::UdpTransceiver::setBufferSize(int rcvSize, int sndSize)
 {
-    setBufSize(rcvSize, sndSize);
+    assert(_fd != INVALID_SOCKET);
+
+    try
+    {
+        // The default size is the size currently configured on the socket. We don't set the buffer size when the
+        // requested size matches the default: re-setting it would needlessly grow the buffer on systems (e.g. Linux)
+        // where the kernel doubles the value on each set.
+
+        int rcvDefault = getRecvBufferSize(_fd);
+        rcvSize = adjustBufferSize(rcvSize, rcvDefault, "Ice.UDP.RcvSize");
+        if (rcvSize == rcvDefault)
+        {
+            _rcvSize = rcvDefault;
+        }
+        else
+        {
+            // The kernel silently adjusts the size to an acceptable value, so read it back to get the size actually
+            // set.
+            setRecvBufferSize(_fd, rcvSize);
+            _rcvSize = getRecvBufferSize(_fd);
+            if (_rcvSize < rcvSize)
+            {
+                // The kernel reduced the requested size; warn unless we already warned for this size.
+                BufSizeWarnInfo winfo = _instance->getBufSizeWarn(UDPEndpointType);
+                if (!winfo.rcvWarn || winfo.rcvSize != rcvSize)
+                {
+                    Warning out(_instance->logger());
+                    out << "UDP receive buffer size: requested size of " << rcvSize << " adjusted to " << _rcvSize;
+                    _instance->setRcvBufSizeWarn(UDPEndpointType, rcvSize);
+                }
+            }
+        }
+
+        int sndDefault = getSendBufferSize(_fd);
+        sndSize = adjustBufferSize(sndSize, sndDefault, "Ice.UDP.SndSize");
+        if (sndSize == sndDefault)
+        {
+            _sndSize = sndDefault;
+        }
+        else
+        {
+            setSendBufferSize(_fd, sndSize);
+            _sndSize = getSendBufferSize(_fd);
+            if (_sndSize < sndSize)
+            {
+                BufSizeWarnInfo winfo = _instance->getBufSizeWarn(UDPEndpointType);
+                if (!winfo.sndWarn || winfo.sndSize != sndSize)
+                {
+                    Warning out(_instance->logger());
+                    out << "UDP send buffer size: requested size of " << sndSize << " adjusted to " << _sndSize;
+                    _instance->setSndBufSizeWarn(UDPEndpointType, sndSize);
+                }
+            }
+        }
+    }
+    catch (const SocketException&)
+    {
+        // The failing call closed the fd.
+        clearFd();
+        throw;
+    }
 }
 
 int
@@ -590,8 +678,15 @@ IceInternal::UdpTransceiver::UdpTransceiver(
       _write(SocketOperationWrite)
 #endif
 {
+    int rcvSize = _instance->properties()->getIcePropertyAsInt("Ice.UDP.RcvSize");
+    int sndSize = _instance->properties()->getIcePropertyAsInt("Ice.UDP.SndSize");
     _fd = createSocket(true, _addr);
-    setBufSize(-1, -1);
+
+    // Sets _rcvSize and _sndSize:
+    setBufferSize(rcvSize, sndSize);
+    assert(_rcvSize >= _udpOverhead + headerSize);
+    assert(_sndSize >= _udpOverhead + headerSize);
+
     setBlock(_fd, false);
 
     _mcastAddr.saStorage.ss_family = AF_UNSPEC;
@@ -614,8 +709,8 @@ IceInternal::UdpTransceiver::UdpTransceiver(
     }
 
     //
-    // In general, connecting a datagram socket should be non-blocking as this just setups
-    // the default destination address for the socket. However, on some OS, connect sometime
+    // In general, connecting a datagram socket should be non-blocking as this just sets up
+    // the default destination address for the socket. However, on some OS, connect sometimes
     // returns EWOULDBLOCK. If that's the case, we keep the state as StateNeedConnect. This
     // will make sure the transceiver is notified when the socket is ready for sending (see
     // the initialize() implementation).
@@ -658,8 +753,15 @@ IceInternal::UdpTransceiver::UdpTransceiver(
       _write(SocketOperationWrite)
 #endif
 {
+    int rcvSize = _instance->properties()->getIcePropertyAsInt("Ice.UDP.RcvSize");
+    int sndSize = _instance->properties()->getIcePropertyAsInt("Ice.UDP.SndSize");
     _fd = createServerSocket(true, _addr, instance->protocolSupport());
-    setBufSize(-1, -1);
+
+    // Sets _rcvSize and _sndSize:
+    setBufferSize(rcvSize, sndSize);
+    assert(_rcvSize >= _udpOverhead + headerSize);
+    assert(_sndSize >= _udpOverhead + headerSize);
+
     setBlock(_fd, false);
 
     memset(&_mcastAddr.saStorage, 0, sizeof(sockaddr_storage));
@@ -670,112 +772,23 @@ IceInternal::UdpTransceiver::UdpTransceiver(
 
 IceInternal::UdpTransceiver::~UdpTransceiver() { assert(_fd == INVALID_SOCKET); }
 
-//
-// Set UDP receive and send buffer sizes.
-//
-void
-IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
+int
+IceInternal::UdpTransceiver::adjustBufferSize(int sizeRequested, int defaultSize, string_view prop)
 {
-    assert(_fd != INVALID_SOCKET);
-
-    for (int i = 0; i < 2; ++i)
+    if (sizeRequested == 0)
     {
-        bool isSnd;
-        string direction;
-        string prop;
-        int* addr;
-        int dfltSize;
-        int sizeRequested;
-        if (i == 0)
-        {
-            isSnd = false;
-            direction = "receive";
-            prop = "Ice.UDP.RcvSize";
-            addr = &_rcvSize;
-            dfltSize = getRecvBufferSize(_fd);
-            sizeRequested = rcvSize;
-        }
-        else
-        {
-            isSnd = true;
-            direction = "send";
-            prop = "Ice.UDP.SndSize";
-            addr = &_sndSize;
-            dfltSize = getSendBufferSize(_fd);
-            sizeRequested = sndSize;
-        }
-
-        if (dfltSize <= 0)
-        {
-            dfltSize = _maxPacketSize;
-        }
-        *addr = dfltSize;
-
-        //
-        // Get property for buffer size if size not passed in.
-        //
-        if (sizeRequested == -1)
-        {
-            sizeRequested = _instance->properties()->getPropertyAsIntWithDefault(prop, dfltSize);
-        }
-        //
-        // Check for sanity.
-        //
-        if (sizeRequested < (_udpOverhead + headerSize))
-        {
-            Warning out(_instance->logger());
-            out << "Invalid " << prop << " value of " << sizeRequested << " adjusted to " << dfltSize;
-            sizeRequested = dfltSize;
-        }
-
-        if (sizeRequested != dfltSize)
-        {
-            //
-            // Try to set the buffer size. The kernel will silently adjust
-            // the size to an acceptable value. Then read the size back to
-            // get the size that was actually set.
-            //
-            if (i == 0)
-            {
-                setRecvBufferSize(_fd, sizeRequested);
-                *addr = getRecvBufferSize(_fd);
-            }
-            else
-            {
-                setSendBufferSize(_fd, sizeRequested);
-                *addr = getSendBufferSize(_fd);
-            }
+        // 0 (the property default) means we want the default size.
+        return defaultSize;
+    }
 
-            //
-            // Warn if the size that was set is less than the requested size and
-            // we have not already warned.
-            //
-            if (*addr == 0) // set buffer size not supported.
-            {
-                *addr = sizeRequested;
-            }
-            else if (*addr < sizeRequested)
-            {
-                BufSizeWarnInfo winfo = _instance->getBufSizeWarn(UDPEndpointType);
-                if ((isSnd && (!winfo.sndWarn || winfo.sndSize != sizeRequested)) ||
-                    (!isSnd && (!winfo.rcvWarn || winfo.rcvSize != sizeRequested)))
-                {
-                    Warning out(_instance->logger());
-                    out << "UDP " << direction << " buffer size: requested size of " << sizeRequested << " adjusted to "
-                        << *addr;
-
-                    if (isSnd)
-                    {
-                        _instance->setSndBufSizeWarn(UDPEndpointType, sizeRequested);
-                    }
-                    else
-                    {
-                        _instance->setRcvBufSizeWarn(UDPEndpointType, sizeRequested);
-                    }
-                }
-            }
-        }
+    if (sizeRequested < _udpOverhead + headerSize)
+    {
+        Warning out(_instance->logger());
+        out << "Invalid " << prop << " value of " << sizeRequested << " adjusted to " << defaultSize;
+        return defaultSize;
     }
+
+    return sizeRequested;
 }
 
 //

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

@@ -9,7 +9,6 @@
 
 namespace IceInternal
 {
-    class UdpEndpoint;
 
     class UdpTransceiver final : public Transceiver,
                                  public NativeInfo,
@@ -57,7 +56,7 @@ namespace IceInternal
         [[nodiscard]] int effectivePort() const;
 
     private:
-        void setBufSize(int, int);
+        int adjustBufferSize(int sizeRequested, int defaultSize, std::string_view prop);
 
         UdpEndpointIPtr _endpoint;
         const ProtocolInstancePtr _instance;
@@ -74,8 +73,8 @@ namespace IceInternal
 #endif
 
         State _state;
-        int _rcvSize;
-        int _sndSize;
+        int _rcvSize{0};
+        int _sndSize{0};
         static const int _udpOverhead;
         static const int _maxPacketSize;