zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/MetricsAdminI.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/MetricsAdminI.h>
 
@@ -23,7 +18,7 @@ using namespace Ice;
 using namespace IceInternal;
 using namespace IceMX;
 
-namespace 
+namespace
 {
 
 const string suffixes[] =
@@ -80,11 +75,11 @@ parseRule(const PropertiesPtr& properties, const string& name)
     {
         try
         {
-            regexps.push_back(new MetricsMapI::RegExp(p->first.substr(name.length() + 1), p->second));
+            regexps.push_back(ICE_MAKE_SHARED(MetricsMapI::RegExp, p->first.substr(name.length() + 1), p->second));
         }
         catch(const std::exception&)
         {
-            throw "invalid regular expression `" + p->second + "' for `" + p->first + "'";
+            throw invalid_argument("invalid regular expression `" + p->second + "' for `" + p->first + "'");
         }
     }
     return regexps;
@@ -99,10 +94,10 @@ MetricsMapI::RegExp::RegExp(const string& attribute, const string& regexp) : _at
     // No regexp support with MinGW, when MinGW C++11 mode is not experimental
     // we can use std::regex.
     //
-#elif !defined(ICE_CPP11_REGEXP)
+#elif !defined(ICE_CPP11_COMPILER_REGEXP)
     if(regcomp(&_preg, regexp.c_str(), REG_EXTENDED | REG_NOSUB) != 0)
     {
-        throw SyscallException(__FILE__, __LINE__); 
+        throw SyscallException(__FILE__, __LINE__);
     }
 #else
 #   if _MSC_VER < 1600
@@ -120,7 +115,7 @@ MetricsMapI::RegExp::~RegExp()
     // No regexp support with MinGW, when MinGW C++11 mode is not experimental
     // we can use std::regex.
     //
-#elif !defined(ICE_CPP11_REGEXP)
+#elif !defined(ICE_CPP11_COMPILER_REGEXP)
     regfree(&_preg);
 #endif
 }
@@ -134,7 +129,7 @@ MetricsMapI::RegExp::match(const string& value)
     // we can use std::regex.
     //
     return false;
-#elif !defined(ICE_CPP11_REGEXP)
+#elif !defined(ICE_CPP11_COMPILER_REGEXP)
     return regexec(&_preg, value.c_str(), 0, 0, 0) == 0;
 #else
 #   if _MSC_VER < 1600
@@ -145,6 +140,11 @@ MetricsMapI::RegExp::match(const string& value)
 #endif
 }
 
+MetricsMapI::~MetricsMapI()
+{
+    // Out of line to avoid weak vtable
+}
+
 MetricsMapI::MetricsMapI(const std::string& mapPrefix, const PropertiesPtr& properties) :
     _properties(properties->getPropertiesForPrefix(mapPrefix)),
     _retain(properties->getPropertyAsIntWithDefault(mapPrefix + "RetainDetached", 10)),
@@ -164,7 +164,7 @@ MetricsMapI::MetricsMapI(const std::string& mapPrefix, const PropertiesPtr& prop
         {
             groupByAttributes.push_back("");
         }
-        
+
         for(string::const_iterator p = groupBy.begin(); p != groupBy.end(); ++p)
         {
             bool isAlphaNum = IceUtilInternal::isAlpha(*p) || IceUtilInternal::isDigit(*p) || *p == '.';
@@ -198,6 +198,11 @@ MetricsMapI::MetricsMapI(const std::string& mapPrefix, const PropertiesPtr& prop
 }
 
 MetricsMapI::MetricsMapI(const MetricsMapI& map) :
+#if defined(ICE_CPP11_MAPPING)
+    std::enable_shared_from_this<MetricsMapI>(),
+#elif defined(__GNUC__)
+    IceUtil::Shared(),
+#endif
     _properties(map._properties),
     _groupByAttributes(map._groupByAttributes),
     _groupBySeparators(map._groupBySeparators),
@@ -213,6 +218,11 @@ MetricsMapI::getProperties() const
     return _properties;
 }
 
+MetricsMapFactory::~MetricsMapFactory()
+{
+    // Out of line to avoid weak vtable
+}
+
 MetricsMapFactory::MetricsMapFactory(Updater* updater) : _updater(updater)
 {
 }
@@ -223,7 +233,7 @@ MetricsMapFactory::update()
     assert(_updater);
     _updater->update();
 }
-    
+
 MetricsViewI::MetricsViewI(const string& name) : _name(name)
 {
 }
@@ -238,7 +248,7 @@ MetricsViewI::destroy()
 }
 
 bool
-MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapName, 
+MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapName,
                              const MetricsMapFactoryPtr& factory, const ::Ice::LoggerPtr& logger)
 {
     const string viewPrefix = "IceMX.Metrics." + _name + ".";
@@ -305,11 +315,6 @@ MetricsViewI::addOrUpdateMap(const PropertiesPtr& properties, const string& mapN
         ::Ice::Warning warn(logger);
         warn << "unexpected exception while creating metrics map:\n" << ex;
     }
-    catch(const string& msg)
-    {
-        ::Ice::Warning warn(logger);
-        warn << msg;
-    }
     return true;
 }
 
@@ -378,10 +383,10 @@ MetricsViewI::getMap(const string& mapName) const
     {
         return p->second;
     }
-    return 0;
+    return ICE_NULLPTR;
 }
 
-MetricsAdminI::MetricsAdminI(const PropertiesPtr& properties, const LoggerPtr& logger) : 
+MetricsAdminI::MetricsAdminI(const PropertiesPtr& properties, const LoggerPtr& logger) :
     _logger(logger), _properties(properties)
 {
     updateViews();
@@ -439,23 +444,23 @@ MetricsAdminI::updateViews()
             map<string, MetricsViewIPtr>::const_iterator q = _views.find(viewName);
             if(q == _views.end())
             {
-                q = views.insert(map<string, MetricsViewIPtr>::value_type(viewName, new MetricsViewI(viewName))).first;
+                q = views.insert(map<string, MetricsViewIPtr>::value_type(viewName, ICE_MAKE_SHARED(MetricsViewI, viewName))).first;
             }
             else
             {
                 q = views.insert(make_pair(viewName, q->second)).first;
             }
 
-            for(map<string, MetricsMapFactoryPtr>::const_iterator p = _factories.begin(); p != _factories.end(); ++p)
+            for(map<string, MetricsMapFactoryPtr>::const_iterator r = _factories.begin(); r != _factories.end(); ++r)
             {
-                if(q->second->addOrUpdateMap(_properties, p->first, p->second, _logger))
+                if(q->second->addOrUpdateMap(_properties, r->first, r->second, _logger))
                 {
-                    updatedMaps.insert(p->second);
+                    updatedMaps.insert(r->second);
                 }
             }
         }
         _views.swap(views);
-        
+
         //
         // Go through removed views to collect maps to update.
         //
@@ -472,7 +477,7 @@ MetricsAdminI::updateViews()
             }
         }
     }
-    
+
     //
     // Call the updaters to update the maps.
     //
@@ -523,13 +528,17 @@ MetricsAdminI::getMetricsViewNames(Ice::StringSeq& disabledViews, const Current&
 
 #else
     disabledViews.insert(disabledViews.end(), _disabledViews.begin(), _disabledViews.end());
-#endif    
+#endif
 
     return enabledViews;
 }
 
 void
+#ifdef ICE_CPP11_MAPPING
+MetricsAdminI::enableMetricsView(string viewName, const Current&)
+#else
 MetricsAdminI::enableMetricsView(const string& viewName, const Current&)
+#endif
 {
     {
         Lock sync(*this);
@@ -540,7 +549,11 @@ MetricsAdminI::enableMetricsView(const string& viewName, const Current&)
 }
 
 void
+#ifdef ICE_CPP11_MAPPING
+MetricsAdminI::disableMetricsView(string viewName, const Current&)
+#else
 MetricsAdminI::disableMetricsView(const string& viewName, const Current&)
+#endif
 {
     {
         Lock sync(*this);
@@ -551,7 +564,11 @@ MetricsAdminI::disableMetricsView(const string& viewName, const Current&)
 }
 
 MetricsView
+#ifdef ICE_CPP11_MAPPING
+MetricsAdminI::getMetricsView(string viewName, ::Ice::Long& timestamp, const Current&)
+#else
 MetricsAdminI::getMetricsView(const string& viewName, ::Ice::Long& timestamp, const Current&)
+#endif
 {
     Lock sync(*this);
     MetricsViewIPtr view = getMetricsView(viewName);
@@ -564,7 +581,11 @@ MetricsAdminI::getMetricsView(const string& viewName, ::Ice::Long& timestamp, co
 }
 
 MetricsFailuresSeq
+#ifdef ICE_CPP11_MAPPING
+MetricsAdminI::getMapMetricsFailures(string viewName, string map, const Current&)
+#else
 MetricsAdminI::getMapMetricsFailures(const string& viewName, const string& map, const Current&)
+#endif
 {
     Lock sync(*this);
     MetricsViewIPtr view = getMetricsView(viewName);
@@ -576,7 +597,11 @@ MetricsAdminI::getMapMetricsFailures(const string& viewName, const string& map,
 }
 
 MetricsFailures
+#ifdef ICE_CPP11_MAPPING
+MetricsAdminI::getMetricsFailures(string viewName, string map, string id, const Current&)
+#else
 MetricsAdminI::getMetricsFailures(const string& viewName, const string& map, const string& id, const Current&)
+#endif
 {
     Lock sync(*this);
     MetricsViewIPtr view = getMetricsView(viewName);
@@ -587,7 +612,7 @@ MetricsAdminI::getMetricsFailures(const string& viewName, const string& map, con
     return MetricsFailures();
 }
 
-vector<MetricsMapIPtr> 
+vector<MetricsMapIPtr>
 MetricsAdminI::getMaps(const string& mapName) const
 {
     Lock sync(*this);
@@ -619,12 +644,12 @@ MetricsAdminI::getMetricsView(const std::string& name)
         {
             throw UnknownMetricsView();
         }
-        return 0;
+        return ICE_NULLPTR;
     }
     return p->second;
 }
 
-void 
+void
 MetricsAdminI::updated(const PropertyDict& props)
 {
     for(PropertyDict::const_iterator p = props.begin(); p != props.end(); ++p)

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

@@ -1,14 +1,8 @@
-// **********************************************************************
 //
-// 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/MetricsObserverI.h>
 
 #include <Ice/Connection.h>
 #include <Ice/Endpoint.h>
-

data/ext/ice/cpp/src/Ice/Network.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.
-//
-// **********************************************************************
 
 //
 // The following is required on HP-UX in order to bring in
@@ -21,17 +16,22 @@
 #include <Ice/Network.h>
 #include <Ice/NetworkProxy.h>
 #include <IceUtil/StringUtil.h>
-#include <IceUtil/StringConverter.h>
+#include <Ice/StringConverter.h>
 #include <Ice/LocalException.h>
 #include <Ice/ProtocolInstance.h> // For setTcpBufSize
 #include <Ice/Properties.h> // For setTcpBufSize
 #include <Ice/LoggerUtil.h> // For setTcpBufSize
 #include <Ice/Buffer.h>
 #include <IceUtil/Random.h>
+#include <functional>
+
+// TODO: fix this warning
+#if defined(_MSC_VER)
+#   pragma warning(disable:4244) // 'argument': conversion from 'int' to 'u_short', possible loss of data
+#endif
 
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
 #   include <IceUtil/InputUtil.h>
-#   include <IceUtil/CountDownLatch.h>
 #elif defined(_WIN32)
 #   include <winsock2.h>
 #   include <ws2tcpip.h>
@@ -52,6 +52,10 @@
 #  include <sys/sockio.h>
 #endif
 
+#if defined(__GNUC__) && (__GNUC__ < 5)
+#  pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
 #if defined(_WIN32)
 #   ifndef SIO_LOOPBACK_FAST_PATH
 #       define SIO_LOOPBACK_FAST_PATH _WSAIOW(IOC_VENDOR,16)
@@ -72,12 +76,12 @@ extern "C"
 }
 #endif
 
-
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
+using namespace Concurrency;
 using namespace Platform;
 using namespace Windows::Foundation;
 using namespace Windows::Foundation::Collections;
@@ -87,40 +91,78 @@ using namespace Windows::Networking::Sockets;
 using namespace Windows::Networking::Connectivity;
 #endif
 
+#ifdef _WIN32
+int
+IceInternal::getSystemErrno()
+{
+    return GetLastError();
+}
+#else
+int
+IceInternal::getSystemErrno()
+{
+    return errno;
+}
+#endif
+
 namespace
 {
 
-#ifndef ICE_OS_WINRT
-struct AddressIsIPv6 : public unary_function<Address, bool>
+struct AddressCompare
 {
 public:
 
     bool
-    operator()(const Address& ss) const
+    operator()(const Address& lhs, const Address& rhs) const
     {
-        return ss.saStorage.ss_family == AF_INET6;
+        return compareAddress(lhs, rhs) < 0;
     }
 };
 
-struct RandomNumberGenerator : public std::unary_function<ptrdiff_t, ptrdiff_t>
+#ifndef ICE_OS_UWP
+
+#   ifndef ICE_CPP11_COMPILER
+
+struct AddressIsIPv6 : public unary_function<Address, bool>
 {
-    ptrdiff_t operator()(ptrdiff_t d)
+public:
+
+    bool
+    operator()(const Address& ss) const
     {
-        return IceUtilInternal::random(static_cast<int>(d));
+        return ss.saStorage.ss_family == AF_INET6;
     }
 };
+#   endif
 
 void
 sortAddresses(vector<Address>& addrs, ProtocolSupport protocol, Ice::EndpointSelectionType selType, bool preferIPv6)
 {
-    if(selType == Ice::Random)
+    if(selType == Ice::ICE_ENUM(EndpointSelectionType, Random))
     {
-        RandomNumberGenerator rng;
-        random_shuffle(addrs.begin(), addrs.end(), rng);
+        IceUtilInternal::shuffle(addrs.begin(), addrs.end());
     }
 
     if(protocol == EnableBoth)
     {
+#ifdef ICE_CPP11_COMPILER
+        if(preferIPv6)
+        {
+            stable_partition(addrs.begin(), addrs.end(),
+                             [](const Address& ss)
+                             {
+                                 return ss.saStorage.ss_family == AF_INET6;
+                             });
+        }
+        else
+        {
+            stable_partition(addrs.begin(), addrs.end(),
+                             [](const Address& ss)
+                             {
+                                 return ss.saStorage.ss_family != AF_INET6;
+                             });
+        }
+#else
         if(preferIPv6)
         {
             stable_partition(addrs.begin(), addrs.end(), AddressIsIPv6());
@@ -129,6 +171,7 @@ sortAddresses(vector& addrs, ProtocolSupport protocol, Ice::EndpointSel
         {
             stable_partition(addrs.begin(), addrs.end(), not1(AddressIsIPv6()));
         }
+#endif
     }
 }
 
@@ -139,9 +182,7 @@ setTcpNoDelay(SOCKET fd)
     if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&flag), int(sizeof(int))) == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 
@@ -152,19 +193,37 @@ setKeepAlive(SOCKET fd)
     if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, reinterpret_cast<char*>(&flag), int(sizeof(int))) == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
+void
+setTcpLoopbackFastPath(SOCKET fd)
+{
+    int OptionValue = 1;
+    DWORD NumberOfBytesReturned = 0;
+
+    int status =
+        WSAIoctl(fd, SIO_LOOPBACK_FAST_PATH, &OptionValue, sizeof(OptionValue), ICE_NULLPTR, 0, &NumberOfBytesReturned, 0, 0);
+    if(status == SOCKET_ERROR)
+    {
+            // On platforms that do not support fast path (< Windows 8), WSAEONOTSUPP is expected.
+        DWORD LastError = ::GetLastError();
+        if(LastError != WSAEOPNOTSUPP)
+        {
+            closeSocketNoThrow(fd);
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
+        }
+    }
+}
+#endif
+
+#ifdef ICE_OS_UWP
 SOCKET
 createSocketImpl(bool udp, int)
 {
-    SOCKET fd;
-
     if(udp)
     {
         return ref new DatagramSocket();
@@ -176,8 +235,6 @@ createSocketImpl(bool udp, int)
         socket->Control->NoDelay = true;
         return socket;
     }
-
-    return fd;
 }
 #else
 SOCKET
@@ -195,9 +252,7 @@ createSocketImpl(bool udp, int family)
 
     if(fd == INVALID_SOCKET)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     if(!udp)
@@ -205,7 +260,7 @@ createSocketImpl(bool udp, int family)
         setTcpNoDelay(fd);
         setKeepAlive(fd);
 
-#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+#if defined(_WIN32) && !defined(ICE_OS_UWP)
         //
         // FIX: the fast path loopback appears to cause issues with
         // connection closure when it's enabled. Sometime, a peer
@@ -222,9 +277,9 @@ createSocketImpl(bool udp, int family)
 }
 #endif
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 vector<Address>
-getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
+getLocalAddresses(ProtocolSupport protocol, bool includeLoopback, bool singleAddressPerInterface)
 {
     vector<Address> result;
 
@@ -243,17 +298,21 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
             break;
     }
 
-    DWORD size;
-    DWORD rv = GetAdaptersAddresses(family, 0, NULL, NULL, &size);
-    if (rv == ERROR_BUFFER_OVERFLOW)
+    DWORD size = 0;
+    DWORD rv = GetAdaptersAddresses(family, 0, ICE_NULLPTR, ICE_NULLPTR, &size);
+    if(rv == ERROR_BUFFER_OVERFLOW)
     {
         PIP_ADAPTER_ADDRESSES adapter_addresses = (PIP_ADAPTER_ADDRESSES) malloc(size);
-        rv = GetAdaptersAddresses(family, 0, NULL, adapter_addresses, &size);
-        if (rv == ERROR_SUCCESS)
+        rv = GetAdaptersAddresses(family, 0, ICE_NULLPTR, adapter_addresses, &size);
+        if(rv == ERROR_SUCCESS)
         {
-            for (PIP_ADAPTER_ADDRESSES aa = adapter_addresses; aa != NULL; aa = aa->Next)
+            for(PIP_ADAPTER_ADDRESSES aa = adapter_addresses; aa != ICE_NULLPTR; aa = aa->Next)
             {
-                for (PIP_ADAPTER_UNICAST_ADDRESS ua = aa->FirstUnicastAddress; ua != NULL; ua = ua->Next)
+                if(aa->OperStatus != IfOperStatusUp)
+                {
+                    continue;
+                }
+                for(PIP_ADAPTER_UNICAST_ADDRESS ua = aa->FirstUnicastAddress; ua != ICE_NULLPTR; ua = ua->Next)
                 {
                     Address addr;
                     memcpy(&addr.saStorage, ua->Address.lpSockaddr, ua->Address.iSockaddrLength);
@@ -263,6 +322,10 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
                            (includeLoopback || addr.saIn.sin_addr.s_addr != htonl(INADDR_LOOPBACK)))
                         {
                             result.push_back(addr);
+                            if(singleAddressPerInterface)
+                            {
+                                break; // One address is enough for each interface.
+                            }
                         }
                     }
                     else if(addr.saStorage.ss_family == AF_INET6 && protocol != EnableIPv4)
@@ -271,6 +334,10 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
                            (includeLoopback || !IN6_IS_ADDR_LOOPBACK(&addr.saIn6.sin6_addr)))
                         {
                             result.push_back(addr);
+                            if(singleAddressPerInterface)
+                            {
+                                break; // One address is enough for each interface.
+                            }
                         }
                     }
                 }
@@ -283,12 +350,11 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
     struct ifaddrs* ifap;
     if(::getifaddrs(&ifap) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     struct ifaddrs* curr = ifap;
+    set<string> interfaces;
     while(curr != 0)
     {
         if(curr->ifa_addr && (includeLoopback || !(curr->ifa_flags & IFF_LOOPBACK)))
@@ -299,7 +365,11 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
                 memcpy(&addr.saStorage, curr->ifa_addr, sizeof(sockaddr_in));
                 if(addr.saIn.sin_addr.s_addr != 0)
                 {
-                    result.push_back(addr);
+                    if(!singleAddressPerInterface || interfaces.find(curr->ifa_name) == interfaces.end())
+                    {
+                        result.push_back(addr);
+                        interfaces.insert(curr->ifa_name);
+                    }
                 }
             }
             else if(curr->ifa_addr->sa_family == AF_INET6 && protocol != EnableIPv4)
@@ -308,7 +378,11 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
                 memcpy(&addr.saStorage, curr->ifa_addr, sizeof(sockaddr_in6));
                 if(!IN6_IS_ADDR_UNSPECIFIED(&addr.saIn6.sin6_addr))
                 {
-                    result.push_back(addr);
+                    if(!singleAddressPerInterface || interfaces.find(curr->ifa_name) == interfaces.end())
+                    {
+                        result.push_back(addr);
+                        interfaces.insert(curr->ifa_name);
+                    }
                 }
             }
         }
@@ -352,9 +426,7 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
             {
                 free(ifc.ifc_buf);
                 closeSocketNoThrow(fd);
-                SocketException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
             else if(ifc.ifc_len == old_ifc_len)
             {
@@ -375,54 +447,41 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
 
         numaddrs = ifc.ifc_len / static_cast<int>(sizeof(struct ifreq));
         struct ifreq* ifr = ifc.ifc_req;
-        for(int i = 0; i < numaddrs; ++i)
+        set<string> interfaces;
+        for(int j = 0; j < numaddrs; ++j)
         {
-            if(!(ifr[i].ifr_flags & IFF_LOOPBACK)) // Don't include loopback interface addresses
+            if(!(ifr[j].ifr_flags & IFF_LOOPBACK)) // Don't include loopback interface addresses
             {
                 //
                 // On Solaris the above Loopback check does not always work so we double
                 // check the address below. Solaris also returns duplicate entries that need
                 // to be filtered out.
                 //
-                if(ifr[i].ifr_addr.sa_family == AF_INET && protocol != EnableIPv6)
+                if(ifr[j].ifr_addr.sa_family == AF_INET && protocol != EnableIPv6)
                 {
                     Address addr;
-                    memcpy(&addr.saStorage, &ifr[i].ifr_addr, sizeof(sockaddr_in));
+                    memcpy(&addr.saStorage, &ifr[j].ifr_addr, sizeof(sockaddr_in));
                     if(addr.saIn.sin_addr.s_addr != 0 &&
                        (includeLoopback || addr.saIn.sin_addr.s_addr != htonl(INADDR_LOOPBACK)))
                     {
-                        unsigned int j;
-                        for(j = 0; j < result.size(); ++j)
-                        {
-                            if(compareAddress(addr, result[j]) == 0)
-                            {
-                                break;
-                            }
-                        }
-                        if(j == result.size())
+                        if(!singleAddressPerInterface || interfaces.find(ifr[j].ifr_name) == interfaces.end())
                         {
                             result.push_back(addr);
+                            interfaces.insert(ifr[j].ifr_name);
                         }
                     }
                 }
-                else if(ifr[i].ifr_addr.sa_family == AF_INET6 && protocol != EnableIPv4)
+                else if(ifr[j].ifr_addr.sa_family == AF_INET6 && protocol != EnableIPv4)
                 {
                     Address addr;
-                    memcpy(&addr.saStorage, &ifr[i].ifr_addr, sizeof(sockaddr_in6));
+                    memcpy(&addr.saStorage, &ifr[j].ifr_addr, sizeof(sockaddr_in6));
                     if(!IN6_IS_ADDR_UNSPECIFIED(&addr.saIn6.sin6_addr) &&
                        (includeLoopback || !IN6_IS_ADDR_LOOPBACK(&addr.saIn6.sin6_addr)))
                     {
-                        unsigned int j;
-                        for(j = 0; j < result.size(); ++j)
-                        {
-                            if(compareAddress(addr, result[j]) == 0)
-                            {
-                                break;
-                            }
-                        }
-                        if(j == result.size())
+                        if(!singleAddressPerInterface || interfaces.find(ifr[j].ifr_name) == interfaces.end())
                         {
                             result.push_back(addr);
+                            interfaces.insert(ifr[j].ifr_name);
                         }
                     }
                 }
@@ -432,17 +491,31 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
     }
 #endif
 
+    //
+    // Remove potential duplicates from the result.
+    //
+    set<Address, AddressCompare> seen;
+    vector<Address> tmp;
+    tmp.swap(result);
+    for(vector<Address>::const_iterator p = tmp.begin(); p != tmp.end(); ++p)
+    {
+        if(seen.find(*p) == seen.end())
+        {
+            result.push_back(*p);
+            seen.insert(*p);
+        }
+    }
     return result;
 }
 
 bool
 isLinklocal(const Address& addr)
 {
-    if (addr.saStorage.ss_family == AF_INET6)
+    if(addr.saStorage.ss_family == AF_INET6)
     {
         return IN6_IS_ADDR_LINKLOCAL(&addr.saIn6.sin6_addr);
     }
-    else if (addr.saStorage.ss_family == AF_INET)
+    else if(addr.saStorage.ss_family == AF_INET)
     {
         // Check for 169.254.X.X in network order
         return (addr.saIn.sin_addr.s_addr & 0xFF) == 169 && ((addr.saIn.sin_addr.s_addr & 0xFF00)>>8) == 254;
@@ -453,58 +526,66 @@ isLinklocal(const Address& addr)
 bool
 isWildcard(const string& host, ProtocolSupport protocol, bool& ipv4)
 {
-    try
+    Address addr = getAddressForServer(host, 0, protocol, true, false);
+    if(addr.saStorage.ss_family == AF_INET)
     {
-        Address addr = getAddressForServer(host, 0, protocol, true);
-        if(addr.saStorage.ss_family == AF_INET)
+        if(addr.saIn.sin_addr.s_addr == INADDR_ANY)
         {
-            if(addr.saIn.sin_addr.s_addr == INADDR_ANY)
-            {
-                ipv4 = true;
-                return true;
-            }
-        }
-        else if(addr.saStorage.ss_family)
-        {
-            if(IN6_IS_ADDR_UNSPECIFIED(&addr.saIn6.sin6_addr))
-            {
-                ipv4 = false;
-                return true;
-            }
+            ipv4 = true;
+            return true;
         }
     }
-    catch(const DNSException&)
+    else if(addr.saStorage.ss_family == AF_INET6)
     {
+        if(IN6_IS_ADDR_UNSPECIFIED(&addr.saIn6.sin6_addr))
+        {
+            ipv4 = false;
+            return true;
+        }
     }
     return false;
 }
 
 int
-getInterfaceIndex(const string& name)
+getInterfaceIndex(const string& intf)
 {
-    if(name.empty())
+    if(intf.empty())
     {
         return 0;
     }
 
-    int index = 0;
+    string name;
+    bool isAddr;
+    in6_addr addr;
+    string::size_type pos = intf.find("%");
+    if(pos != string::npos)
+    {
+        //
+        // If it's a link-local address, use the zone indice.
+        //
+        isAddr = false;
+        name = intf.substr(pos + 1);
+    }
+    else
+    {
+        //
+        // Then check if it's an IPv6 address. If it's an address we'll
+        // look for the interface index by address.
+        //
+        isAddr = inet_pton(AF_INET6, intf.c_str(), &addr) > 0;
+        name = intf;
+    }
 
     //
-    // First check if index
+    // Check if index
     //
+    int index = -1;
     istringstream p(name);
     if((p >> index) && p.eof())
     {
         return index;
     }
 
-    //
-    // Then check if it's an IPv6 address. If it's an address we'll
-    // look for the interface index by address.
-    //
-    in6_addr addr;
-    bool isAddr = inet_pton(AF_INET6, name.c_str(), &addr) > 0;
-
 #ifdef _WIN32
     IP_ADAPTER_ADDRESSES addrs;
     ULONG buflen = 0;
@@ -545,7 +626,7 @@ getInterfaceIndex(const string& name)
                     // Don't need to pass a wide string converter as the wide string
                     // come from Windows API.
                     //
-                    if(IceUtil::wstringToString(paddrs->FriendlyName, IceUtil::getProcessStringConverter()) == name)
+                    if(wstringToString(paddrs->FriendlyName, getProcessStringConverter()) == name)
                     {
                         index = paddrs->Ipv6IfIndex;
                         break;
@@ -556,6 +637,10 @@ getInterfaceIndex(const string& name)
         }
         delete[] buf;
     }
+    if(index < 0) // interface not found
+    {
+        throw Ice::SocketException(__FILE__, __LINE__, WSAEINVAL);
+    }
 #elif !defined(__hpux)
 
     //
@@ -575,7 +660,7 @@ getInterfaceIndex(const string& name)
                     struct sockaddr_in6* ipv6Addr = reinterpret_cast<struct sockaddr_in6*>(curr->ifa_addr);
                     if(memcmp(&addr, &ipv6Addr->sin6_addr, sizeof(in6_addr)) == 0)
                     {
-                        index = if_nametoindex(curr->ifa_name);
+                        index = static_cast<int>(if_nametoindex(curr->ifa_name));
                         break;
                     }
                 }
@@ -640,7 +725,7 @@ getInterfaceIndex(const string& name)
                     struct sockaddr_in6* ipv6Addr = reinterpret_cast<struct sockaddr_in6*>(&ifr[i].ifr_addr);
                     if(memcmp(&addr, &ipv6Addr->sin6_addr, sizeof(in6_addr)) == 0)
                     {
-                        index = if_nametoindex(ifr[i].ifr_name);
+                        index = static_cast<int>(if_nametoindex(ifr[i].ifr_name));
                         break;
                     }
                 }
@@ -651,7 +736,12 @@ getInterfaceIndex(const string& name)
     }
     else // Look for an interface with the given name.
     {
-        index = if_nametoindex(name.c_str());
+        index = static_cast<int>(if_nametoindex(name.c_str()));
+    }
+    if(index <= 0)
+    {
+        // index == 0 if if_nametoindex returned 0, < 0 if name wasn't found
+        throw Ice::SocketException(__FILE__, __LINE__, index == 0 ? getSocketErrno() : ENXIO);
     }
 #endif
 
@@ -689,19 +779,20 @@ getInterfaceAddress(const string& name)
                 // Don't need to pass a wide string converter as the wide string come
                 // from Windows API.
                 //
-                if(IceUtil::wstringToString(paddrs->FriendlyName, IceUtil::getProcessStringConverter()) == name)
+                if(wstringToString(paddrs->FriendlyName, getProcessStringConverter()) == name)
                 {
                     struct sockaddr_in addrin;
                     memcpy(&addrin, paddrs->FirstUnicastAddress->Address.lpSockaddr,
                            paddrs->FirstUnicastAddress->Address.iSockaddrLength);
-                    addr =  addrin.sin_addr;
-                    break;
+                    delete[] buf;
+                    return addrin.sin_addr;
                 }
                 paddrs = paddrs->Next;
             }
         }
         delete[] buf;
     }
+    throw Ice::SocketException(__FILE__, __LINE__, WSAEINVAL);
 #else
     ifreq if_address;
     strcpy(if_address.ifr_name, name.c_str());
@@ -709,14 +800,12 @@ getInterfaceAddress(const string& name)
     SOCKET fd = createSocketImpl(false, AF_INET);
     int rc = ioctl(fd, SIOCGIFADDR, &if_address);
     closeSocketNoThrow(fd);
-
-    if(rc != SOCKET_ERROR)
+    if(rc == SOCKET_ERROR)
     {
-        addr = reinterpret_cast<struct sockaddr_in*>(&if_address.ifr_addr)->sin_addr;
+        throw Ice::SocketException(__FILE__, __LINE__, getSocketErrno());
     }
+    return reinterpret_cast<struct sockaddr_in*>(&if_address.ifr_addr)->sin_addr;
 #endif
-
-    return addr;
 }
 
 int
@@ -734,11 +823,57 @@ getAddressStorageSize(const Address& addr)
     return size;
 }
 
-#endif // #ifndef ICE_OS_WINRT
+vector<Address>
+getLoopbackAddresses(ProtocolSupport protocol, int port = 0)
+{
+    vector<Address> result;
 
+    Address addr;
+    memset(&addr.saStorage, 0, sizeof(sockaddr_storage));
+
+    //
+    // We don't use getaddrinfo when host is empty as it's not portable (some old Linux
+    // versions don't support it).
+    //
+    if(protocol != EnableIPv4)
+    {
+        addr.saIn6.sin6_family = AF_INET6;
+        addr.saIn6.sin6_port = htons(port);
+        addr.saIn6.sin6_addr = in6addr_loopback;
+        result.push_back(addr);
+    }
+    if(protocol != EnableIPv6)
+    {
+        addr.saIn.sin_family = AF_INET;
+        addr.saIn.sin_port = htons(port);
+        addr.saIn.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+        result.push_back(addr);
+    }
+    return result;
+}
+
+#endif // #ifndef ICE_OS_UWP
+
+}
+
+ReadyCallback::~ReadyCallback()
+{
+    // Out of line to avoid weak vtable
+}
+
+NativeInfo::~NativeInfo()
+{
+    // Out of line to avoid weak vtable
+}
+
+void
+NativeInfo::setReadyCallback(const ReadyCallbackPtr& callback)
+{
+    _readyCallback = callback;
 }
 
 #ifdef ICE_USE_IOCP
+
 IceInternal::AsyncInfo::AsyncInfo(SocketOperation s)
 {
     ZeroMemory(this, sizeof(AsyncInfo));
@@ -757,12 +892,115 @@ IceInternal::NativeInfo::completed(SocketOperation operation)
 {
     if(!PostQueuedCompletionStatus(_handle, 0, _key, getAsyncInfo(operation)))
     {
-        Ice::SocketException ex(__FILE__, __LINE__);
-        ex.error = GetLastError();
-        throw ex;
+        throw Ice::SocketException(__FILE__, __LINE__, GetLastError());
+    }
+}
+
+#elif defined(ICE_OS_UWP)
+
+void
+IceInternal::NativeInfo::queueAction(SocketOperation op, IAsyncAction^ action, bool connect)
+{
+    AsyncInfo* asyncInfo = getAsyncInfo(op);
+    if(checkIfErrorOrCompleted(op, action, action->Status, connect))
+    {
+        asyncInfo->count = 0;
+        asyncInfo->error = ERROR_SUCCESS;
+    }
+    else
+    {
+        action->Completed = ref new AsyncActionCompletedHandler(
+            [=] (IAsyncAction^ info, Windows::Foundation::AsyncStatus status)
+            {
+                //
+                // 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.
+                //
+                this->queueActionCompleted(op, asyncInfo, info, status);
+            });
+        asyncInfo->operation = action;
+    }
+}
+
+void
+IceInternal::NativeInfo::queueActionCompleted(SocketOperation op, AsyncInfo* asyncInfo, IAsyncAction^ info,
+                                              Windows::Foundation::AsyncStatus status)
+{
+    if(status != Windows::Foundation::AsyncStatus::Completed)
+    {
+        asyncInfo->error = info->ErrorCode.Value;
+    }
+    else
+    {
+        asyncInfo->error = ERROR_SUCCESS;
+    }
+    asyncInfo->count = 0;
+    completed(op);
+}
+
+void
+IceInternal::NativeInfo::queueOperation(SocketOperation op, IAsyncOperation<unsigned int>^ operation)
+{
+    AsyncInfo* info = getAsyncInfo(op);
+    Windows::Foundation::AsyncStatus status = operation->Status;
+    if(status == Windows::Foundation::AsyncStatus::Completed)
+    {
+        //
+        // NOTE: it's important to modify the count _before_ calling the completion handler
+        // since this might not always be called with the connection mutex but from a Windows
+        // thread pool thread if we chained multiple Async calls (GetGetOutputStreamAsync and
+        // StoreAsync for example, see the UDPTransceiver implementation). So we can't modify
+        // the AsyncInfo structure after calling the completed callback.
+        //
+        info->count = static_cast<int>(operation->GetResults());
+        info->error = ERROR_SUCCESS;
+        _completedHandler(op);
+        return;
+    }
+    else if(!checkIfErrorOrCompleted(op, operation, status))
+    {
+        if(!info->completedHandler)
+        {
+            info->completedHandler = ref new AsyncOperationCompletedHandler<unsigned int>(
+                [=] (IAsyncOperation<unsigned int>^ operation, Windows::Foundation::AsyncStatus status)
+                {
+                    //
+                    // 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.
+                    //
+                    this->queueOperationCompleted(op, info, operation, status);
+                });
+        }
+        operation->Completed = info->completedHandler;
+        info->operation = operation;
+    }
+}
+
+void
+IceInternal::NativeInfo::queueOperationCompleted(SocketOperation op, AsyncInfo* info,
+                                                 IAsyncOperation<unsigned int>^ operation,
+                                                 Windows::Foundation::AsyncStatus status)
+{
+    if(status != Windows::Foundation::AsyncStatus::Completed)
+    {
+        info->count = 0;
+        info->error = operation->ErrorCode.Value;
+    }
+    else
+    {
+        info->count = static_cast<int>(operation->GetResults());
+        info->error = ERROR_SUCCESS;
     }
+    completed(op);
+}
+
+void
+IceInternal::NativeInfo::setCompletedHandler(SocketOperationCompletedHandler^ handler)
+{
+    _completedHandler = handler;
 }
-#elif defined(ICE_OS_WINRT)
 
 void
 IceInternal::NativeInfo::completed(SocketOperation operation)
@@ -771,12 +1009,68 @@ IceInternal::NativeInfo::completed(SocketOperation operation)
     _completedHandler(operation);
 }
 
+bool
+IceInternal::NativeInfo::checkIfErrorOrCompleted(SocketOperation op, IAsyncInfo^ info, Windows::Foundation::AsyncStatus status, bool connect)
+{
+    //
+    // 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.
+    //
+    if(status == Windows::Foundation::AsyncStatus::Completed)
+    {
+        _completedHandler(op);
+        return true;
+    }
+    else if (status == Windows::Foundation::AsyncStatus::Started)
+    {
+        return false;
+    }
+    else
+    {
+        if(connect) // Connect
+        {
+            checkConnectErrorCode(__FILE__, __LINE__, info->ErrorCode.Value);
+        }
+        else
+        {
+            checkErrorCode(__FILE__, __LINE__, info->ErrorCode.Value);
+        }
+        return true; // Prevent compiler warning.
+    }
+}
+
+#else
+
+void
+IceInternal::NativeInfo::setNewFd(SOCKET fd)
+{
+    assert(_fd == INVALID_SOCKET); // This can only be called once, when the current socket isn't set yet.
+    _newFd = fd;
+}
+
+bool
+IceInternal::NativeInfo::newFd()
+{
+    if(_newFd == INVALID_SOCKET)
+    {
+        return false;
+    }
+    assert(_fd == INVALID_SOCKET);
+    swap(_fd, _newFd);
+    return true;
+}
+
 #endif
 
 bool
 IceInternal::noMoreFds(int error)
 {
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
     return error == (int)SocketErrorStatus::TooManyOpenFiles;
 #elif defined(_WIN32)
     return error == WSAEMFILE;
@@ -785,7 +1079,7 @@ IceInternal::noMoreFds(int error)
 #endif
 }
 
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
 string
 IceInternal::errorToStringDNS(int)
 {
@@ -803,7 +1097,7 @@ IceInternal::errorToStringDNS(int error)
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 vector<Address>
 IceInternal::getAddresses(const string& host, int port, ProtocolSupport, Ice::EndpointSelectionType, bool, bool)
 {
@@ -822,37 +1116,31 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport, Ice::En
             // to Windows API.
             //
             addr.host = ref new HostName(ref new String(
-                                             IceUtil::stringToWstring(host,
-                                                                      IceUtil::getProcessStringConverter()).c_str()));
+                                             stringToWstring(host,
+                                                             getProcessStringConverter()).c_str()));
         }
         stringstream os;
         os << port;
         //
         // Don't need to use any string converter here as the port number use just
-        // ACII characters.
+        // ASCII characters.
         //
-        addr.port = ref new String(IceUtil::stringToWstring(os.str()).c_str());
+        addr.port = ref new String(stringToWstring(os.str()).c_str());
         result.push_back(addr);
         return result;
     }
     catch(Platform::Exception^ pex)
     {
-        DNSException ex(__FILE__, __LINE__);
-        ex.error = (int)SocketError::GetStatus(pex->HResult);
-        ex.host = host;
-        throw ex;
+        throw DNSException(__FILE__, __LINE__, (int)SocketError::GetStatus(pex->HResult), host);
     }
 
 }
 #else
 vector<Address>
 IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol, Ice::EndpointSelectionType selType,
-                          bool preferIPv6, bool blocking)
+                          bool preferIPv6, bool canBlock)
 {
     vector<Address> result;
-    Address addr;
-
-    memset(&addr.saStorage, 0, sizeof(sockaddr_storage));
 
     //
     // We don't use getaddrinfo when host is empty as it's not portable (some old Linux
@@ -860,28 +1148,18 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
     //
     if(host.empty())
     {
-        if(protocol != EnableIPv4)
-        {
-            addr.saIn6.sin6_family = AF_INET6;
-            addr.saIn6.sin6_port = htons(port);
-            addr.saIn6.sin6_addr = in6addr_loopback;
-            result.push_back(addr);
-        }
-        if(protocol != EnableIPv6)
-        {
-            addr.saIn.sin_family = AF_INET;
-            addr.saIn.sin_port = htons(port);
-            addr.saIn.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-            result.push_back(addr);
-        }
+        result = getLoopbackAddresses(protocol, port);
         sortAddresses(result, protocol, selType, preferIPv6);
         return result;
     }
 
+    Address addr;
+    memset(&addr.saStorage, 0, sizeof(sockaddr_storage));
+
     struct addrinfo* info = 0;
     int retry = 5;
 
-    struct addrinfo hints = { 0 };
+    struct addrinfo hints = {};
     if(protocol == EnableIPv4)
     {
         hints.ai_family = PF_INET;
@@ -895,7 +1173,7 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
         hints.ai_family = PF_UNSPEC;
     }
 
-    if(!blocking)
+    if(!canBlock)
     {
         hints.ai_flags = AI_NUMERICHOST;
     }
@@ -912,22 +1190,19 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
     // 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
-    if(!blocking && (rs == EAI_NONAME || rs == EAI_NODATA))
+    if(!canBlock && (rs == EAI_NONAME || rs == EAI_NODATA))
 #  else
-    if(!blocking && rs == EAI_NONAME)
+    if(!canBlock && rs == EAI_NONAME)
 #  endif
     {
-        return result; // Empty result indicates that a blocking lookup is necessary.
+        return result; // Empty result indicates that a canBlock lookup is necessary.
     }
     else if(rs != 0)
     {
-        DNSException ex(__FILE__, __LINE__);
-        ex.error = rs;
-        ex.host = host;
-        throw ex;
+        throw DNSException(__FILE__, __LINE__, rs, host);
     }
 
-    for(struct addrinfo* p = info; p != NULL; p = p->ai_next)
+    for(struct addrinfo* p = info; p != ICE_NULLPTR; p = p->ai_next)
     {
         memcpy(&addr.saStorage, p->ai_addr, p->ai_addrlen);
         if(p->ai_family == PF_INET)
@@ -958,20 +1233,18 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
 
     if(result.empty())
     {
-        DNSException ex(__FILE__, __LINE__);
-        ex.host = host;
-        throw ex;
+        throw DNSException(__FILE__, __LINE__, 0, host);
     }
     sortAddresses(result, protocol, selType, preferIPv6);
     return result;
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 ProtocolSupport
 IceInternal::getProtocolSupport(const Address&)
 {
-    // For WinRT, there's no distinction between IPv4 and IPv6 adresses.
+    // For UWP, there's no distinction between IPv4 and IPv6 adresses.
     return EnableBoth;
 }
 #else
@@ -983,7 +1256,7 @@ IceInternal::getProtocolSupport(const Address& addr)
 #endif
 
 Address
-IceInternal::getAddressForServer(const string& host, int port, ProtocolSupport protocol, bool preferIPv6)
+IceInternal::getAddressForServer(const string& host, int port, ProtocolSupport protocol, bool preferIPv6, bool canBlock)
 {
     //
     // We don't use getaddrinfo when host is empty as it's not portable (some old Linux
@@ -992,14 +1265,14 @@ IceInternal::getAddressForServer(const string& host, int port, ProtocolSupport p
     if(host.empty())
     {
         Address addr;
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
         ostringstream os;
         os << port;
         //
         // Don't need to use any string converter here as the port number use just
         // ASCII characters.
         //
-        addr.port = ref new String(IceUtil::stringToWstring(os.str()).c_str());
+        addr.port = ref new String(stringToWstring(os.str()).c_str());
         addr.host = nullptr; // Equivalent of inaddr_any, see doBind implementation.
 #else
         memset(&addr.saStorage, 0, sizeof(sockaddr_storage));
@@ -1018,13 +1291,15 @@ IceInternal::getAddressForServer(const string& host, int port, ProtocolSupport p
 #endif
         return addr;
     }
-    return getAddresses(host, port, protocol, Ice::Ordered, preferIPv6, true)[0];
+    vector<Address> addrs = getAddresses(host, port, protocol, Ice::ICE_ENUM(EndpointSelectionType, Ordered),
+                                         preferIPv6, canBlock);
+    return addrs.empty() ? Address() : addrs[0];
 }
 
 int
 IceInternal::compareAddress(const Address& addr1, const Address& addr2)
 {
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
     int o = String::CompareOrdinal(addr1.port, addr2.port);
     if(o != 0)
     {
@@ -1099,7 +1374,7 @@ IceInternal::compareAddress(const Address& addr1, const Address& addr2)
 #endif
 }
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 bool
 IceInternal::isIPv6Supported()
 {
@@ -1122,7 +1397,7 @@ IceInternal::isIPv6Supported()
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 SOCKET
 IceInternal::createSocket(bool udp, const Address&)
 {
@@ -1136,7 +1411,7 @@ IceInternal::createSocket(bool udp, const Address& addr)
 }
 #endif
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 SOCKET
 IceInternal::createServerSocket(bool udp, const Address& addr, ProtocolSupport protocol)
 {
@@ -1153,9 +1428,7 @@ IceInternal::createServerSocket(bool udp, const Address& addr, ProtocolSupport p
             }
 #endif
             closeSocketNoThrow(fd);
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
     return fd;
@@ -1171,7 +1444,7 @@ IceInternal::createServerSocket(bool udp, const Address& addr, ProtocolSupport)
 void
 IceInternal::closeSocketNoThrow(SOCKET fd)
 {
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
     //
     // NOTE: StreamSocket::Close or DatagramSocket::Close aren't
     // exposed in C++, you have to delete the socket to close
@@ -1194,7 +1467,7 @@ IceInternal::closeSocketNoThrow(SOCKET fd)
 void
 IceInternal::closeSocket(SOCKET fd)
 {
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
     //
     // NOTE: StreamSocket::Close or DatagramSocket::Close aren't
     // exposed in C++, you have to delete the socket to close
@@ -1207,9 +1480,7 @@ IceInternal::closeSocket(SOCKET fd)
     int error = WSAGetLastError();
     if(closesocket(fd) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
     WSASetLastError(error);
 #else
@@ -1226,9 +1497,7 @@ IceInternal::closeSocket(SOCKET fd)
     if(close(fd) == SOCKET_ERROR)
 #  endif
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
     errno = error;
 #endif
@@ -1245,13 +1514,11 @@ IceInternal::addrToString(const Address& addr)
 void
 IceInternal::fdToLocalAddress(SOCKET fd, Address& addr)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     socklen_t len = static_cast<socklen_t>(sizeof(sockaddr_storage));
     if(getsockname(fd, &addr.sa, &len) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 #else
     StreamSocket^ stream = dynamic_cast<StreamSocket^>(fd);
@@ -1272,7 +1539,7 @@ IceInternal::fdToLocalAddress(SOCKET fd, Address& addr)
 bool
 IceInternal::fdToRemoteAddress(SOCKET fd, Address& addr)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     socklen_t len = static_cast<socklen_t>(sizeof(sockaddr_storage));
     if(getpeername(fd, &addr.sa, &len) == SOCKET_ERROR)
     {
@@ -1282,9 +1549,7 @@ IceInternal::fdToRemoteAddress(SOCKET fd, Address& addr)
         }
         else
         {
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
 
@@ -1427,14 +1692,14 @@ IceInternal::addressesToString(const Address& localAddr, const Address& remoteAd
 bool
 IceInternal::isAddressValid(const Address& addr)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     return addr.saStorage.ss_family != AF_UNSPEC;
 #else
     return addr.host != nullptr || addr.port != nullptr;
 #endif
 }
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 vector<string>
 IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport protocolSupport, bool includeLoopback)
 {
@@ -1446,11 +1711,10 @@ IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport proto
             HostName^ h = it->Current;
             if(h->IPInformation != nullptr && h->IPInformation->NetworkAdapter != nullptr)
             {
-                hosts.push_back(IceUtil::wstringToString(h->CanonicalName->Data(),
-                                                         IceUtil::getProcessStringConverter()));
+                hosts.push_back(wstringToString(h->CanonicalName->Data(), getProcessStringConverter()));
             }
         }
-        if(includeLoopback)
+        if(hosts.empty() || includeLoopback)
         {
             if(protocolSupport != EnableIPv6)
             {
@@ -1464,6 +1728,32 @@ IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport proto
     }
     return hosts;
 }
+
+vector<string>
+IceInternal::getInterfacesForMulticast(const string& intf, ProtocolSupport)
+{
+    vector<string> interfaces;
+    if(intf.empty() || intf == "0.0.0.0" || intf == "::" || intf == "0:0:0:0:0:0:0:0")
+    {
+        for(IIterator<HostName^>^ it = NetworkInformation::GetHostNames()->First(); it->HasCurrent; it->MoveNext())
+        {
+            HostName^ h = it->Current;
+            if(h->IPInformation != nullptr && h->IPInformation->NetworkAdapter != nullptr)
+            {
+                string s = wstringToString(h->CanonicalName->Data(), getProcessStringConverter());
+                if(find(interfaces.begin(), interfaces.end(), s) == interfaces.end())
+                {
+                    interfaces.push_back(s);
+                }
+            }
+        }
+    }
+    if(interfaces.empty())
+    {
+        interfaces.push_back(intf);
+    }
+    return interfaces;
+}
 #else
 vector<string>
 IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport protocolSupport, bool includeLoopback)
@@ -1472,7 +1762,7 @@ IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport proto
     bool ipv4Wildcard = false;
     if(isWildcard(host, protocolSupport, ipv4Wildcard))
     {
-        vector<Address> addrs = getLocalAddresses(ipv4Wildcard ? EnableIPv4 : protocolSupport, includeLoopback);
+        vector<Address> addrs = getLocalAddresses(ipv4Wildcard ? EnableIPv4 : protocolSupport, includeLoopback, false);
         for(vector<Address>::const_iterator p = addrs.begin(); p != addrs.end(); ++p)
         {
             //
@@ -1485,15 +1775,44 @@ IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport proto
                 hosts.push_back(inetAddrToString(*p));
             }
         }
+        if(hosts.empty())
+        {
+            // Return loopback if no other local addresses are available.
+            addrs = getLoopbackAddresses(protocolSupport);
+            for(vector<Address>::const_iterator p = addrs.begin(); p != addrs.end(); ++p)
+            {
+                hosts.push_back(inetAddrToString(*p));
+            }
+        }
     }
     return hosts; // An empty host list indicates to just use the given host.
 }
+
+vector<string>
+IceInternal::getInterfacesForMulticast(const string& intf, ProtocolSupport protocolSupport)
+{
+    vector<string> interfaces;
+    bool ipv4Wildcard = false;
+    if(isWildcard(intf, protocolSupport, ipv4Wildcard))
+    {
+        vector<Address> addrs = getLocalAddresses(ipv4Wildcard ? EnableIPv4 : protocolSupport, true, true);
+        for(vector<Address>::const_iterator p = addrs.begin(); p != addrs.end(); ++p)
+        {
+            interfaces.push_back(inetAddrToString(*p)); // We keep link local addresses for multicast
+        }
+    }
+    if(interfaces.empty())
+    {
+        interfaces.push_back(intf);
+    }
+    return interfaces;
+}
 #endif
 
 string
 IceInternal::inetAddrToString(const Address& ss)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     int size = getAddressStorageSize(ss);
     if(size == 0)
     {
@@ -1502,7 +1821,8 @@ IceInternal::inetAddrToString(const Address& ss)
 
     char namebuf[1024];
     namebuf[0] = '\0';
-    getnameinfo(&ss.sa, size, namebuf, static_cast<socklen_t>(sizeof(namebuf)), 0, 0, NI_NUMERICHOST);
+    getnameinfo(&ss.sa, static_cast<socklen_t>(size), namebuf, static_cast<socklen_t>(sizeof(namebuf)), 0, 0,
+                NI_NUMERICHOST);
     return string(namebuf);
 #else
     if(ss.host == nullptr)
@@ -1515,7 +1835,7 @@ IceInternal::inetAddrToString(const Address& ss)
         // Don't need to pass a wide string converter as the wide string come
         // from Windows API.
         //
-        return IceUtil::wstringToString(ss.host->RawName->Data(), IceUtil::getProcessStringConverter());
+        return wstringToString(ss.host->RawName->Data(), getProcessStringConverter());
     }
 #endif
 }
@@ -1523,7 +1843,7 @@ IceInternal::inetAddrToString(const Address& ss)
 int
 IceInternal::getPort(const Address& addr)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     if(addr.saStorage.ss_family == AF_INET)
     {
         return ntohs(addr.saIn.sin_port);
@@ -1537,11 +1857,11 @@ IceInternal::getPort(const Address& addr)
         return -1;
     }
 #else
-    IceUtil::Int64 port;
+    IceUtil::Int64 port = 0;
     //
     // Don't need to use any string converter here as the port number use just ASCII characters.
     //
-    if(addr.port == nullptr || !IceUtilInternal::stringToInt64(IceUtil::wstringToString(addr.port->Data()), port))
+    if(addr.port == nullptr || !IceUtilInternal::stringToInt64(wstringToString(addr.port->Data()), port))
     {
         return -1;
     }
@@ -1552,7 +1872,7 @@ IceInternal::getPort(const Address& addr)
 void
 IceInternal::setPort(Address& addr, int port)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     if(addr.saStorage.ss_family == AF_INET)
     {
         addr.saIn.sin_port = htons(port);
@@ -1567,16 +1887,16 @@ IceInternal::setPort(Address& addr, int port)
     os << port;
     //
     // Don't need to use any string converter here as the port number use just
-    // ACII characters.
+    // ASCII characters.
     //
-    addr.port = ref new String(IceUtil::stringToWstring(os.str()).c_str());
+    addr.port = ref new String(stringToWstring(os.str()).c_str());
 #endif
 }
 
 bool
 IceInternal::isMulticast(const Address& addr)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     if(addr.saStorage.ss_family == AF_INET)
     {
         return IN_MULTICAST(ntohl(addr.saIn.sin_addr.s_addr));
@@ -1594,7 +1914,7 @@ IceInternal::isMulticast(const Address& addr)
     // Don't need to use string converters here, this is just to do a local
     // comparison to find if the address is multicast.
     //
-    string host = IceUtil::wstringToString(addr.host->RawName->Data());
+    string host = wstringToString(addr.host->RawName->Data());
     string ip = IceUtilInternal::toUpper(host);
     vector<string> tokens;
     IceUtilInternal::splitString(ip, ".", tokens);
@@ -1689,7 +2009,7 @@ IceInternal::setTcpBufSize(SOCKET fd, int rcvSize, int sndSize, const ProtocolIn
     }
 }
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setBlock(SOCKET fd, bool)
 {
@@ -1705,9 +2025,7 @@ IceInternal::setBlock(SOCKET fd, bool block)
         if(ioctlsocket(fd, FIONBIO, &arg) == SOCKET_ERROR)
         {
             closeSocketNoThrow(fd);
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = WSAGetLastError();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, WSAGetLastError());
         }
     }
     else
@@ -1716,9 +2034,7 @@ IceInternal::setBlock(SOCKET fd, bool block)
         if(ioctlsocket(fd, FIONBIO, &arg) == SOCKET_ERROR)
         {
             closeSocketNoThrow(fd);
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = WSAGetLastError();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, WSAGetLastError());
         }
     }
 #else
@@ -1729,9 +2045,7 @@ IceInternal::setBlock(SOCKET fd, bool block)
         if(fcntl(fd, F_SETFL, flags) == SOCKET_ERROR)
         {
             closeSocketNoThrow(fd);
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = errno;
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, errno);
         }
     }
     else
@@ -1741,9 +2055,7 @@ IceInternal::setBlock(SOCKET fd, bool block)
         if(fcntl(fd, F_SETFL, flags) == SOCKET_ERROR)
         {
             closeSocketNoThrow(fd);
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = errno;
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, errno);
         }
     }
 #endif
@@ -1753,13 +2065,11 @@ IceInternal::setBlock(SOCKET fd, bool block)
 void
 IceInternal::setSendBufferSize(SOCKET fd, int sz)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     if(setsockopt(fd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<char*>(&sz), int(sizeof(int))) == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 #else
     StreamSocket^ stream = dynamic_cast<StreamSocket^>(fd);
@@ -1773,16 +2083,14 @@ IceInternal::setSendBufferSize(SOCKET fd, int sz)
 int
 IceInternal::getSendBufferSize(SOCKET fd)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     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))
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
     return sz;
 #else
@@ -1795,7 +2103,7 @@ IceInternal::getSendBufferSize(SOCKET fd)
 #endif
 }
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setRecvBufferSize(SOCKET, int)
 {
@@ -1807,9 +2115,7 @@ IceInternal::setRecvBufferSize(SOCKET fd, int sz)
     if(setsockopt(fd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<char*>(&sz), int(sizeof(int))) == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 #endif
@@ -1817,16 +2123,14 @@ IceInternal::setRecvBufferSize(SOCKET fd, int sz)
 int
 IceInternal::getRecvBufferSize(SOCKET fd)
 {
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     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);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
     return sz;
 #else
@@ -1834,31 +2138,39 @@ IceInternal::getRecvBufferSize(SOCKET fd)
 #endif
 }
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 void
 IceInternal::setMcastGroup(SOCKET fd, const Address& group, const string& intf)
 {
-    int rc;
-    if(group.saStorage.ss_family == AF_INET)
-    {
-        struct ip_mreq mreq;
-        mreq.imr_multiaddr = group.saIn.sin_addr;
-        mreq.imr_interface = getInterfaceAddress(intf);
-        rc = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, reinterpret_cast<char*>(&mreq), int(sizeof(mreq)));
-    }
-    else
+    vector<string> interfaces = getInterfacesForMulticast(intf, getProtocolSupport(group));
+    set<int> indexes;
+    for(vector<string>::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
     {
-        struct ipv6_mreq mreq;
-        mreq.ipv6mr_multiaddr = group.saIn6.sin6_addr;
-        mreq.ipv6mr_interface = getInterfaceIndex(intf);
-        rc = setsockopt(fd, IPPROTO_IPV6, IPV6_JOIN_GROUP, reinterpret_cast<char*>(&mreq), int(sizeof(mreq)));
-    }
-    if(rc == SOCKET_ERROR)
-    {
-        closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        int rc = 0;
+        if(group.saStorage.ss_family == AF_INET)
+        {
+            struct ip_mreq mreq;
+            mreq.imr_multiaddr = group.saIn.sin_addr;
+            mreq.imr_interface = getInterfaceAddress(*p);
+            rc = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, reinterpret_cast<char*>(&mreq), int(sizeof(mreq)));
+        }
+        else
+        {
+            int index = getInterfaceIndex(*p);
+            if(indexes.find(index) == indexes.end()) // Don't join twice the same interface (if it has multiple IPs)
+            {
+                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)
+        {
+            closeSocketNoThrow(fd);
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
+        }
     }
 }
 #else
@@ -1868,9 +2180,34 @@ IceInternal::setMcastGroup(SOCKET fd, const Address& group, const string&)
     try
     {
         //
-        // NOTE: WinRT doesn't allow specyfing the interface.
+        // NOTE: UWP mcast interface is set earlier in doBind.
         //
         safe_cast<DatagramSocket^>(fd)->JoinMulticastGroup(group.host);
+
+        //
+        // BUGFIX DatagramSocket will not recive any messages from a multicast group if the
+        // messages originate in the same host until the socket is used to send at least one
+        // message. We send a valiate connection message that the peers will ignore to workaround
+        // the issue.
+        //
+        auto out = IceInternal::runSync(safe_cast<DatagramSocket^>(fd)->GetOutputStreamAsync(group.host, group.port));
+        auto writer = ref new DataWriter(out);
+
+        OutputStream os;
+        os.write(magic[0]);
+        os.write(magic[1]);
+        os.write(magic[2]);
+        os.write(magic[3]);
+        os.write(currentProtocol);
+        os.write(currentProtocolEncoding);
+        os.write(validateConnectionMsg);
+        os.write(static_cast<Byte>(0)); // Compression status (always zero for validate connection).
+        os.write(headerSize); // Message size.
+        os.i = os.b.begin();
+
+        writer->WriteBytes(ref new Array<unsigned char>(&*os.i, static_cast<unsigned int>(headerSize)));
+
+        IceInternal::runSync(writer->StoreAsync());
     }
     catch(Platform::Exception^ pex)
     {
@@ -1879,7 +2216,7 @@ IceInternal::setMcastGroup(SOCKET fd, const Address& group, const string&)
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setMcastInterface(SOCKET, const string&, const Address&)
 {
@@ -1902,14 +2239,12 @@ IceInternal::setMcastInterface(SOCKET fd, const string& intf, const Address& add
     if(rc == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setMcastTtl(SOCKET, int, const Address&)
 {
@@ -1930,14 +2265,12 @@ IceInternal::setMcastTtl(SOCKET fd, int ttl, const Address& addr)
     if(rc == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setReuseAddress(SOCKET, bool)
 {
@@ -1950,48 +2283,56 @@ IceInternal::setReuseAddress(SOCKET fd, bool reuse)
     if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&flag), int(sizeof(int))) == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 #endif
 
+#ifdef ICE_OS_UWP
+namespace
+{
 
-#ifdef ICE_OS_WINRT
 void
 checkResultAndWait(IAsyncAction^ action)
 {
-    if(action->Status == Windows::Foundation::AsyncStatus::Started)
+    auto status = action->Status;
+    switch(status)
     {
-        IceUtilInternal::CountDownLatch count(1);
-        HRESULT result = 0;
-        action->Completed = ref new AsyncActionCompletedHandler(
-            [&count, &result] (IAsyncAction^ action, Windows::Foundation::AsyncStatus status)
-                {
-                    if(status != Windows::Foundation::AsyncStatus::Completed)
+        case Windows::Foundation::AsyncStatus::Started:
+        {
+            promise<HRESULT> p;
+            action->Completed = ref new AsyncActionCompletedHandler(
+                [&p] (IAsyncAction^ action, Windows::Foundation::AsyncStatus status)
                     {
-                        result = action->ErrorCode.Value;
-                    }
-                    count.countDown();
-                });
-        count.await();
-        if(result)
+                        p.set_value(status != Windows::Foundation::AsyncStatus::Completed ? action->ErrorCode.Value : 0);
+                    });
+
+            HRESULT result = p.get_future().get();
+            if(result)
+            {
+                checkErrorCode(__FILE__, __LINE__, result);
+            }
+            break;
+        }
+        case Windows::Foundation::AsyncStatus::Error:
         {
-            checkErrorCode(__FILE__, __LINE__, result);
+            checkErrorCode(__FILE__, __LINE__, action->ErrorCode.Value);
+            break;
+        }
+        default:
+        {
+            break;
         }
     }
-    else if(action->Status == Windows::Foundation::AsyncStatus::Error)
-    {
-        checkErrorCode(__FILE__, __LINE__, action->ErrorCode.Value);
-    }
+}
+
 }
 #endif
 
+#ifdef ICE_OS_UWP
 Address
-IceInternal::doBind(SOCKET fd, const Address& addr)
+IceInternal::doBind(SOCKET fd, const Address& addr, const string& intf)
 {
-#ifdef ICE_OS_WINRT
     Address local;
     try
     {
@@ -2015,7 +2356,32 @@ IceInternal::doBind(SOCKET fd, const Address& addr)
         {
             if(addr.host == nullptr) // inaddr_any
             {
-                checkResultAndWait(datagram->BindServiceNameAsync(addr.port));
+                NetworkAdapter^ adapter;
+                if(!intf.empty())
+                {
+                    auto s = ref new String(Ice::stringToWstring(intf).c_str());
+                    auto profiles = NetworkInformation::GetConnectionProfiles();
+                    for(auto i = profiles->First(); adapter == nullptr && i->HasCurrent; i->MoveNext())
+                    {
+                        auto names = i->Current->GetNetworkNames();
+                        for(auto j = names->First(); adapter == nullptr && j->HasCurrent; j->MoveNext())
+                        {
+                            if(j->Current->Equals(s))
+                            {
+                                adapter = i->Current->NetworkAdapter;
+                            }
+                        }
+                    }
+                }
+
+                if(adapter)
+                {
+                    checkResultAndWait(datagram->BindServiceNameAsync(addr.port, adapter));
+                }
+                else
+                {
+                    checkResultAndWait(datagram->BindServiceNameAsync(addr.port));
+                }
             }
             else
             {
@@ -2031,16 +2397,18 @@ IceInternal::doBind(SOCKET fd, const Address& addr)
         throw;
     }
     return local;
+}
 #else
+Address
+IceInternal::doBind(SOCKET fd, const Address& addr, const string&)
+{
     int size = getAddressStorageSize(addr);
     assert(size != 0);
 
-    if(::bind(fd, &addr.sa, size) == SOCKET_ERROR)
+    if(::bind(fd, &addr.sa, static_cast<socklen_t>(size)) == SOCKET_ERROR)
     {
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     Address local;
@@ -2052,15 +2420,16 @@ IceInternal::doBind(SOCKET fd, const Address& addr)
     assert(ret != SOCKET_ERROR);
 #  endif
     return local;
-#endif
 }
+#endif
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 
 Address
 IceInternal::getNumericAddress(const std::string& address)
 {
-    vector<Address> addrs = getAddresses(address, 0, EnableBoth, Ice::Ordered, false, false);
+    vector<Address> addrs = getAddresses(address, 0, EnableBoth, Ice::ICE_ENUM(EndpointSelectionType, Ordered), false,
+                                         false);
     if(addrs.empty())
     {
         return Address();
@@ -2242,9 +2611,7 @@ repeatListen:
         }
 
         closeSocketNoThrow(fd);
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 
@@ -2260,7 +2627,7 @@ repeatConnect:
     int size = getAddressStorageSize(addr);
     assert(size != 0);
 
-    if(::connect(fd, &addr.sa, size) == SOCKET_ERROR)
+    if(::connect(fd, &addr.sa, static_cast<socklen_t>(size)) == SOCKET_ERROR)
     {
         if(interrupted())
         {
@@ -2275,21 +2642,15 @@ repeatConnect:
         closeSocketNoThrow(fd);
         if(connectionRefused())
         {
-            ConnectionRefusedException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectionRefusedException(__FILE__, __LINE__, getSocketErrno());
         }
         else if(connectFailed())
         {
-            ConnectFailedException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectFailedException(__FILE__, __LINE__, getSocketErrno());
         }
         else
         {
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
 
@@ -2305,9 +2666,7 @@ repeatConnect:
         fdToLocalAddress(fd, localAddr);
         if(compareAddress(addr, localAddr) == 0)
         {
-            ConnectionRefusedException ex(__FILE__, __LINE__);
-            ex.error = 0; // No appropriate errno
-            throw ex;
+            throw ConnectionRefusedException(__FILE__, __LINE__, 0); // No appropriate errno
         }
     }
     catch(const LocalException&)
@@ -2340,9 +2699,7 @@ IceInternal::doFinishConnect(SOCKET fd)
     socklen_t len = static_cast<socklen_t>(sizeof(int));
     if(getsockopt(fd, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&val), &len) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     if(val > 0)
@@ -2354,21 +2711,15 @@ IceInternal::doFinishConnect(SOCKET fd)
 #endif
         if(connectionRefused())
         {
-            ConnectionRefusedException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectionRefusedException(__FILE__, __LINE__, getSocketErrno());
         }
         else if(connectFailed())
         {
-            ConnectFailedException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectFailedException(__FILE__, __LINE__, getSocketErrno());
         }
         else
         {
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
 
@@ -2383,9 +2734,7 @@ IceInternal::doFinishConnect(SOCKET fd)
     Address remoteAddr;
     if(fdToRemoteAddress(fd, remoteAddr) && compareAddress(remoteAddr, localAddr) == 0)
     {
-        ConnectionRefusedException ex(__FILE__, __LINE__);
-        ex.error = 0; // No appropriate errno
-        throw ex;
+        throw ConnectionRefusedException(__FILE__, __LINE__, 0); // No appropriate errno
     }
 #endif
 }
@@ -2407,9 +2756,7 @@ repeatAccept:
             goto repeatAccept;
         }
 
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     setTcpNoDelay(ret);
@@ -2417,7 +2764,6 @@ repeatAccept:
     return ret;
 }
 
-
 void
 IceInternal::createPipe(SOCKET fds[2])
 {
@@ -2491,9 +2837,7 @@ IceInternal::createPipe(SOCKET fds[2])
 
     if(::pipe(fds) != 0)
     {
-        SyscallException ex(__FILE__, __LINE__);
-        ex.error = getSystemErrno();
-        throw ex;
+        throw SyscallException(__FILE__, __LINE__, getSocketErrno());
     }
 
     try
@@ -2521,23 +2865,19 @@ IceInternal::createPipe(SOCKET fds[2])
 #endif
 }
 
-#else // ICE_OS_WINRT
+#else // ICE_OS_UWP
 
 void
-IceInternal::checkConnectErrorCode(const char* file, int line, HRESULT herr, HostName^ host)
+IceInternal::checkConnectErrorCode(const char* file, int line, HRESULT herr)
 {
     if(herr == E_ACCESSDENIED)
     {
-        SocketException ex(file, line);
-        ex.error = static_cast<int>(herr);
-        throw ex;
+        throw SocketException(file, line, static_cast<int>(herr));
     }
     SocketErrorStatus error = SocketError::GetStatus(herr);
     if(error == SocketErrorStatus::ConnectionRefused)
     {
-        ConnectionRefusedException ex(file, line);
-        ex.error = static_cast<int>(error);
-        throw ex;
+        throw ConnectionRefusedException(file, line, static_cast<int>(error));
     }
     else if(error == SocketErrorStatus::NetworkDroppedConnectionOnReset ||
             error == SocketErrorStatus::ConnectionTimedOut ||
@@ -2546,26 +2886,15 @@ IceInternal::checkConnectErrorCode(const char* file, int line, HRESULT herr, Hos
             error == SocketErrorStatus::ConnectionResetByPeer ||
             error == SocketErrorStatus::SoftwareCausedConnectionAbort)
     {
-        ConnectFailedException ex(file, line);
-        ex.error = static_cast<int>(error);
-        throw ex;
+        throw ConnectFailedException(file, line, static_cast<int>(error));
     }
     else if(error == SocketErrorStatus::HostNotFound)
     {
-        DNSException ex(file, line);
-        ex.error = static_cast<int>(error);
-        //
-        // Don't need to pass a wide string converter as the wide string come from
-        // Windows API.
-        //
-        ex.host = IceUtil::wstringToString(host->RawName->Data(), IceUtil::getProcessStringConverter());
-        throw ex;
+        throw DNSException(file, line, static_cast<int>(error), "");
     }
     else
     {
-        SocketException ex(file, line);
-        ex.error = static_cast<int>(error);
-        throw ex;
+        throw SocketException(file, line, static_cast<int>(error));
     }
 }
 
@@ -2574,33 +2903,53 @@ IceInternal::checkErrorCode(const char* file, int line, HRESULT herr)
 {
     if(herr == E_ACCESSDENIED)
     {
-        SocketException ex(file, line);
-        ex.error = static_cast<int>(herr);
-        throw ex;
+        throw SocketException(file, line, static_cast<int>(herr));
     }
     SocketErrorStatus error = SocketError::GetStatus(herr);
     if(error == SocketErrorStatus::NetworkDroppedConnectionOnReset ||
        error == SocketErrorStatus::SoftwareCausedConnectionAbort ||
        error == SocketErrorStatus::ConnectionResetByPeer)
     {
-        ConnectionLostException ex(file, line);
-        ex.error = static_cast<int>(error);
-        throw ex;
+        throw ConnectionLostException(file, line, static_cast<int>(error));
     }
     else if(error == SocketErrorStatus::HostNotFound)
     {
-        DNSException ex(file, line);
-        ex.error = static_cast<int>(error);
-        throw ex;
+        throw DNSException(file, line, static_cast<int>(error), "");
     }
     else
     {
-        SocketException ex(file, line);
-        ex.error = static_cast<int>(error);
-        throw ex;
+        throw SocketException(file, line, static_cast<int>(error));
     }
 }
 
+//
+// UWP impose some restriction on operations that block when run from
+// STA thread and throws concurrency::invalid_operation. We cannot
+// directly call task::get or task::way, this helper method is used to
+// workaround this limitation.
+//
+void
+IceInternal::runSync(Windows::Foundation::IAsyncAction^ action)
+{
+    std::promise<void> p;
+
+    concurrency::create_task(action).then(
+        [&p](concurrency::task<void> t)
+        {
+            try
+            {
+                t.get();
+                p.set_value();
+            }
+            catch(...)
+            {
+                p.set_exception(std::current_exception());
+            }
+        },
+        concurrency::task_continuation_context::use_arbitrary());
+
+    return p.get_future().get();
+}
 
 #endif
 
@@ -2639,12 +2988,10 @@ IceInternal::doConnectAsync(SOCKET fd, const Address& addr, const Address& sourc
 
     if(::bind(fd, &bindAddr.sa, size) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
-    LPFN_CONNECTEX ConnectEx = NULL; // a pointer to the 'ConnectEx()' function
+    LPFN_CONNECTEX ConnectEx = ICE_NULLPTR; // a pointer to the 'ConnectEx()' function
     GUID GuidConnectEx = WSAID_CONNECTEX; // The Guid
     DWORD dwBytes;
     if(WSAIoctl(fd,
@@ -2654,12 +3001,10 @@ IceInternal::doConnectAsync(SOCKET fd, const Address& addr, const Address& sourc
                 &ConnectEx,
                 sizeof(ConnectEx),
                 &dwBytes,
-                NULL,
-                NULL) == SOCKET_ERROR)
+                ICE_NULLPTR,
+                ICE_NULLPTR) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     if(!ConnectEx(fd, &addr.sa, size, 0, 0, 0, &info))
@@ -2668,21 +3013,15 @@ IceInternal::doConnectAsync(SOCKET fd, const Address& addr, const Address& sourc
         {
             if(connectionRefused())
             {
-                ConnectionRefusedException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw ConnectionRefusedException(__FILE__, __LINE__, getSocketErrno());
             }
             else if(connectFailed())
             {
-                ConnectFailedException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw ConnectFailedException(__FILE__, __LINE__, getSocketErrno());
             }
             else
             {
-                SocketException ex(__FILE__, __LINE__);
-                ex.error = getSocketErrno();
-                throw ex;
+                throw SocketException(__FILE__, __LINE__, getSocketErrno());
             }
         }
     }
@@ -2696,35 +3035,41 @@ IceInternal::doFinishConnectAsync(SOCKET fd, AsyncInfo& info)
     // failure to connect. The socket isn't closed by this method.
     //
 
-    if(static_cast<int>(info.count) == SOCKET_ERROR)
+    if(info.error != ERROR_SUCCESS)
     {
         WSASetLastError(info.error);
         if(connectionRefused())
         {
-            ConnectionRefusedException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectionRefusedException(__FILE__, __LINE__, getSocketErrno());
         }
         else if(connectFailed())
         {
-            ConnectFailedException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw ConnectFailedException(__FILE__, __LINE__, getSocketErrno());
         }
         else
         {
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
 
-    if(setsockopt(fd, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, NULL, 0) == SOCKET_ERROR)
+    if(setsockopt(fd, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, ICE_NULLPTR, 0) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 }
 #endif
 
+bool
+IceInternal::isIpAddress(const string& name)
+{
+#ifdef ICE_OS_UWP
+     HostName^ hostname = ref new HostName(ref new String(stringToWstring(name,
+                                                          getProcessStringConverter()).c_str()));
+     return hostname->Type == HostNameType::Ipv4 || hostname->Type == HostNameType::Ipv6;
+#else
+    in_addr addr;
+    in6_addr addr6;
+
+    return inet_pton(AF_INET, name.c_str(), &addr) > 0 || inet_pton(AF_INET6, name.c_str(), &addr6) > 0;
+#endif
+}