zeroc-ice 3.8.2 → 3.8.3

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

@@ -3,7 +3,6 @@
 #include "Network.h"
 #include "Ice/LocalExceptions.h"
 #include "Ice/LoggerUtil.h" // For setTcpBufSize
-#include "Ice/Properties.h" // For setTcpBufSize
 #include "Ice/StringUtil.h"
 #include "NetworkProxy.h"
 #include "ProtocolInstance.h" // For setTcpBufSize
@@ -242,7 +241,7 @@ namespace
         if (pos != string::npos)
         {
             //
-            // If it's a link-local address, use the zone indice.
+            // If it's a link-local address, use the zone index.
             //
             isAddr = false;
             name = intf.substr(pos + 1);
@@ -387,7 +386,7 @@ namespace
                 while (paddrs)
                 {
                     //
-                    // Don't need to pass a wide string converter as the wide string come
+                    // Don't need to pass a wide string converter as the wide string comes
                     // from Windows API.
                     //
                     if (wstringToString(paddrs->FriendlyName, getProcessStringConverter()) == name)
@@ -580,7 +579,7 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
     } while (info == nullptr && rs == EAI_AGAIN && --retry >= 0);
 
     // In theory, getaddrinfo should only return EAI_NONAME if
-    // AI_NUMERICHOST is specified and the host name is not a IP
+    // AI_NUMERICHOST is specified and the host name is not an IP
     // address. However on some platforms (e.g. macOS 10.4.x)
     // EAI_NODATA is also returned so we also check for it.
 #ifdef EAI_NODATA
@@ -720,6 +719,16 @@ IceInternal::compareAddress(const Address& addr1, const Address& addr2)
         {
             return 1;
         }
+
+        // Distinguish scoped link-local addresses such as fe80::1%eth0 and fe80::1%eth1.
+        if (addr1.saIn6.sin6_scope_id < addr2.saIn6.sin6_scope_id)
+        {
+            return -1;
+        }
+        else if (addr2.saIn6.sin6_scope_id < addr1.saIn6.sin6_scope_id)
+        {
+            return 1;
+        }
     }
 
     return 0;
@@ -814,7 +823,15 @@ IceInternal::addrToString(const Address& addr)
     if (isAddressValid(addr))
     {
         ostringstream s;
-        s << inetAddrToString(addr) << ':' << getPort(addr);
+        // An IPv6 address is enclosed in square brackets in the host:port form, e.g. [::1]:4061.
+        if (addr.saStorage.ss_family == AF_INET6)
+        {
+            s << '[' << inetAddrToString(addr) << "]:" << getPort(addr);
+        }
+        else
+        {
+            s << inetAddrToString(addr) << ':' << getPort(addr);
+        }
         return s.str();
     }
     else
@@ -852,70 +869,86 @@ IceInternal::fdToRemoteAddress(SOCKET fd, Address& addr)
 }
 
 std::string
-IceInternal::fdToString(SOCKET fd, const NetworkProxyPtr& proxy, const Address& target)
+IceInternal::fdToString(SOCKET fd, const NetworkProxyPtr& proxy, const Address& target) noexcept
 {
     if (fd == INVALID_SOCKET)
     {
         return "<closed>";
     }
 
-    ostringstream s;
+    try
+    {
+        ostringstream s;
 
-    Address remoteAddr;
-    bool peerConnected = fdToRemoteAddress(fd, remoteAddr);
+        Address remoteAddr;
+        bool peerConnected = fdToRemoteAddress(fd, remoteAddr);
 
 #ifdef _WIN32
-    if (!peerConnected)
-    {
-        //
-        // The local address is only accessible with connected sockets on Windows.
-        //
-        s << "local address = <not available>";
-    }
-    else
+        if (!peerConnected)
+        {
+            //
+            // The local address is only accessible with connected sockets on Windows.
+            //
+            s << "local address = <not available>";
+        }
+        else
 #endif
-    {
-        Address localAddr;
-        fdToLocalAddress(fd, localAddr);
-        s << "local address = " << addrToString(localAddr);
-    }
+        {
+            Address localAddr;
+            fdToLocalAddress(fd, localAddr);
+            s << "local address = " << addrToString(localAddr);
+        }
 
-    if (proxy)
-    {
-        if (!peerConnected)
+        if (proxy)
         {
-            remoteAddr = proxy->getAddress();
+            if (!peerConnected)
+            {
+                remoteAddr = proxy->getAddress();
+            }
+            s << "\n" + proxy->getName() + " proxy address = " << addrToString(remoteAddr);
+            s << "\nremote address = " << addrToString(target);
         }
-        s << "\n" + proxy->getName() + " proxy address = " << addrToString(remoteAddr);
-        s << "\nremote address = " << addrToString(target);
-    }
-    else
-    {
-        if (!peerConnected)
+        else
         {
-            remoteAddr = target;
+            if (!peerConnected)
+            {
+                remoteAddr = target;
+            }
+            s << "\nremote address = " << addrToString(remoteAddr);
         }
-        s << "\nremote address = " << addrToString(remoteAddr);
-    }
 
-    return s.str();
+        return s.str();
+    }
+    catch (...)
+    {
+        // The description is best-effort: the address queries can fail only in extreme conditions such as kernel
+        // resource exhaustion.
+        return "<not available>";
+    }
 }
 
 std::string
-IceInternal::fdToString(SOCKET fd)
+IceInternal::fdToString(SOCKET fd) noexcept
 {
     if (fd == INVALID_SOCKET)
     {
         return "<closed>";
     }
 
-    Address localAddr;
-    fdToLocalAddress(fd, localAddr);
+    try
+    {
+        Address localAddr;
+        fdToLocalAddress(fd, localAddr);
 
-    Address remoteAddr;
-    bool peerConnected = fdToRemoteAddress(fd, remoteAddr);
+        Address remoteAddr;
+        bool peerConnected = fdToRemoteAddress(fd, remoteAddr);
 
-    return addressesToString(localAddr, remoteAddr, peerConnected);
+        return addressesToString(localAddr, remoteAddr, peerConnected);
+    }
+    catch (...)
+    {
+        return "<not available>";
+    }
 }
 
 void
@@ -1068,26 +1101,6 @@ IceInternal::isMulticast(const Address& addr)
     return false;
 }
 
-void
-IceInternal::setTcpBufSize(SOCKET fd, const ProtocolInstancePtr& instance)
-{
-    assert(fd != INVALID_SOCKET);
-
-    //
-    // By default, on Windows we use a 128KB buffer size. On Unix
-    // platforms, we use the system defaults.
-    //
-#ifdef _WIN32
-    const int dfltBufSize = 128 * 1024;
-#else
-    const int dfltBufSize = 0;
-#endif
-    int32_t rcvSize = instance->properties()->getPropertyAsIntWithDefault("Ice.TCP.RcvSize", dfltBufSize);
-    int32_t sndSize = instance->properties()->getPropertyAsIntWithDefault("Ice.TCP.SndSize", dfltBufSize);
-
-    setTcpBufSize(fd, rcvSize, sndSize, instance);
-}
-
 void
 IceInternal::setTcpBufSize(SOCKET fd, int rcvSize, int sndSize, const ProtocolInstancePtr& instance)
 {
@@ -1102,7 +1115,7 @@ IceInternal::setTcpBufSize(SOCKET fd, int rcvSize, int sndSize, const ProtocolIn
         //
         setRecvBufferSize(fd, rcvSize);
         int size = getRecvBufferSize(fd);
-        if (size > 0 && size < rcvSize)
+        if (size < rcvSize)
         {
             // Warn if the size that was set is less than the requested size and
             // we have not already warned.
@@ -1125,7 +1138,7 @@ IceInternal::setTcpBufSize(SOCKET fd, int rcvSize, int sndSize, const ProtocolIn
         //
         setSendBufferSize(fd, sndSize);
         int size = getSendBufferSize(fd);
-        if (size > 0 && size < sndSize)
+        if (size < sndSize)
         {
             // Warn if the size that was set is less than the requested size and
             // we have not already warned.
@@ -1199,10 +1212,8 @@ IceInternal::setSendBufferSize(SOCKET fd, int sz)
 int
 IceInternal::getSendBufferSize(SOCKET fd)
 {
-    int sz;
-    socklen_t len = sizeof(sz);
-    if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<char*>(&sz), &len) == SOCKET_ERROR ||
-        static_cast<unsigned int>(len) != sizeof(sz))
+    int sz = getSendBufferSizeNoThrow(fd);
+    if (sz == 0)
     {
         closeSocketNoThrow(fd);
         throw SocketException(__FILE__, __LINE__, getSocketErrno());
@@ -1222,14 +1233,38 @@ IceInternal::setRecvBufferSize(SOCKET fd, int sz)
 
 int
 IceInternal::getRecvBufferSize(SOCKET fd)
+{
+    int sz = getRecvBufferSizeNoThrow(fd);
+    if (sz == 0)
+    {
+        closeSocketNoThrow(fd);
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
+    }
+    return sz;
+}
+
+int
+IceInternal::getSendBufferSizeNoThrow(SOCKET fd) noexcept
+{
+    int sz;
+    socklen_t len = sizeof(sz);
+    if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<char*>(&sz), &len) == SOCKET_ERROR ||
+        static_cast<unsigned int>(len) != sizeof(sz))
+    {
+        return 0;
+    }
+    return sz;
+}
+
+int
+IceInternal::getRecvBufferSizeNoThrow(SOCKET fd) noexcept
 {
     int sz;
     socklen_t len = sizeof(sz);
     if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<char*>(&sz), &len) == SOCKET_ERROR ||
         static_cast<unsigned int>(len) != sizeof(sz))
     {
-        closeSocketNoThrow(fd);
-        throw SocketException(__FILE__, __LINE__, getSocketErrno());
+        return 0;
     }
     return sz;
 }
@@ -1237,51 +1272,80 @@ IceInternal::getRecvBufferSize(SOCKET fd)
 void
 IceInternal::setMcastGroup(SOCKET fd, const Address& group, const string& intf)
 {
-    vector<string> interfaces = getInterfacesForMulticast(intf, getProtocolSupport(group));
-    set<int> indexes;
-    for (const auto& interface : interfaces)
+    try
     {
-        int rc = 0;
-        if (group.saStorage.ss_family == AF_INET)
+        vector<string> interfaces = getInterfacesForMulticast(intf, getProtocolSupport(group));
+        set<int> indexes;
+        for (const auto& interface : interfaces)
         {
-            struct ip_mreq mreq;
-            mreq.imr_multiaddr = group.saIn.sin_addr;
-            mreq.imr_interface = getInterfaceAddress(interface);
-            rc = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, reinterpret_cast<char*>(&mreq), int(sizeof(mreq)));
-        }
-        else
-        {
-            int index = getInterfaceIndex(interface);
-            if (indexes.find(index) == indexes.end()) // Don't join twice the same interface (if it has multiple IPs)
+            int rc = 0;
+            if (group.saStorage.ss_family == AF_INET)
             {
-                indexes.insert(index);
-                struct ipv6_mreq mreq;
-                mreq.ipv6mr_multiaddr = group.saIn6.sin6_addr;
-                mreq.ipv6mr_interface = static_cast<unsigned int>(index);
-                rc = setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, reinterpret_cast<char*>(&mreq), int(sizeof(mreq)));
+                struct ip_mreq mreq;
+                mreq.imr_multiaddr = group.saIn.sin_addr;
+                mreq.imr_interface = getInterfaceAddress(interface);
+                rc = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, reinterpret_cast<char*>(&mreq), int(sizeof(mreq)));
+            }
+            else
+            {
+                int index = getInterfaceIndex(interface);
+                // Don't join twice the same interface (if it has multiple IPs).
+                if (indexes.find(index) == indexes.end())
+                {
+                    indexes.insert(index);
+                    struct ipv6_mreq mreq;
+                    mreq.ipv6mr_multiaddr = group.saIn6.sin6_addr;
+                    mreq.ipv6mr_interface = static_cast<unsigned int>(index);
+                    rc = setsockopt(
+                        fd,
+                        IPPROTO_IPV6,
+                        IPV6_JOIN_GROUP,
+                        reinterpret_cast<char*>(&mreq),
+                        int(sizeof(mreq)));
+                }
+            }
+            if (rc == SOCKET_ERROR)
+            {
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
-        }
-        if (rc == SOCKET_ERROR)
-        {
-            closeSocketNoThrow(fd);
-            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
+    catch (...)
+    {
+        // Close the socket on any failure (interface resolution or the multicast join) so this helper always
+        // leaves the socket closed when it throws, like doBind and setReuseAddress.
+        closeSocketNoThrow(fd);
+        throw;
+    }
 }
 
 void
 IceInternal::setMcastInterface(SOCKET fd, const string& intf, const Address& addr)
 {
     int rc;
-    if (addr.saStorage.ss_family == AF_INET)
+    try
     {
-        struct in_addr iface = getInterfaceAddress(intf);
-        rc = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, reinterpret_cast<char*>(&iface), int(sizeof(iface)));
+        if (addr.saStorage.ss_family == AF_INET)
+        {
+            struct in_addr iface = getInterfaceAddress(intf);
+            rc = setsockopt(fd, IPPROTO_IP, IP_MULTICAST_IF, reinterpret_cast<char*>(&iface), int(sizeof(iface)));
+        }
+        else
+        {
+            int interfaceNum = getInterfaceIndex(intf);
+            rc = setsockopt(
+                fd,
+                IPPROTO_IPV6,
+                IPV6_MULTICAST_IF,
+                reinterpret_cast<char*>(&interfaceNum),
+                int(sizeof(int)));
+        }
     }
-    else
+    catch (const Ice::SocketException&)
     {
-        int interfaceNum = getInterfaceIndex(intf);
-        rc = setsockopt(fd, IPPROTO_IPV6, IPV6_MULTICAST_IF, reinterpret_cast<char*>(&interfaceNum), int(sizeof(int)));
+        // getInterfaceAddress and getInterfaceIndex throw if the interface cannot be resolved.
+        closeSocketNoThrow(fd);
+        throw;
     }
     if (rc == SOCKET_ERROR)
     {
@@ -1779,7 +1843,7 @@ void
 IceInternal::doConnectAsync(SOCKET fd, const Address& addr, const Address& sourceAddr, AsyncInfo& info)
 {
     //
-    // NOTE: It's the caller's responsability to close the socket upon
+    // NOTE: It's the caller's responsibility to close the socket upon
     // failure to connect. The socket isn't closed by this method.
     //
     Address bindAddr;
@@ -1903,8 +1967,9 @@ IceInternal::isLoopbackOrMulticastAddress(const string& name)
         in6_addr addr6;
         if (inet_pton(AF_INET, name.c_str(), &addr) > 0)
         {
-            // It's an IPv4 address
-            return addr.s_addr == htonl(INADDR_LOOPBACK) || IN_MULTICAST(ntohl(addr.s_addr));
+            // It's an IPv4 address. The whole 127.0.0.0/8 range is loopback, not just 127.0.0.1.
+            const uint32_t host = ntohl(addr.s_addr);
+            return (host & 0xFF000000u) == 0x7F000000u || IN_MULTICAST(host);
         }
         else if (inet_pton(AF_INET6, name.c_str(), &addr6) > 0)
         {

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

@@ -5,9 +5,7 @@
 
 #include "Ice/Config.h"
 #include "Ice/EndpointTypes.h"
-#include "Ice/Logger.h"      // For setTcpBufSize
-#include "Ice/PropertiesF.h" // For setTcpBufSize
-#include "Ice/StringUtil.h"  // For ErrorCode
+#include "Ice/StringUtil.h" // For ErrorCode
 #include "NetworkF.h"
 #include "NetworkProxyF.h"
 #include "Protocol.h"
@@ -45,7 +43,7 @@ typedef int ssize_t;
 #    error "Unsupported platform"
 #endif
 
-#if defined(_WIN32) || defined(__osf__)
+#if defined(_WIN32)
 typedef int socklen_t;
 #endif
 
@@ -147,6 +145,10 @@ namespace IceInternal
 
         [[nodiscard]] SOCKET fd() const { return _fd; }
 
+        // Forgets the fd. Called when a failed socket operation has already closed the fd, so that close() does not
+        // close an unrelated descriptor later assigned the same number.
+        void clearFd() noexcept { _fd = INVALID_SOCKET; }
+
         void setReadyCallback(const ReadyCallbackPtr& callback);
 
         void ready(SocketOperation operation, bool value)
@@ -198,8 +200,8 @@ namespace IceInternal
     ICE_API std::string addrToString(const Address&);
     ICE_API void fdToLocalAddress(SOCKET, Address&);
     ICE_API bool fdToRemoteAddress(SOCKET, Address&);
-    ICE_API std::string fdToString(SOCKET, const NetworkProxyPtr&, const Address&);
-    ICE_API std::string fdToString(SOCKET);
+    ICE_API std::string fdToString(SOCKET, const NetworkProxyPtr&, const Address&) noexcept;
+    ICE_API std::string fdToString(SOCKET) noexcept;
     ICE_API void fdToAddressAndPort(SOCKET, std::string&, int&, std::string&, int&);
     ICE_API void addrToAddressAndPort(const Address&, std::string&, int&);
     ICE_API std::string addressesToString(const Address&, const Address&, bool);
@@ -212,7 +214,6 @@ namespace IceInternal
     ICE_API void setPort(Address&, int);
 
     ICE_API bool isMulticast(const Address&);
-    ICE_API void setTcpBufSize(SOCKET, const ProtocolInstancePtr&);
     ICE_API void setTcpBufSize(SOCKET, int, int, const ProtocolInstancePtr&);
 
     ICE_API void setBlock(SOCKET, bool);
@@ -221,6 +222,10 @@ namespace IceInternal
     ICE_API void setRecvBufferSize(SOCKET, int);
     ICE_API int getRecvBufferSize(SOCKET);
 
+    // Non-throwing variants that return 0 on failure and never close the fd.
+    ICE_API int getSendBufferSizeNoThrow(SOCKET) noexcept;
+    ICE_API int getRecvBufferSizeNoThrow(SOCKET) noexcept;
+
     ICE_API void setMcastGroup(SOCKET, const Address&, const std::string&);
     ICE_API void setMcastInterface(SOCKET, const std::string&, const Address&);
     ICE_API void setMcastTtl(SOCKET, int, const Address&);

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

@@ -142,7 +142,7 @@ SOCKSNetworkProxy::finish(Buffer& readBuffer, Buffer&)
         throw Ice::ConnectFailedException{
             __FILE__,
             __LINE__,
-            "connection establishment failed due to an HTTP proxy error"};
+            "connection establishment failed due to a SOCKS4 proxy error"};
     }
 }
 
@@ -224,27 +224,38 @@ HTTPNetworkProxy::endRead(Buffer& buf)
     // reading otherwise we're done.
     //
     const byte* end = HttpParser().isCompleteMessage(buf.b.begin(), buf.i);
-    if (!end && buf.i == buf.b.end())
+    if (end)
+    {
+        return SocketOperationNone;
+    }
+
+    if (buf.i == buf.b.end())
     {
         //
         // Read one more byte, we can't easily read bytes in advance
-        // since the transport implementation might be be able to read
+        // since the transport implementation might be able to read
         // the data from the memory instead of the socket. This is for
         // instance the case with the OpenSSL transport (or we would
         // have to use a buffering BIO).
         //
         buf.b.resize(buf.b.size() + 1);
         buf.i = buf.b.begin() + buf.b.size() - 1;
-        return SocketOperationRead;
     }
-    return SocketOperationNone;
+    return SocketOperationRead;
 }
 
 void
 HTTPNetworkProxy::finish(Buffer& readBuffer, Buffer&)
 {
     HttpParser parser;
-    parser.parse(readBuffer.b.begin(), readBuffer.b.end());
+    try
+    {
+        parser.parse(readBuffer.b.begin(), readBuffer.b.end());
+    }
+    catch (const WebSocketException& ex)
+    {
+        throw Ice::ProtocolException{__FILE__, __LINE__, "malformed HTTP proxy response: " + ex.reason};
+    }
     if (parser.status() != 200)
     {
         throw Ice::ConnectFailedException{

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

@@ -4,6 +4,7 @@
 #define ICE_NETWORK_PROXY_H
 
 #include "Ice/Buffer.h"
+#include "Ice/PropertiesF.h"
 #include "Network.h"
 
 namespace IceInternal
@@ -39,7 +40,7 @@ namespace IceInternal
         // If the proxy host needs to be resolved, this should return
         // a new NetworkProxy containing the IP address of the proxy.
         // This is called from the endpoint host resolver thread, so
-        // it's safe if this this method blocks.
+        // it's safe if this method blocks.
         //
         [[nodiscard]] virtual NetworkProxyPtr resolveHost(ProtocolSupport) const = 0;
 

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

@@ -91,7 +91,7 @@ Ice::Object::_iceD_ice_ids(
             }
             else
             {
-                ostr->write(&ret[0], &ret[0] + ret.size(), false);
+                ostr->write(ret.data(), ret.data() + ret.size(), false);
             }
         },
         request.current()));