zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,17 +1,13 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/UdpEndpointI.h>
 #include <Ice/Network.h>
 #include <Ice/UdpConnector.h>
 #include <Ice/UdpTransceiver.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/LocalException.h>
 #include <Ice/Protocol.h>
 #include <Ice/ProtocolInstance.h>
@@ -22,7 +18,9 @@ using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(UdpEndpointI* p) { return p; }
+#endif
 
 extern "C"
 {
@@ -35,6 +33,26 @@ createIceUDP(const CommunicatorPtr& c, const string&, const StringSeq&)
 
 }
 
+namespace Ice
+{
+
+ICE_API void
+registerIceUDP(bool loadOnInitialize)
+{
+    Ice::registerPluginFactory("IceUDP", createIceUDP, loadOnInitialize);
+}
+
+}
+
+//
+// Objective-C function to allow Objective-C programs to register plugin.
+//
+extern "C" ICE_API void
+ICEregisterIceUDP(bool loadOnInitialize)
+{
+    Ice::registerIceUDP(loadOnInitialize);
+}
+
 IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, const string& host, Int port,
                                         const Address& sourceAddr, const string& mcastInterface, Int mttl, bool conn,
                                         const string& conId, bool co) :
@@ -54,13 +72,13 @@ IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance) :
 {
 }
 
-IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, BasicStream* s) :
+IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, InputStream* s) :
     IPEndpointI(instance, s),
     _mcastTtl(-1),
     _connect(false),
     _compress(false)
 {
-    if(s->getReadEncoding() == Ice::Encoding_1_0)
+    if(s->getEncoding() == Ice::Encoding_1_0)
     {
         Ice::Byte b;
         s->read(b);
@@ -73,10 +91,25 @@ IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, Bas
     s->read(const_cast<bool&>(_compress));
 }
 
+void
+IceInternal::UdpEndpointI::streamWriteImpl(OutputStream* s) const
+{
+    IPEndpointI::streamWriteImpl(s);
+    if(s->getEncoding() == Ice::Encoding_1_0)
+    {
+        s->write(Ice::Protocol_1_0);
+        s->write(Ice::Encoding_1_0);
+    }
+    // Not transmitted.
+    //s->write(_connect);
+    s->write(_compress);
+}
+
 EndpointInfoPtr
-IceInternal::UdpEndpointI::getInfo() const
+IceInternal::UdpEndpointI::getInfo() const ICE_NOEXCEPT
 {
-    Ice::UDPEndpointInfoPtr info = new InfoI<Ice::UDPEndpointInfo>(const_cast<UdpEndpointI*>(this));
+    Ice::UDPEndpointInfoPtr info = ICE_MAKE_SHARED(InfoI<Ice::UDPEndpointInfo>,
+                                                   ICE_DYNAMIC_CAST(UdpEndpointI, ICE_SHARED_FROM_CONST_THIS(UdpEndpointI)));
     fillEndpointInfo(info.get());
     return info;
 }
@@ -90,7 +123,7 @@ IceInternal::UdpEndpointI::timeout() const
 EndpointIPtr
 IceInternal::UdpEndpointI::timeout(Int) const
 {
-    return const_cast<UdpEndpointI*>(this);
+    return ICE_SHARED_FROM_CONST_THIS(UdpEndpointI);
 }
 
 bool
@@ -104,12 +137,12 @@ IceInternal::UdpEndpointI::compress(bool compress) const
 {
     if(compress == _compress)
     {
-        return const_cast<UdpEndpointI*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(UdpEndpointI);
     }
     else
     {
-        return new UdpEndpointI(_instance, _host, _port, _sourceAddr, _mcastInterface, _mcastTtl, _connect,
-                                _connectionId, compress);
+        return ICE_MAKE_SHARED(UdpEndpointI, _instance, _host, _port, _sourceAddr, _mcastInterface, _mcastTtl,
+                               _connect, _connectionId, compress);
     }
 }
 
@@ -122,7 +155,8 @@ IceInternal::UdpEndpointI::datagram() const
 TransceiverPtr
 IceInternal::UdpEndpointI::transceiver() const
 {
-    return new UdpTransceiver(const_cast<UdpEndpointI*>(this), _instance, _host, _port, _mcastInterface, _connect);
+    return new UdpTransceiver(ICE_DYNAMIC_CAST(UdpEndpointI, ICE_SHARED_FROM_CONST_THIS(UdpEndpointI)), _instance,
+                              _host, _port, _mcastInterface, _connect);
 }
 
 AcceptorPtr
@@ -134,8 +168,35 @@ IceInternal::UdpEndpointI::acceptor(const string&) const
 UdpEndpointIPtr
 IceInternal::UdpEndpointI::endpoint(const UdpTransceiverPtr& transceiver) const
 {
-    return new UdpEndpointI(_instance, _host, transceiver->effectivePort(), _sourceAddr, _mcastInterface, _mcastTtl,
-                            _connect, _connectionId, _compress);
+    int port = transceiver->effectivePort();
+    if(port == _port)
+    {
+        return ICE_DYNAMIC_CAST(UdpEndpointI, ICE_SHARED_FROM_CONST_THIS(UdpEndpointI));
+    }
+    else
+    {
+        return ICE_MAKE_SHARED(UdpEndpointI, _instance, _host, port, _sourceAddr, _mcastInterface,_mcastTtl, _connect,
+                               _connectionId, _compress);
+    }
+}
+
+void
+IceInternal::UdpEndpointI::initWithOptions(vector<string>& args, bool oaEndpoint)
+{
+    IPEndpointI::initWithOptions(args, oaEndpoint);
+
+    if(_mcastInterface == "*")
+    {
+        if(oaEndpoint)
+        {
+            const_cast<string&>(_mcastInterface) = string();
+        }
+        else
+        {
+            throw EndpointParseException(__FILE__, __LINE__, "`--interface *' not valid for proxy endpoint `" +
+                                         toString() + "'");
+        }
+    }
 }
 
 string
@@ -153,7 +214,17 @@ IceInternal::UdpEndpointI::options() const
 
     if(_mcastInterface.length() > 0)
     {
-        s << " --interface " << _mcastInterface;
+        s << " --interface ";
+        bool addQuote = _mcastInterface.find(':') != string::npos;
+        if(addQuote)
+        {
+            s << "\"";
+        }
+        s << _mcastInterface;
+        if(addQuote)
+        {
+            s << "\"";
+        }
     }
 
     if(_mcastTtl != -1)
@@ -175,7 +246,11 @@ IceInternal::UdpEndpointI::options() const
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceInternal::UdpEndpointI::operator==(const Endpoint& r) const
+#else
 IceInternal::UdpEndpointI::operator==(const LocalObject& r) const
+#endif
 {
     if(!IPEndpointI::operator==(r))
     {
@@ -217,7 +292,11 @@ IceInternal::UdpEndpointI::operator==(const LocalObject& r) const
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceInternal::UdpEndpointI::operator<(const Endpoint& r) const
+#else
 IceInternal::UdpEndpointI::operator<(const LocalObject& r) const
+#endif
 {
     const UdpEndpointI* p = dynamic_cast<const UdpEndpointI*>(&r);
     if(!p)
@@ -274,20 +353,6 @@ IceInternal::UdpEndpointI::operator<(const LocalObject& r) const
     return IPEndpointI::operator<(r);
 }
 
-void
-IceInternal::UdpEndpointI::streamWriteImpl(BasicStream* s) const
-{
-    IPEndpointI::streamWriteImpl(s);
-    if(s->getWriteEncoding() == Ice::Encoding_1_0)
-    {
-        s->write(Ice::Protocol_1_0);
-        s->write(Ice::Encoding_1_0);
-    }
-    // Not transmitted.
-    //s->write(_connect);
-    s->write(_compress);
-}
-
 void
 IceInternal::UdpEndpointI::hashInit(Ice::Int& h) const
 {
@@ -324,9 +389,8 @@ IceInternal::UdpEndpointI::checkOption(const string& option, const string& argum
     {
         if(!argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "unexpected argument `" + argument + "' provided for -c option in " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__,  "unexpected argument `" + argument +
+                                         "' provided for -c option in " + endpoint);
         }
         const_cast<bool&>(_connect) = true;
     }
@@ -334,9 +398,8 @@ IceInternal::UdpEndpointI::checkOption(const string& option, const string& argum
     {
         if(!argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "unexpected argument `" + argument + "' provided for -z option in " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
+                                         "' provided for -z option in " + endpoint);
         }
         const_cast<bool&>(_compress) = true;
     }
@@ -344,9 +407,8 @@ IceInternal::UdpEndpointI::checkOption(const string& option, const string& argum
     {
         if(argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for " + option + " option in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for " + option +
+                                         " option in endpoint " + endpoint);
         }
         try
         {
@@ -357,20 +419,18 @@ IceInternal::UdpEndpointI::checkOption(const string& option, const string& argum
                 _instance->logger()->warning("deprecated udp endpoint option: " + option);
             }
         }
-        catch(const VersionParseException& e)
+        catch(const VersionParseException& ex)
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid version `" + argument + "' in endpoint " + endpoint + ":\n" + e.str;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "invalid version `" + argument + "' in endpoint " +
+                                         endpoint + ":\n" + ex.str);
         }
     }
     else if(option == "--interface")
     {
         if(argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for --interface option in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for --interface option in endpoint "
+                                         + endpoint);
         }
         const_cast<string&>(_mcastInterface) = argument;
     }
@@ -378,16 +438,14 @@ IceInternal::UdpEndpointI::checkOption(const string& option, const string& argum
     {
         if(argument.empty())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for --ttl option in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for --ttl option in endpoint " +
+                                         endpoint);
         }
         istringstream p(argument);
         if(!(p >> const_cast<Int&>(_mcastTtl)) || !p.eof())
         {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid TTL value `" + argument + "' in endpoint " + endpoint;
-            throw ex;
+            throw EndpointParseException(__FILE__, __LINE__, "invalid TTL value `" + argument + "' in endpoint " +
+                                         endpoint);
         }
     }
     else
@@ -406,8 +464,8 @@ IceInternal::UdpEndpointI::createConnector(const Address& address, const Network
 IPEndpointIPtr
 IceInternal::UdpEndpointI::createEndpoint(const string& host, int port, const string& connectionId) const
 {
-    return new UdpEndpointI(_instance, host, port, _sourceAddr, _mcastInterface, _mcastTtl, _connect, connectionId,
-                            _compress);
+    return ICE_MAKE_SHARED(UdpEndpointI, _instance, host, port, _sourceAddr, _mcastInterface, _mcastTtl, _connect,
+                           connectionId, _compress);
 }
 
 IceInternal::UdpEndpointFactory::UdpEndpointFactory(const ProtocolInstancePtr& instance) : _instance(instance)
@@ -433,15 +491,15 @@ IceInternal::UdpEndpointFactory::protocol() const
 EndpointIPtr
 IceInternal::UdpEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
 {
-    IPEndpointIPtr endpt = new UdpEndpointI(_instance);
+    IPEndpointIPtr endpt = ICE_MAKE_SHARED(UdpEndpointI, _instance);
     endpt->initWithOptions(args, oaEndpoint);
     return endpt;
 }
 
 EndpointIPtr
-IceInternal::UdpEndpointFactory::read(BasicStream* s) const
+IceInternal::UdpEndpointFactory::read(InputStream* s) const
 {
-    return new UdpEndpointI(_instance, s);
+    return ICE_MAKE_SHARED(UdpEndpointI, _instance, s);
 }
 
 void

data/ext/ice/cpp/src/Ice/UdpEndpointI.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_UDP_ENDPOINT_I_H
 #define ICE_UDP_ENDPOINT_I_H
@@ -25,9 +20,11 @@ public:
     UdpEndpointI(const ProtocolInstancePtr&, const std::string&, Ice::Int, const Address&, const std::string&,
                  Ice::Int, bool, const std::string&, bool);
     UdpEndpointI(const ProtocolInstancePtr&);
-    UdpEndpointI(const ProtocolInstancePtr&, BasicStream*);
+    UdpEndpointI(const ProtocolInstancePtr&, Ice::InputStream*);
+
+    virtual void streamWriteImpl(Ice::OutputStream*) const;
 
-    virtual Ice::EndpointInfoPtr getInfo() const;
+    virtual Ice::EndpointInfoPtr getInfo() const ICE_NOEXCEPT;
 
     virtual Ice::Int timeout() const;
     virtual EndpointIPtr timeout(Ice::Int) const;
@@ -39,16 +36,22 @@ public:
     virtual AcceptorPtr acceptor(const std::string&) const;
     virtual std::string options() const;
 
+#ifdef ICE_CPP11_MAPPING
+    virtual bool operator==(const Ice::Endpoint&) const;
+    virtual bool operator<(const Ice::Endpoint&) const;
+#else
     virtual bool operator==(const Ice::LocalObject&) const;
     virtual bool operator<(const Ice::LocalObject&) const;
+#endif
 
     UdpEndpointIPtr endpoint(const UdpTransceiverPtr&) const;
 
     using IPEndpointI::connectionId;
 
+    virtual void initWithOptions(std::vector<std::string>&, bool);
+
 protected:
 
-    virtual void streamWriteImpl(BasicStream*) const;
     virtual void hashInit(Ice::Int&) const;
     virtual void fillEndpointInfo(Ice::IPEndpointInfo*) const;
     virtual bool checkOption(const std::string&, const std::string&, const std::string&);
@@ -77,7 +80,7 @@ public:
     virtual Ice::Short type() const;
     virtual std::string protocol() const;
     virtual EndpointIPtr create(std::vector<std::string>&, bool) const;
-    virtual EndpointIPtr read(BasicStream*) const;
+    virtual EndpointIPtr read(Ice::InputStream*) const;
     virtual void destroy();
 
     virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const;

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/UdpTransceiver.h>
 #include <Ice/UdpEndpointI.h>
@@ -17,14 +12,14 @@
 #include <Ice/Properties.h>
 #include <IceUtil/StringUtil.h>
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 #   include <ppltasks.h> // For Concurrency::task
 #endif
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 using namespace Platform;
 using namespace Windows::Foundation;
 using namespace Windows::Storage::Streams;
@@ -40,11 +35,11 @@ IceInternal::UdpTransceiver::getNativeInfo()
     return this;
 }
 
-
-#if defined(ICE_USE_IOCP)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 AsyncInfo*
 IceInternal::UdpTransceiver::getAsyncInfo(SocketOperation status)
 {
+#if defined(ICE_USE_IOCP)
     switch(status)
     {
     case SocketOperationRead:
@@ -55,31 +50,15 @@ IceInternal::UdpTransceiver::getAsyncInfo(SocketOperation status)
         assert(false);
         return 0;
     }
-}
-#elif defined(ICE_OS_WINRT)
-void
-IceInternal::UdpTransceiver::setCompletedHandler(SocketOperationCompletedHandler^ handler)
-{
-    _completedHandler = handler;
-    _writeOperationCompletedHandler = ref new AsyncOperationCompletedHandler<unsigned int>(
-        [=] (IAsyncOperation<unsigned int>^ operation, Windows::Foundation::AsyncStatus status)
-        {
-            if(status != Windows::Foundation::AsyncStatus::Completed)
-            {
-                _write.count = SOCKET_ERROR;
-                _write.error = operation->ErrorCode.Value;
-            }
-            else
-            {
-                _write.count = static_cast<int>(operation->GetResults());
-            }
-            _completedHandler(SocketOperationWrite);
-        });
+#elif defined(ICE_OS_UWP)
+    UNREFERENCED_PARAMETER(status);
+    return &_write;
+#endif
 }
 #endif
 
 SocketOperation
-IceInternal::UdpTransceiver::initialize(Buffer& /*readBuffer*/, Buffer& /*writeBuffer*/, bool& /*hasMoreData*/)
+IceInternal::UdpTransceiver::initialize(Buffer& /*readBuffer*/, Buffer& /*writeBuffer*/)
 {
     if(_state == StateNeedConnect)
     {
@@ -90,10 +69,18 @@ IceInternal::UdpTransceiver::initialize(Buffer& /*readBuffer*/, Buffer& /*writeB
     {
 #if defined(ICE_USE_IOCP)
         doFinishConnectAsync(_fd, _write);
-#elif defined(ICE_OS_WINRT)
-        if(_write.count == SOCKET_ERROR)
+#elif defined(ICE_OS_UWP)
+        if(_write.error != ERROR_SUCCESS)
         {
-            checkConnectErrorCode(__FILE__, __LINE__, _write.error, _addr.host);
+            try
+            {
+                checkConnectErrorCode(__FILE__, __LINE__, _write.error);
+            }
+            catch(Ice::DNSException& ex)
+            {
+                ex.host = wstringToString(_addr.host->RawName->Data(), Ice::getProcessStringConverter());
+                throw;
+            }
         }
 #else
         doFinishConnect(_fd);
@@ -115,16 +102,15 @@ IceInternal::UdpTransceiver::closing(bool, const Ice::LocalException&)
 void
 IceInternal::UdpTransceiver::close()
 {
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     IceUtil::Mutex::Lock lock(_mutex);
     if(_readPending)
     {
         assert(_received.empty());
-        _completedHandler(SocketOperationRead);
+        completed(SocketOperationRead);
         _readPending = false;
     }
     _received.clear();
-    _completedHandler = nullptr;
 #endif
 
     assert(_fd != INVALID_SOCKET);
@@ -149,10 +135,10 @@ IceInternal::UdpTransceiver::bind()
         // address won't be the multicast address and the client will
         // therefore reject the datagram.
         //
-        const_cast<Address&>(_addr) = getAddressForServer("", _port, getProtocolSupport(_addr), false);
+        const_cast<Address&>(_addr) = getAddressForServer("", _port, getProtocolSupport(_addr), false, false);
 #endif
 
-        const_cast<Address&>(_addr) = doBind(_fd, _addr);
+        const_cast<Address&>(_addr) = doBind(_fd, _addr, _mcastInterface);
         if(getPort(_mcastAddr) == 0)
         {
             setPort(_mcastAddr, getPort(_addr));
@@ -192,7 +178,7 @@ IceInternal::UdpTransceiver::write(Buffer& buf)
     {
         return SocketOperationNone;
     }
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     return SocketOperationWrite;
 #else
     assert(buf.i == buf.b.begin());
@@ -226,9 +212,7 @@ repeat:
         else
         {
             // No peer has sent a datagram yet.
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = 0;
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, 0);
         }
 
 #   ifdef _WIN32
@@ -252,9 +236,7 @@ repeat:
             return SocketOperationWrite;
         }
 
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     assert(ret == static_cast<ssize_t>(buf.b.size()));
@@ -264,26 +246,34 @@ repeat:
 }
 
 SocketOperation
-IceInternal::UdpTransceiver::read(Buffer& buf, bool&)
+IceInternal::UdpTransceiver::read(Buffer& buf)
 {
     if(buf.i == buf.b.end())
     {
         return SocketOperationNone;
     }
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     return SocketOperationRead;
 #else
 
     assert(buf.i == buf.b.begin());
     assert(_fd != INVALID_SOCKET);
 
-    const int packetSize = min(_maxPacketSize, _rcvSize - _udpOverhead);
+#ifdef _WIN32
+    int packetSize = min(_maxPacketSize, _rcvSize - _udpOverhead);
+#else
+    const size_t packetSize = static_cast<size_t>(min(_maxPacketSize, _rcvSize - _udpOverhead));
+#endif
     buf.b.resize(packetSize);
     buf.i = buf.b.begin();
 
 repeat:
 
+#ifdef _WIN32
+    int ret;
+#else
     ssize_t ret;
+#endif
     if(_state == StateConnected)
     {
         ret = ::recv(_fd, reinterpret_cast<char*>(&buf.b[0]), packetSize, 0);
@@ -328,15 +318,11 @@ repeat:
 
             if(connectionLost())
             {
-                ConnectionLostException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
             }
             else
             {
-                SocketException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
         }
     }
@@ -363,13 +349,13 @@ repeat:
         }
     }
 
-    buf.b.resize(ret);
+    buf.b.resize(static_cast<size_t>(ret));
     buf.i = buf.b.end();
     return SocketOperationNone;
 #endif
 }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 bool
 IceInternal::UdpTransceiver::startWrite(Buffer& buf)
 {
@@ -379,7 +365,7 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
     assert(min(_maxPacketSize, _sndSize - _udpOverhead) >= static_cast<int>(buf.b.size()));
     assert(_fd != INVALID_SOCKET);
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     if(_state < StateConnected)
     {
         try
@@ -388,60 +374,46 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
             if(!multicast)
             {
                 auto operation = safe_cast<DatagramSocket^>(_fd)->ConnectAsync(_addr.host, _addr.port);
-                if(!checkIfErrorOrCompleted(SocketOperationConnect, operation))
+                if(!checkIfErrorOrCompleted(SocketOperationConnect, operation, operation->Status))
                 {
-                    SocketOperationCompletedHandler^ completed = _completedHandler;
                     operation->Completed = ref new AsyncActionCompletedHandler(
-                        [=] (IAsyncAction^ info, Windows::Foundation::AsyncStatus status)
+                        [this] (IAsyncAction^ info, Windows::Foundation::AsyncStatus status)
                         {
-                            if(status != Windows::Foundation::AsyncStatus::Completed)
-                            {
-                                _write.count = SOCKET_ERROR;
-                                _write.error = info->ErrorCode.Value;
-                            }
-                            else
-                            {
-                                _write.count = 0;
-                                _writer = ref new DataWriter(safe_cast<DatagramSocket^>(_fd)->OutputStream);
-                            }
-                            completed(SocketOperationConnect);
+                            //
+                            // COMPILERFIX with v141 using operator!= and operator== inside
+                            // a lambda callback triggers a compiler bug, we move the code to
+                            // a seperate private method to workaround the issue.
+                            //
+                            connectCompleted(info, status);
                         });
                 }
                 else
                 {
                     _write.count = 0;
+                    _write.error = ERROR_SUCCESS;
                     _writer = ref new DataWriter(safe_cast<DatagramSocket^>(_fd)->OutputStream);
                 }
             }
             else
             {
                 auto operation = safe_cast<DatagramSocket^>(_fd)->GetOutputStreamAsync(_addr.host, _addr.port);
-                if(!checkIfErrorOrCompleted(SocketOperationConnect, operation))
+                if(!checkIfErrorOrCompleted(SocketOperationConnect, operation, operation->Status))
                 {
-                    SocketOperationCompletedHandler^ completed = _completedHandler;
                     operation->Completed = ref new AsyncOperationCompletedHandler<IOutputStream^>(
-                        [=] (IAsyncOperation<IOutputStream^>^ info, Windows::Foundation::AsyncStatus status)
+                        [=](IAsyncOperation<IOutputStream^>^ info, Windows::Foundation::AsyncStatus status)
                         {
-                            if(status != Windows::Foundation::AsyncStatus::Completed)
-                            {
-                                _write.count = SOCKET_ERROR;
-                                _write.error = info->ErrorCode.Value;
-                            }
-                            else
-                            {
-                                _write.count = 0;
-                                _writer = ref new DataWriter(info->GetResults());
-                            }
-                            if(_mcastAddr.host != nullptr)
-                            {
-                                setMcastGroup(_fd, _mcastAddr, "");
-                            }
-                            completed(SocketOperationConnect);
+                            //
+                            // COMPILERFIX with v141 using operator!= and operator== inside
+                            // a lambda callback triggers a compiler bug, we move the code to
+                            // a seperate private method to workaround the issue.
+                            //
+                            getOutputStreamMcastCompleted(info, status);
                         });
                 }
                 else
                 {
                     _write.count = 0;
+                    _write.error = ERROR_SUCCESS;
                     _writer = ref new DataWriter(operation->GetResults());
                     if(_mcastAddr.host != nullptr)
                     {
@@ -452,7 +424,7 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
         }
         catch(Platform::Exception^ ex)
         {
-            checkConnectErrorCode(__FILE__, __LINE__, ex->HResult, _addr.host);
+            checkConnectErrorCode(__FILE__, __LINE__, ex->HResult);
         }
         return false;
     }
@@ -460,52 +432,16 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
     {
         try
         {
-            SocketOperationCompletedHandler^ completed = _completedHandler;
             DatagramSocket^ fd = safe_cast<DatagramSocket^>(_fd);
             concurrency::create_task(fd->GetOutputStreamAsync(_peerAddr.host, _peerAddr.port)).then(
-                [=,&buf](concurrency::task<IOutputStream^> task)
+                [=, &buf](concurrency::task<IOutputStream^> task)
                 {
-                    try
-                    {
-                        DataWriter^ writer = ref new DataWriter(task.get());
-                        writer->WriteBytes(ref new Array<unsigned char>(&*buf.i, static_cast<int>(buf.b.size())));
-                        DataWriterStoreOperation^ operation = writer->StoreAsync();
-
-                        Windows::Foundation::AsyncStatus status = operation->Status;
-                        if(status == Windows::Foundation::AsyncStatus::Completed)
-                        {
-                            //
-                            // NOTE: unlike other methods, it's important to modify _write.count
-                            // _before_ calling checkIfErrorOrCompleted since this isn't called
-                            // with the connection mutex but from a Windows thread pool thread.
-                            // So we can't modify the _write structure after calling the
-                            // completed callback.
-                            //
-                            _write.count = operation->GetResults();
-                            completed(SocketOperationWrite);
-                        }
-                        else if(status == Windows::Foundation::AsyncStatus::Started)
-                        {
-                            operation->Completed = _writeOperationCompletedHandler;
-                        }
-                        else
-                        {
-                            if(_state < StateConnected)
-                            {
-                                checkConnectErrorCode(__FILE__, __LINE__, operation->ErrorCode.Value, _addr.host);
-                            }
-                            else
-                            {
-                                checkErrorCode(__FILE__, __LINE__, operation->ErrorCode.Value);
-                            }
-                        }
-                    }
-                    catch(Platform::Exception^ pex)
-                    {
-                        _write.count = SOCKET_ERROR;
-                        _write.error = pex->HResult;
-                        completed(SocketOperationWrite);
-                    }
+                    //
+                    // COMPILERFIX with v141 using operator!= and operator== inside
+                    // a lambda callback triggers a compiler bug, we move the code to
+                    // a seperate private method to workaround the issue.
+                    //
+                    getOutputStreamCompleted(task, buf);
                 });
         }
         catch(Platform::Exception^ ex)
@@ -519,15 +455,7 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
         try
         {
             _writer->WriteBytes(ref new Array<unsigned char>(&*buf.i, static_cast<int>(buf.b.size())));
-            DataWriterStoreOperation^ operation = _writer->StoreAsync();
-            if(checkIfErrorOrCompleted(SocketOperationWrite, operation))
-            {
-                _write.count = operation->GetResults();
-            }
-            else
-            {
-                operation->Completed = _writeOperationCompletedHandler;
-            }
+            queueOperation(SocketOperationWrite, _writer->StoreAsync());
         }
         catch(Platform::Exception^ ex)
         {
@@ -538,10 +466,11 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
 #else
     _write.buf.len = static_cast<int>(buf.b.size());
     _write.buf.buf = reinterpret_cast<char*>(&*buf.i);
+    _write.error = ERROR_SUCCESS;
     int err;
     if(_state == StateConnected)
     {
-        err = WSASend(_fd, &_write.buf, 1, &_write.count, 0, &_write, NULL);
+        err = WSASend(_fd, &_write.buf, 1, &_write.count, 0, &_write, ICE_NULLPTR);
     }
     else
     {
@@ -557,12 +486,9 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
         else
         {
             // No peer has sent a datagram yet.
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = 0;
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, 0);
         }
-        err = WSASendTo(_fd, &_write.buf, 1, &_write.count, 0, &_peerAddr.sa,
-                        len, &_write, NULL);
+        err = WSASendTo(_fd, &_write.buf, 1, &_write.count, 0, &_peerAddr.sa, len, &_write, ICE_NULLPTR);
     }
 
     if(err == SOCKET_ERROR)
@@ -571,52 +497,103 @@ IceInternal::UdpTransceiver::startWrite(Buffer& buf)
         {
             if(connectionLost())
             {
-                ConnectionLostException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
             }
             else
             {
-                SocketException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
         }
     }
-#endif
     return true;
+#endif
 }
 
+#ifdef ICE_OS_UWP
+void
+IceInternal::UdpTransceiver::connectCompleted(Windows::Foundation::IAsyncAction^ action,
+                                              Windows::Foundation::AsyncStatus status)
+{
+    if(status != Windows::Foundation::AsyncStatus::Completed)
+    {
+        _write.error = action->ErrorCode.Value;
+    }
+    else
+    {
+        _write.error = ERROR_SUCCESS;
+        _writer = ref new DataWriter(safe_cast<DatagramSocket^>(_fd)->OutputStream);
+    }
+    _write.count = 0;
+    completed(SocketOperationConnect);
+}
+
+void
+IceInternal::UdpTransceiver::getOutputStreamMcastCompleted(IAsyncOperation<IOutputStream^>^ operation,
+                                                           Windows::Foundation::AsyncStatus status)
+{
+    if(status != Windows::Foundation::AsyncStatus::Completed)
+    {
+        _write.error = operation->ErrorCode.Value;
+    }
+    else
+    {
+        _write.error = ERROR_SUCCESS;
+        _writer = ref new DataWriter(operation->GetResults());
+    }
+    _write.count = 0;
+    if(_mcastAddr.host != nullptr)
+    {
+        setMcastGroup(_fd, _mcastAddr, "");
+    }
+    completed(SocketOperationConnect);
+}
+
+void
+IceInternal::UdpTransceiver::getOutputStreamCompleted(concurrency::task<IOutputStream^> task, Buffer& buf)
+{
+    try
+    {
+        DataWriter^ writer = ref new DataWriter(task.get());
+        writer->WriteBytes(ref new Array<unsigned char>(&*buf.i, static_cast<int>(buf.b.size())));
+        DataWriterStoreOperation^ operation = writer->StoreAsync();
+        queueOperation(SocketOperationWrite, operation);
+    }
+    catch(Platform::Exception^ pex)
+    {
+        _write.count = 0;
+        _write.error = pex->HResult;
+        completed(SocketOperationWrite);
+    }
+}
+
+#endif
+
 void
 IceInternal::UdpTransceiver::finishWrite(Buffer& buf)
 {
-    if(_state < StateConnected)
+    if(_fd == INVALID_SOCKET || _state < StateConnected)
     {
         return;
     }
 
-    if(static_cast<int>(_write.count) == SOCKET_ERROR)
+    if(_write.error != ERROR_SUCCESS)
     {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
         WSASetLastError(_write.error);
         if(connectionLost())
         {
-            ConnectionLostException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectionLostException(__FILE__, __LINE__ ,getSocketErrno());
         }
         else
         {
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
 #else
         checkErrorCode(__FILE__, __LINE__, _write.error);
 #endif
     }
 
-    assert(_write.count == buf.b.size());
+    assert(static_cast<size_t>(_write.count) == buf.b.size());
     buf.i = buf.b.end();
 }
 
@@ -627,21 +604,22 @@ IceInternal::UdpTransceiver::startRead(Buffer& buf)
     buf.b.resize(packetSize);
     buf.i = buf.b.begin();
     assert(!buf.b.empty() && buf.i != buf.b.end());
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     _read.buf.len = packetSize;
     _read.buf.buf = reinterpret_cast<char*>(&*buf.i);
+    _read.error = ERROR_SUCCESS;
     int err;
     if(_state == StateConnected)
     {
-        err = WSARecv(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_read, NULL);
+        err = WSARecv(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_read, ICE_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, NULL);
+        err = WSARecvFrom(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_readAddr.sa, &_readAddrLen, &_read,
+                          ICE_NULLPTR);
     }
 
     if(err == SOCKET_ERROR)
@@ -654,15 +632,11 @@ IceInternal::UdpTransceiver::startRead(Buffer& buf)
         {
             if(connectionLost())
             {
-                ConnectionLostException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
             }
             else
             {
-                SocketException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
         }
     }
@@ -671,7 +645,7 @@ IceInternal::UdpTransceiver::startRead(Buffer& buf)
     assert(!_readPending);
     if(!_received.empty())
     {
-        _completedHandler(SocketOperationRead);
+        completed(SocketOperationRead);
     }
     else
     {
@@ -681,9 +655,9 @@ IceInternal::UdpTransceiver::startRead(Buffer& buf)
 }
 
 void
-IceInternal::UdpTransceiver::finishRead(Buffer& buf, bool&)
+IceInternal::UdpTransceiver::finishRead(Buffer& buf)
 {
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     IceUtil::Mutex::Lock lock(_mutex);
     assert(!_readPending && (!_received.empty() || _fd == INVALID_SOCKET));
     if(_fd == INVALID_SOCKET)
@@ -694,7 +668,7 @@ IceInternal::UdpTransceiver::finishRead(Buffer& buf, bool&)
     DatagramSocketMessageReceivedEventArgs^ args = _received.front();
     _received.pop_front();
 
-    int ret;
+    int ret = 0;
     try
     {
         DataReader^ reader = args->GetDataReader();
@@ -715,7 +689,7 @@ IceInternal::UdpTransceiver::finishRead(Buffer& buf, bool&)
         checkErrorCode(__FILE__, __LINE__, ex->HResult);
     }
 #else
-    if(static_cast<int>(_read.count) == SOCKET_ERROR)
+    if(_read.error != ERROR_SUCCESS)
     {
         WSASetLastError(_read.error);
 
@@ -730,15 +704,11 @@ IceInternal::UdpTransceiver::finishRead(Buffer& buf, bool&)
         {
             if(connectionLost())
             {
-                ConnectionLostException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
             }
             else
             {
-                SocketException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
         }
     }
@@ -787,7 +757,7 @@ IceInternal::UdpTransceiver::toString() const
     }
     else
     {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
         s << fdToString(_fd);
 #else
         Address localAddr;
@@ -809,7 +779,15 @@ IceInternal::UdpTransceiver::toDetailedString() const
 {
     ostringstream os;
     os << toString();
-    vector<string> intfs = getHostsForEndpointExpand(inetAddrToString(_addr), _instance->protocolSupport(), true);
+    vector<string> intfs;
+    if(isAddressValid(_mcastAddr))
+    {
+        intfs = getInterfacesForMulticast(_mcastInterface, getProtocolSupport(_mcastAddr));
+    }
+    else
+    {
+        intfs = getHostsForEndpointExpand(inetAddrToString(_addr), _instance->protocolSupport(), true);
+    }
     if(!intfs.empty())
     {
         os << "\nlocal interfaces = ";
@@ -821,8 +799,8 @@ IceInternal::UdpTransceiver::toDetailedString() const
 Ice::ConnectionInfoPtr
 IceInternal::UdpTransceiver::getInfo() const
 {
-    Ice::UDPConnectionInfoPtr info = new Ice::UDPConnectionInfo();
-#if defined(ICE_OS_WINRT)
+    Ice::UDPConnectionInfoPtr info = ICE_MAKE_SHARED(Ice::UDPConnectionInfo);
+#if defined(ICE_OS_UWP)
     if(isMulticast(_addr) || isAddressValid(_mcastAddr))
     {
         info->remotePort = 0;
@@ -897,7 +875,7 @@ IceInternal::UdpTransceiver::effectivePort() const
 
 IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
                                             const Address& addr,
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
                                             const Address&,
                                             const string&,
                                             int
@@ -915,7 +893,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
 #if defined(ICE_USE_IOCP)
     , _read(SocketOperationRead),
     _write(SocketOperationWrite)
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
     , _readPending(false)
 #endif
 {
@@ -923,7 +901,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
     setBufSize(-1, -1);
     setBlock(_fd, false);
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     _mcastAddr.saStorage.ss_family = AF_UNSPEC;
     _peerAddr.saStorage.ss_family = AF_UNSPEC; // Not initialized yet.
 
@@ -972,7 +950,6 @@ IceInternal::UdpTransceiver::UdpTransceiver(const ProtocolInstancePtr& instance,
         });
 #endif
 
-
 #ifdef ICE_USE_IOCP
     //
     // On Windows when using IOCP, we must make sure that the socket is connected without
@@ -990,11 +967,11 @@ IceInternal::UdpTransceiver::UdpTransceiver(const UdpEndpointIPtr& endpoint, con
     _instance(instance),
     _incoming(true),
     _bound(false),
-    _addr(getAddressForServer(host, port, instance->protocolSupport(), instance->preferIPv6())),
+    _addr(getAddressForServer(host, port, instance->protocolSupport(), instance->preferIPv6(), true)),
     _mcastInterface(mcastInterface),
     _port(port),
     _state(connect ? StateNeedConnect : StateNotConnected)
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     , _readPending(false)
 #elif defined(ICE_USE_IOCP)
     , _read(SocketOperationRead),
@@ -1005,7 +982,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const UdpEndpointIPtr& endpoint, con
     setBufSize(-1, -1);
     setBlock(_fd, false);
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     memset(&_mcastAddr.saStorage, 0, sizeof(sockaddr_storage));
     memset(&_peerAddr.saStorage, 0, sizeof(sockaddr_storage));
     _peerAddr.saStorage.ss_family = AF_UNSPEC;
@@ -1142,43 +1119,7 @@ IceInternal::UdpTransceiver::setBufSize(int rcvSize, int sndSize)
     }
 }
 
-#ifdef ICE_OS_WINRT
-bool
-IceInternal::UdpTransceiver::checkIfErrorOrCompleted(SocketOperation op, IAsyncInfo^ info)
-{
-    //
-    // NOTE: It's important to only check for info->Status once as it
-    // might change during the checks below (the Status can be changed
-    // by the Windows thread pool concurrently).
-    //
-    // We consider that a canceled async status is the same as an
-    // error. A canceled async status can occur if there's a timeout
-    // and the socket is closed.
-    //
-    Windows::Foundation::AsyncStatus status = info->Status;
-    if(status == Windows::Foundation::AsyncStatus::Completed)
-    {
-        _completedHandler(op);
-        return true;
-    }
-    else if(status == Windows::Foundation::AsyncStatus::Started)
-    {
-        return false;
-    }
-    else
-    {
-        if(_state < StateConnected)
-        {
-            checkConnectErrorCode(__FILE__, __LINE__, info->ErrorCode.Value, _addr.host);
-        }
-        else
-        {
-            checkErrorCode(__FILE__, __LINE__, info->ErrorCode.Value);
-        }
-        return true; // Prevent compiler warning.
-    }
-}
-
+#ifdef ICE_OS_UWP
 void
 IceInternal::UdpTransceiver::appendMessage(DatagramSocketMessageReceivedEventArgs^ args)
 {
@@ -1198,7 +1139,7 @@ IceInternal::UdpTransceiver::appendMessage(DatagramSocketMessageReceivedEventArg
     //
     if(_readPending)
     {
-        _completedHandler(SocketOperationRead);
+        completed(SocketOperationRead);
         _readPending = false;
     }
 }