zeroc-ice 3.8.1 → 3.8.3

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;
 

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

@@ -56,7 +56,7 @@ IceInternal::WSAcceptor::accept()
     // WebSocket handshaking is performed in TransceiverI::initialize, since
     // accept must not block.
     //
-    return make_shared<WSTransceiver>(_instance, _delegate->accept());
+    return make_shared<WSTransceiver>(_instance, _delegate->accept(), _allowedOrigins);
 }
 
 string
@@ -77,10 +77,15 @@ IceInternal::WSAcceptor::toDetailedString() const
     return _delegate->toDetailedString();
 }
 
-IceInternal::WSAcceptor::WSAcceptor(WSEndpointPtr endpoint, ProtocolInstancePtr instance, AcceptorPtr del)
+IceInternal::WSAcceptor::WSAcceptor(
+    WSEndpointPtr endpoint,
+    ProtocolInstancePtr instance,
+    AcceptorPtr del,
+    set<string> allowedOrigins)
     : _endpoint(std::move(endpoint)),
       _instance(std::move(instance)),
-      _delegate(std::move(del))
+      _delegate(std::move(del)),
+      _allowedOrigins(std::move(allowedOrigins))
 {
 }
 

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

@@ -9,6 +9,9 @@
 #include "ProtocolInstance.h"
 #include "TransceiverF.h"
 
+#include <set>
+#include <string>
+
 namespace IceInternal
 {
     class WSEndpoint;
@@ -16,7 +19,7 @@ namespace IceInternal
     class WSAcceptor final : public Acceptor, public NativeInfo
     {
     public:
-        WSAcceptor(WSEndpointPtr, ProtocolInstancePtr, AcceptorPtr);
+        WSAcceptor(WSEndpointPtr, ProtocolInstancePtr, AcceptorPtr, std::set<std::string> allowedOrigins);
         ~WSAcceptor() override;
         NativeInfoPtr getNativeInfo() final;
 #if defined(ICE_USE_IOCP)
@@ -40,6 +43,7 @@ namespace IceInternal
         WSEndpointPtr _endpoint;
         const ProtocolInstancePtr _instance;
         const AcceptorPtr _delegate;
+        const std::set<std::string> _allowedOrigins;
     };
 }
 

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

@@ -10,6 +10,7 @@
 #include "TargetCompare.h"
 #include "WSAcceptor.h"
 #include "WSConnector.h"
+#include "WSTransceiver.h"
 
 #include <algorithm>
 
@@ -21,6 +22,36 @@ namespace
 {
     const char* const wsPluginName = "IceWS";
 
+    // Parse the values of the ObjectAdapter property "AllowedOrigins" into a canonicalized set of origins.
+    // Each entry is "scheme://host[:port]", lowercased, with the default port for the scheme (80/443) omitted.
+    // The literal "*" disables enforcement; in that case the returned set is empty -- handleRequest treats an empty
+    // allowlist as "allow any origin", so the two cases (unset and wildcard) collapse into one.
+    // Throws PropertyException if any entry is not a syntactically valid origin; propertyName is included in the
+    // message so the operator can identify which adapter is misconfigured.
+    set<string> parseAllowedOrigins(const vector<string>& entries, const string& propertyName)
+    {
+        set<string> result;
+        for (const auto& entry : entries)
+        {
+            if (entry == "*")
+            {
+                return {};
+            }
+            try
+            {
+                result.insert(canonicalizeOrigin(entry));
+            }
+            catch (const std::invalid_argument&)
+            {
+                throw PropertyException(
+                    __FILE__,
+                    __LINE__,
+                    "malformed origin '" + entry + "' in property '" + propertyName + "'");
+            }
+        }
+        return result;
+    }
+
     class WSEndpointFactoryPlugin : public Plugin
     {
     public:
@@ -246,8 +277,20 @@ IceInternal::WSEndpoint::acceptor(
     const string& adapterName,
     const optional<Ice::SSL::ServerAuthenticationOptions>& serverAuthenticationOptions) const
 {
+    // Parse AllowedOrigins before creating the delegate acceptor so a malformed property doesn't leave an open socket
+    // hanging on a TcpAcceptor whose destructor asserts INVALID_SOCKET.
+    set<string> allowedOrigins;
+    if (!adapterName.empty())
+    {
+        const string propertyName = adapterName + ".AllowedOrigins";
+        allowedOrigins = parseAllowedOrigins(_instance->properties()->getPropertyAsList(propertyName), propertyName);
+    }
     AcceptorPtr acceptor = _delegate->acceptor(adapterName, serverAuthenticationOptions);
-    return make_shared<WSAcceptor>(const_cast<WSEndpoint*>(this)->shared_from_this(), _instance, acceptor);
+    return make_shared<WSAcceptor>(
+        const_cast<WSEndpoint*>(this)->shared_from_this(),
+        _instance,
+        acceptor,
+        std::move(allowedOrigins));
 }
 
 WSEndpointPtr
@@ -255,7 +298,7 @@ IceInternal::WSEndpoint::endpoint(const EndpointIPtr& delEndp) const
 {
     if (delEndp.get() == _delegate.get())
     {
-        return dynamic_pointer_cast<WSEndpoint>(const_cast<WSEndpoint*>(this)->shared_from_this());
+        return static_pointer_cast<WSEndpoint>(const_cast<WSEndpoint*>(this)->shared_from_this());
     }
     else
     {