zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,42 +1,38 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/UdpTransceiver.h>
-#include <Ice/UdpEndpointI.h>
-#include <Ice/Connection.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/Buffer.h>
-#include <Ice/LocalException.h>
-#include <Ice/Properties.h>
-#include <IceUtil/StringUtil.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "UdpTransceiver.h"
+#include "Ice/Buffer.h"
+#include "Ice/Connection.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Ice/StringUtil.h"
+#include "ProtocolInstance.h"
+#include "UdpEndpointI.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(UdpTransceiver* p) { return p; }
-
 NativeInfoPtr
 IceInternal::UdpTransceiver::getNativeInfo()
 {
-    return this;
+    return shared_from_this();
 }
 
 #if defined(ICE_USE_IOCP)
 AsyncInfo*
 IceInternal::UdpTransceiver::getAsyncInfo(SocketOperation status)
 {
-    switch(status)
+    switch (status)
     {
-    case SocketOperationRead:
-        return &_read;
-    case SocketOperationWrite:
-        return &_write;
-    default:
-        assert(false);
-        return 0;
+        case SocketOperationRead:
+            return &_read;
+        case SocketOperationWrite:
+            return &_write;
+        default:
+            assert(false);
+            return 0;
     }
 }
 #endif
@@ -44,12 +40,12 @@ IceInternal::UdpTransceiver::getAsyncInfo(SocketOperation status)
 SocketOperation
 IceInternal::UdpTransceiver::initialize(Buffer& /*readBuffer*/, Buffer& /*writeBuffer*/)
 {
-    if(_state == StateNeedConnect)
+    if (_state == StateNeedConnect)
     {
         _state = StateConnectPending;
         return SocketOperationConnect;
     }
-    else if(_state <= StateConnectPending)
+    else if (_state <= StateConnectPending)
     {
 #if defined(ICE_USE_IOCP)
         doFinishConnectAsync(_fd, _write);
@@ -64,7 +60,7 @@ IceInternal::UdpTransceiver::initialize(Buffer& /*readBuffer*/, Buffer& /*writeB
 }
 
 SocketOperation
-IceInternal::UdpTransceiver::closing(bool, const Ice::LocalException&)
+IceInternal::UdpTransceiver::closing(bool, exception_ptr)
 {
     // Nothing to do.
     return SocketOperationNone;
@@ -82,24 +78,19 @@ IceInternal::UdpTransceiver::close()
 EndpointIPtr
 IceInternal::UdpTransceiver::bind()
 {
-    if(isMulticast(_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 (0.0.0.0) instead. As a result,
-        // bi-directional connection won't work because the source
-        // address won't be the multicast address and the client will
-        // therefore reject the datagram.
-        //
+        // 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)
+        if (getPort(_mcastAddr) == 0)
         {
             setPort(_mcastAddr, getPort(_addr));
         }
@@ -107,34 +98,19 @@ IceInternal::UdpTransceiver::bind()
     }
     else
     {
-#ifndef _WIN32
-        //
-        // Enable SO_REUSEADDR on Unix platforms to allow re-using
-        // the socket even if it's in the TIME_WAIT state. On
-        // Windows, this doesn't appear to be necessary and
-        // enabling SO_REUSEADDR would actually not be a good
-        // thing since it allows a second process to bind to an
-        // address even it's already bound by another process.
-        //
-        // TODO: using SO_EXCLUSIVEADDRUSE on Windows would
-        // probably be better but it's only supported by recent
-        // Windows versions (XP SP2, Windows Server 2003).
-        //
-        setReuseAddress(_fd, true);
-#endif
         const_cast<Address&>(_addr) = doBind(_fd, _addr);
     }
 
     _bound = true;
 
-    _endpoint = _endpoint->endpoint(this);
+    _endpoint = _endpoint->endpoint(shared_from_this());
     return _endpoint;
 }
 
 SocketOperation
 IceInternal::UdpTransceiver::write(Buffer& buf)
 {
-    if(buf.i == buf.b.end())
+    if (buf.i == buf.b.end())
     {
         return SocketOperationNone;
     }
@@ -147,7 +123,7 @@ IceInternal::UdpTransceiver::write(Buffer& buf)
 repeat:
 
     ssize_t ret;
-    if(_state == StateConnected)
+    if (_state == StateConnected)
     {
 #ifdef _WIN32
         ret = ::send(_fd, reinterpret_cast<const char*>(&buf.b[0]), static_cast<int>(buf.b.size()), 0);
@@ -157,12 +133,12 @@ repeat:
     }
     else
     {
-        socklen_t len = static_cast<socklen_t>(sizeof(sockaddr_storage));
-        if(_peerAddr.saStorage.ss_family == AF_INET)
+        auto len = static_cast<socklen_t>(sizeof(sockaddr_storage));
+        if (_peerAddr.saStorage.ss_family == AF_INET)
         {
             len = static_cast<socklen_t>(sizeof(sockaddr_in));
         }
-        else if(_peerAddr.saStorage.ss_family == AF_INET6)
+        else if (_peerAddr.saStorage.ss_family == AF_INET6)
         {
             len = static_cast<socklen_t>(sizeof(sockaddr_in6));
         }
@@ -173,22 +149,26 @@ repeat:
         }
 
 #ifdef _WIN32
-        ret = ::sendto(_fd, reinterpret_cast<const char*>(&buf.b[0]), static_cast<int>(buf.b.size()), 0,
-                       &_peerAddr.sa, len);
+        ret = ::sendto(
+            _fd,
+            reinterpret_cast<const char*>(&buf.b[0]),
+            static_cast<int>(buf.b.size()),
+            0,
+            &_peerAddr.sa,
+            len);
 #else
-        ret = ::sendto(_fd, reinterpret_cast<const char*>(&buf.b[0]), buf.b.size(), 0,
-                       &_peerAddr.sa, len);
+        ret = ::sendto(_fd, reinterpret_cast<const char*>(&buf.b[0]), buf.b.size(), 0, &_peerAddr.sa, len);
 #endif
     }
 
-    if(ret == SOCKET_ERROR)
+    if (ret == SOCKET_ERROR)
     {
-        if(interrupted())
+        if (interrupted())
         {
             goto repeat;
         }
 
-        if(wouldBlock())
+        if (wouldBlock())
         {
             return SocketOperationWrite;
         }
@@ -204,7 +184,7 @@ repeat:
 SocketOperation
 IceInternal::UdpTransceiver::read(Buffer& buf)
 {
-    if(buf.i == buf.b.end())
+    if (buf.i == buf.b.end())
     {
         return SocketOperationNone;
     }
@@ -226,7 +206,7 @@ repeat:
 #else
     ssize_t ret;
 #endif
-    if(_state == StateConnected)
+    if (_state == StateConnected)
     {
         ret = ::recv(_fd, reinterpret_cast<char*>(&buf.b[0]), packetSize, 0);
     }
@@ -236,20 +216,19 @@ repeat:
 
         Address peerAddr;
         memset(&peerAddr.saStorage, 0, sizeof(sockaddr_storage));
-        socklen_t len = static_cast<socklen_t>(sizeof(sockaddr_storage));
+        auto len = static_cast<socklen_t>(sizeof(sockaddr_storage));
 
-        ret = recvfrom(_fd, reinterpret_cast<char*>(&buf.b[0]), packetSize, 0,
-                       &peerAddr.sa, &len);
+        ret = recvfrom(_fd, reinterpret_cast<char*>(&buf.b[0]), packetSize, 0, &peerAddr.sa, &len);
 
-        if(ret != SOCKET_ERROR)
+        if (ret != SOCKET_ERROR)
         {
             _peerAddr = peerAddr;
         }
     }
 
-    if(ret == SOCKET_ERROR)
+    if (ret == SOCKET_ERROR)
     {
-        if(recvTruncated())
+        if (recvTruncated())
         {
             // The message was truncated and the whole buffer is filled. We ignore
             // this error here, it will be detected at the connection level when
@@ -258,19 +237,19 @@ repeat:
         }
         else
         {
-            if(interrupted())
+            if (interrupted())
             {
                 goto repeat;
             }
 
-            if(wouldBlock())
+            if (wouldBlock())
             {
                 return SocketOperationRead;
             }
 
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_peerAddr));
             }
             else
             {
@@ -279,27 +258,8 @@ repeat:
         }
     }
 
-    if(_state == StateNeedConnect)
-    {
-        //
-        // If we must connect, we connect to the first peer that sends us a packet.
-        //
-        assert(_incoming); // Client connections should always be connected at this point.
-
-#ifndef NDEBUG
-        bool connected = doConnect(_fd, _peerAddr, Address());
-        assert(connected);
-#else
-        doConnect(_fd, _peerAddr, Address());
-#endif
-        _state = StateConnected;
-
-        if(_instance->traceLevel() >= 1)
-        {
-            Trace out(_instance->logger(), _instance->traceCategory());
-            out << "connected " << _instance->protocol() << " socket\n" << toString();
-        }
-    }
+    // Client connections are connected at this point, and server connections are never connected.
+    assert(_state != StateNeedConnect);
 
     buf.b.resize(static_cast<size_t>(ret));
     buf.i = buf.b.end();
@@ -320,18 +280,18 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
     _write.buf.buf = reinterpret_cast<char*>(&*buf.i);
     _write.error = ERROR_SUCCESS;
     int err;
-    if(_state == StateConnected)
+    if (_state == StateConnected)
     {
-        err = WSASend(_fd, &_write.buf, 1, &_write.count, 0, &_write, ICE_NULLPTR);
+        err = WSASend(_fd, &_write.buf, 1, &_write.count, 0, &_write, nullptr);
     }
     else
     {
         socklen_t len = static_cast<socklen_t>(sizeof(sockaddr_storage));
-        if(_peerAddr.saStorage.ss_family == AF_INET)
+        if (_peerAddr.saStorage.ss_family == AF_INET)
         {
             len = sizeof(sockaddr_in);
         }
-        else if(_peerAddr.saStorage.ss_family == AF_INET6)
+        else if (_peerAddr.saStorage.ss_family == AF_INET6)
         {
             len = sizeof(sockaddr_in6);
         }
@@ -340,16 +300,16 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
             // No peer has sent a datagram yet.
             throw SocketException(__FILE__, __LINE__, 0);
         }
-        err = WSASendTo(_fd, &_write.buf, 1, &_write.count, 0, &_peerAddr.sa, len, &_write, ICE_NULLPTR);
+        err = WSASendTo(_fd, &_write.buf, 1, &_write.count, 0, &_peerAddr.sa, len, &_write, nullptr);
     }
 
-    if(err == SOCKET_ERROR)
+    if (err == SOCKET_ERROR)
     {
-        if(!wouldBlock())
+        if (!wouldBlock())
         {
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_peerAddr));
             }
             else
             {
@@ -363,17 +323,17 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
 void
 IceInternal::UdpTransceiver::finishWrite(Buffer& buf)
 {
-    if(_fd == INVALID_SOCKET || _state < StateConnected)
+    if (_fd == INVALID_SOCKET || _state < StateConnected)
     {
         return;
     }
 
-    if(_write.error != ERROR_SUCCESS)
+    if (_write.error != ERROR_SUCCESS)
     {
         WSASetLastError(_write.error);
-        if(connectionLost())
+        if (connectionLost())
         {
-            throw ConnectionLostException(__FILE__, __LINE__ ,getSocketErrno());
+            throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_peerAddr));
         }
         else
         {
@@ -396,30 +356,30 @@ IceInternal::UdpTransceiver::startRead(Buffer& buf)
     _read.buf.buf = reinterpret_cast<char*>(&*buf.i);
     _read.error = ERROR_SUCCESS;
     int err;
-    if(_state == StateConnected)
+    if (_state == StateConnected)
     {
-        err = WSARecv(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_read, ICE_NULLPTR);
+        err = WSARecv(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_read, nullptr);
     }
     else
     {
         memset(&_readAddr.saStorage, 0, sizeof(struct sockaddr_storage));
         _readAddrLen = static_cast<socklen_t>(sizeof(sockaddr_storage));
 
-        err = WSARecvFrom(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_readAddr.sa, &_readAddrLen, &_read,
-                          ICE_NULLPTR);
+        err =
+            WSARecvFrom(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_readAddr.sa, &_readAddrLen, &_read, nullptr);
     }
 
-    if(err == SOCKET_ERROR)
+    if (err == SOCKET_ERROR)
     {
-        if(recvTruncated())
+        if (recvTruncated())
         {
             // Nothing to do.
         }
-        else if(!wouldBlock())
+        else if (!wouldBlock())
         {
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_peerAddr));
             }
             else
             {
@@ -432,11 +392,11 @@ IceInternal::UdpTransceiver::startRead(Buffer& buf)
 void
 IceInternal::UdpTransceiver::finishRead(Buffer& buf)
 {
-    if(_read.error != ERROR_SUCCESS)
+    if (_read.error != ERROR_SUCCESS)
     {
         WSASetLastError(_read.error);
 
-        if(recvTruncated())
+        if (recvTruncated())
         {
             // The message was truncated and the whole buffer is filled. We ignore
             // this error here, it will be detected at the connection level when
@@ -445,9 +405,9 @@ IceInternal::UdpTransceiver::finishRead(Buffer& buf)
         }
         else
         {
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_peerAddr));
             }
             else
             {
@@ -456,7 +416,7 @@ IceInternal::UdpTransceiver::finishRead(Buffer& buf)
         }
     }
 
-    if(_state == StateNotConnected)
+    if (_state == StateNotConnected)
     {
         _peerAddr = _readAddr;
     }
@@ -477,32 +437,28 @@ IceInternal::UdpTransceiver::protocol() const
 string
 IceInternal::UdpTransceiver::toString() const
 {
-    if(_fd == INVALID_SOCKET)
+    if (_fd == INVALID_SOCKET)
     {
         return "<closed>";
     }
 
     ostringstream s;
-    if(_incoming && !_bound)
+    if (_incoming && !_bound)
     {
         s << "local address = " << addrToString(_addr);
     }
-    else if(_state == StateNotConnected)
+    else if (_state == StateNotConnected)
     {
         Address localAddr;
         fdToLocalAddress(_fd, localAddr);
         s << "local address = " << addrToString(localAddr);
-        if(isAddressValid(_peerAddr))
-        {
-            s << "\nremote address = " << addrToString(_peerAddr);
-        }
     }
     else
     {
         s << fdToString(_fd);
     }
 
-    if(isAddressValid(_mcastAddr))
+    if (isAddressValid(_mcastAddr))
     {
         s << "\nmulticast address = " + addrToString(_mcastAddr);
     }
@@ -514,63 +470,81 @@ IceInternal::UdpTransceiver::toDetailedString() const
 {
     ostringstream os;
     os << toString();
-    vector<string> intfs;
-    if(isAddressValid(_mcastAddr))
-    {
-        intfs = getInterfacesForMulticast(_mcastInterface, getProtocolSupport(_mcastAddr));
-    }
-    else
-    {
-        intfs = getHostsForEndpointExpand(inetAddrToString(_addr), _instance->protocolSupport(), true);
-    }
-    if(!intfs.empty())
+    if (isAddressValid(_mcastAddr))
     {
-        os << "\nlocal interfaces = ";
-        os << IceUtilInternal::joinString(intfs, ", ");
+        vector<string> intfs = getInterfacesForMulticast(_mcastInterface, getProtocolSupport(_mcastAddr));
+        if (!intfs.empty())
+        {
+            os << "\nlocal interfaces = ";
+            os << IceInternal::joinString(intfs, ", ");
+        }
     }
     return os.str();
 }
 
 Ice::ConnectionInfoPtr
-IceInternal::UdpTransceiver::getInfo() const
+IceInternal::UdpTransceiver::getInfo(bool incoming, string adapterName, string connectionId) const
 {
-    Ice::UDPConnectionInfoPtr info = ICE_MAKE_SHARED(Ice::UDPConnectionInfo);
-    if(_fd == INVALID_SOCKET)
+    if (_fd == INVALID_SOCKET)
     {
-        return info;
+        return make_shared<UDPConnectionInfo>(incoming, std::move(adapterName), std::move(connectionId));
     }
-
-    if(_state == StateNotConnected)
+    else
     {
-        Address localAddr;
-        fdToLocalAddress(_fd, localAddr);
-        addrToAddressAndPort(localAddr, info->localAddress, info->localPort);
-        if(isAddressValid(_peerAddr))
+        string mcastAddress;
+        int mcastPort = 0;
+        if (isAddressValid(_mcastAddr))
         {
-            addrToAddressAndPort(_peerAddr, info->remoteAddress, info->remotePort);
+            addrToAddressAndPort(_mcastAddr, mcastAddress, mcastPort);
+        }
+
+        if (_state == StateNotConnected)
+        {
+            assert(_incoming);
+            Address localAddr;
+            fdToLocalAddress(_fd, localAddr);
+            string localAddress;
+            int localPort;
+            addrToAddressAndPort(localAddr, localAddress, localPort);
+
+            // Since this info is cached in the Connection object shared by all the clients, we don't store the
+            // remote address/port of the latest client in this info.
+            return make_shared<UDPConnectionInfo>(
+                incoming,
+                std::move(adapterName),
+                std::move(connectionId),
+                std::move(localAddress),
+                localPort,
+                "", // remoteAddress
+                -1, // remotePort
+                std::move(mcastAddress),
+                mcastPort,
+                _rcvSize,
+                _sndSize);
         }
         else
         {
-            info->remotePort = 0;
+            assert(!_incoming);
+            string localAddress;
+            int localPort;
+            string remoteAddress;
+            int remotePort;
+            fdToAddressAndPort(_fd, localAddress, localPort, remoteAddress, remotePort);
+
+            return make_shared<UDPConnectionInfo>(
+                incoming,
+                std::move(adapterName),
+                std::move(connectionId),
+                std::move(localAddress),
+                localPort,
+                std::move(remoteAddress),
+                remotePort,
+                std::move(mcastAddress),
+                mcastPort,
+                _rcvSize,
+                _sndSize);
         }
     }
-    else
-    {
-        fdToAddressAndPort(_fd, info->localAddress, info->localPort, info->remoteAddress, info->remotePort);
-    }
-
-    info->rcvSize = _rcvSize;
-    info->sndSize = _sndSize;
-
-    if(isAddressValid(_mcastAddr))
-    {
-        addrToAddressAndPort(_mcastAddr, info->mcastAddress, info->mcastPort);
-    }
-    else
-    {
-        info->mcastPort = 0;
-    }
-    return info;
 }
 
 void
@@ -581,7 +555,7 @@ IceInternal::UdpTransceiver::checkSendSize(const Buffer& buf)
     // the UDP send buffer size (which ever is smaller).
     //
     const int packetSize = min(_maxPacketSize, _sndSize - _udpOverhead);
-    if(packetSize < static_cast<int>(buf.b.size()))
+    if (packetSize < static_cast<int>(buf.b.size()))
     {
         throw DatagramLimitException(__FILE__, __LINE__);
     }
@@ -599,19 +573,21 @@ IceInternal::UdpTransceiver::effectivePort() const
     return getPort(_addr);
 }
 
-IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
-                                            const Address& addr,
-                                            const Address& sourceAddr,
-                                            const string& mcastInterface,
-                                            int mcastTtl) :
-    _instance(instance),
-    _incoming(false),
-    _bound(false),
-    _addr(addr),
-    _state(StateNeedConnect)
+IceInternal::UdpTransceiver::UdpTransceiver(
+    ProtocolInstancePtr instance,
+    const Address& addr,
+    const Address& sourceAddr,
+    const string& mcastInterface,
+    int mcastTtl)
+    : _instance(std::move(instance)),
+      _incoming(false),
+      _bound(false),
+      _addr(addr),
+      _state(StateNeedConnect)
 #if defined(ICE_USE_IOCP)
-    , _read(SocketOperationRead),
-    _write(SocketOperationWrite)
+      ,
+      _read(SocketOperationRead),
+      _write(SocketOperationWrite)
 #endif
 {
     _fd = createSocket(true, _addr);
@@ -625,13 +601,13 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
     // NOTE: setting the multicast interface before performing the
     // connect is important for some OS such as macOS.
     //
-    if(isMulticast(_addr))
+    if (isMulticast(_addr))
     {
-        if(mcastInterface.length() > 0)
+        if (mcastInterface.length() > 0)
         {
             setMcastInterface(_fd, mcastInterface, _addr);
         }
-        if(mcastTtl != -1)
+        if (mcastTtl != -1)
         {
             setMcastTtl(_fd, mcastTtl, _addr);
         }
@@ -644,7 +620,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
     // will make sure the transceiver is notified when the socket is ready for sending (see
     // the initialize() implementation).
     //
-    if(doConnect(_fd, _addr, sourceAddr))
+    if (doConnect(_fd, _addr, sourceAddr))
     {
         _state = StateConnected;
     }
@@ -652,7 +628,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
 #ifdef ICE_USE_IOCP
     //
     // On Windows when using IOCP, we must make sure that the socket is connected without
-    // blocking as there's no way to do a non-blocking datagram socket conection (ConnectEx
+    // blocking as there's no way to do a non-blocking datagram socket connection (ConnectEx
     // only supports connection oriented sockets). According to Microsoft documentation of
     // the connect() call, this should always be the case.
     //
@@ -660,19 +636,26 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
 #endif
 }
 
-IceInternal::UdpTransceiver::UdpTransceiver(const UdpEndpointIPtr& endpoint, const ProtocolInstancePtr& instance,
-                                            const string& host, int port, const string& mcastInterface, bool connect) :
-    _endpoint(endpoint),
-    _instance(instance),
-    _incoming(true),
-    _bound(false),
-    _addr(getAddressForServer(host, port, instance->protocolSupport(), instance->preferIPv6(), true)),
-    _mcastInterface(mcastInterface),
-    _port(port),
-    _state(connect ? StateNeedConnect : StateNotConnected)
+IceInternal::UdpTransceiver::UdpTransceiver(
+    UdpEndpointIPtr endpoint,
+    const ProtocolInstancePtr& instance,
+    const string& host,
+    int port,
+    string mcastInterface)
+    : _endpoint(std::move(endpoint)),
+      _instance(instance),
+      _incoming(true),
+      _bound(false),
+      _addr(getAddressForServer(host, port, instance->protocolSupport(), instance->preferIPv6(), true)),
+      _mcastInterface(std::move(mcastInterface)),
+#ifdef _WIN32
+      _port(port),
+#endif
+      _state(StateNotConnected)
 #if defined(ICE_USE_IOCP)
-    , _read(SocketOperationRead),
-    _write(SocketOperationWrite)
+      ,
+      _read(SocketOperationRead),
+      _write(SocketOperationWrite)
 #endif
 {
     _fd = createServerSocket(true, _addr, instance->protocolSupport());
@@ -685,10 +668,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const UdpEndpointIPtr& endpoint, con
     _mcastAddr.saStorage.ss_family = AF_UNSPEC;
 }
 
-IceInternal::UdpTransceiver::~UdpTransceiver()
-{
-    assert(_fd == INVALID_SOCKET);
-}
+IceInternal::UdpTransceiver::~UdpTransceiver() { assert(_fd == INVALID_SOCKET); }
 
 //
 // Set UDP receive and send buffer sizes.
@@ -698,7 +678,7 @@ IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
 {
     assert(_fd != INVALID_SOCKET);
 
-    for(int i = 0; i < 2; ++i)
+    for (int i = 0; i < 2; ++i)
     {
         bool isSnd;
         string direction;
@@ -706,7 +686,7 @@ IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
         int* addr;
         int dfltSize;
         int sizeRequested;
-        if(i == 0)
+        if (i == 0)
         {
             isSnd = false;
             direction = "receive";
@@ -725,7 +705,7 @@ IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
             sizeRequested = sndSize;
         }
 
-        if(dfltSize <= 0)
+        if (dfltSize <= 0)
         {
             dfltSize = _maxPacketSize;
         }
@@ -734,28 +714,28 @@ IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
         //
         // Get property for buffer size if size not passed in.
         //
-        if(sizeRequested == -1)
+        if (sizeRequested == -1)
         {
             sizeRequested = _instance->properties()->getPropertyAsIntWithDefault(prop, dfltSize);
         }
         //
         // Check for sanity.
         //
-        if(sizeRequested < (_udpOverhead + headerSize))
+        if (sizeRequested < (_udpOverhead + headerSize))
         {
             Warning out(_instance->logger());
             out << "Invalid " << prop << " value of " << sizeRequested << " adjusted to " << dfltSize;
             sizeRequested = dfltSize;
         }
 
-        if(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)
+            if (i == 0)
             {
                 setRecvBufferSize(_fd, sizeRequested);
                 *addr = getRecvBufferSize(_fd);
@@ -770,21 +750,21 @@ IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
             // 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.
+            if (*addr == 0) // set buffer size not supported.
             {
                 *addr = sizeRequested;
             }
-            else if(*addr < sizeRequested)
+            else if (*addr < sizeRequested)
             {
                 BufSizeWarnInfo winfo = _instance->getBufSizeWarn(UDPEndpointType);
-                if((isSnd && (!winfo.sndWarn || winfo.sndSize != sizeRequested)) ||
-                   (!isSnd && (!winfo.rcvWarn || winfo.rcvSize != sizeRequested)))
+                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;
+                    out << "UDP " << direction << " buffer size: requested size of " << sizeRequested << " adjusted to "
+                        << *addr;
 
-                    if(isSnd)
+                    if (isSnd)
                     {
                         _instance->setSndBufSizeWarn(UDPEndpointType, sizeRequested);
                     }