zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -23,7 +23,7 @@ using namespace Ice;
 using namespace IceInternal;
 using namespace IceMX;
 
-namespace 
+namespace
 {
 
 const string suffixes[] =
@@ -80,7 +80,7 @@ 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&)
         {
@@ -99,10 +99,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 +120,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 +134,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 +145,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 +169,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 == '.';
@@ -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 + ".";
@@ -378,10 +388,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,7 +449,7 @@ 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
             {
@@ -455,7 +465,7 @@ MetricsAdminI::updateViews()
             }
         }
         _views.swap(views);
-        
+
         //
         // Go through removed views to collect maps to update.
         //
@@ -472,7 +482,7 @@ MetricsAdminI::updateViews()
             }
         }
     }
-    
+
     //
     // Call the updaters to update the maps.
     //
@@ -523,13 +533,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 +554,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 +569,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 +586,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 +602,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 +617,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 +649,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,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -11,4 +11,3 @@
 
 #include <Ice/Connection.h>
 #include <Ice/Endpoint.h>
-

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -21,17 +21,17 @@
 #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>
 
-#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>
@@ -46,7 +46,7 @@
 #   include <sys/ioctl.h>
 #endif
 
-#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+#if defined(__linux) || defined(__APPLE__) || defined(__FreeBSD__)
 #  include <ifaddrs.h>
 #elif defined(__sun)
 #  include <sys/sockio.h>
@@ -72,12 +72,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,10 +87,24 @@ 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
+#ifndef ICE_OS_UWP
 struct AddressIsIPv6 : public unary_function<Address, bool>
 {
 public:
@@ -113,7 +127,7 @@ struct RandomNumberGenerator : public std::unary_function<ptrdiff_t, ptrdiff_t>
 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);
@@ -159,7 +173,31 @@ setKeepAlive(SOCKET fd)
 }
 #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);
+            SocketException ex(__FILE__, __LINE__);
+            ex.error = getSocketErrno();
+            throw ex;
+        }
+    }
+}
+#endif
+
+#ifdef ICE_OS_UWP
 SOCKET
 createSocketImpl(bool udp, int)
 {
@@ -205,7 +243,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,7 +260,7 @@ createSocketImpl(bool udp, int family)
 }
 #endif
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 vector<Address>
 getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
 {
@@ -244,16 +282,20 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
     }
 
     DWORD size;
-    DWORD rv = GetAdaptersAddresses(family, 0, NULL, NULL, &size);
-    if (rv == ERROR_BUFFER_OVERFLOW)
+    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);
@@ -279,7 +321,7 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
 
         free(adapter_addresses);
     }
-#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+#elif defined(__linux) || defined(__APPLE__) || defined(__FreeBSD__)
     struct ifaddrs* ifap;
     if(::getifaddrs(&ifap) == SOCKET_ERROR)
     {
@@ -438,11 +480,11 @@ getLocalAddresses(ProtocolSupport protocol, bool includeLoopback)
 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 +495,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)
-            {
-                ipv4 = true;
-                return true;
-            }
-        }
-        else if(addr.saStorage.ss_family)
+        if(addr.saIn.sin_addr.s_addr == INADDR_ANY)
         {
-            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 +595,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 +606,10 @@ getInterfaceIndex(const string& name)
         }
         delete[] buf;
     }
+    if(index < 0) // interface not found
+    {
+        throw Ice::SocketException(__FILE__, __LINE__, WSAEINVAL);
+    }
 #elif !defined(__hpux)
 
     //
@@ -563,7 +617,7 @@ getInterfaceIndex(const string& name)
     //
     if(isAddr)
     {
-#  if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
+#  if defined(__linux) || defined(__APPLE__) || defined(__FreeBSD__)
         struct ifaddrs* ifap;
         if(::getifaddrs(&ifap) != SOCKET_ERROR)
         {
@@ -653,6 +707,11 @@ getInterfaceIndex(const string& name)
     {
         index = 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
 
     return index;
@@ -689,19 +748,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 +769,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 +792,28 @@ getAddressStorageSize(const Address& addr)
     return size;
 }
 
-#endif // #ifndef ICE_OS_WINRT
+#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));
@@ -762,7 +837,97 @@ IceInternal::NativeInfo::completed(SocketOperation operation)
         throw ex;
     }
 }
-#elif defined(ICE_OS_WINRT)
+
+#elif defined(ICE_OS_UWP)
+
+void
+IceInternal::NativeInfo::queueAction(SocketOperation op, IAsyncAction^ action, bool connect)
+{
+    AsyncInfo* asyncInfo = getAsyncInfo(op);
+    if(checkIfErrorOrCompleted(op, action, connect))
+    {
+        asyncInfo->count = 0;
+    }
+    else
+    {
+        action->Completed = ref new AsyncActionCompletedHandler(
+            [=] (IAsyncAction^ info, Windows::Foundation::AsyncStatus status)
+            {
+                //
+                // COMPILERFIX with VC141 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);
+            });
+    }
+}
+
+void
+IceInternal::NativeInfo::queueActionCompleted(SocketOperation op, AsyncInfo* asyncInfo, IAsyncAction^ info,
+                                              Windows::Foundation::AsyncStatus status)
+{
+    if(status != Windows::Foundation::AsyncStatus::Completed)
+    {
+        asyncInfo->count = SOCKET_ERROR;
+        asyncInfo->error = info->ErrorCode.Value;
+    }
+    else
+    {
+        asyncInfo->count = 0;
+    }
+    completed(op);
+}
+
+void
+IceInternal::NativeInfo::queueOperation(SocketOperation op, IAsyncOperation<unsigned int>^ operation)
+{
+    AsyncInfo* info = getAsyncInfo(op);
+    if(checkIfErrorOrCompleted(op, operation))
+    {
+        info->count = static_cast<int>(operation->GetResults());
+    }
+    else
+    {
+        if(!info->completedHandler)
+        {
+            info->completedHandler = ref new AsyncOperationCompletedHandler<unsigned int>(
+                [=] (IAsyncOperation<unsigned int>^ operation, Windows::Foundation::AsyncStatus status)
+                {
+                    //
+                    // COMPILERFIX with VC141 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;
+    }
+}
+
+void
+IceInternal::NativeInfo::queueOperationCompleted(SocketOperation op, AsyncInfo* info,
+                                                 IAsyncOperation<unsigned int>^ operation,
+                                                 Windows::Foundation::AsyncStatus status)
+{
+    if(status != Windows::Foundation::AsyncStatus::Completed)
+    {
+        info->count = SOCKET_ERROR;
+        info->error = operation->ErrorCode.Value;
+    }
+    else
+    {
+        info->count = static_cast<int>(operation->GetResults());
+    }
+    completed(op);
+}
+
+void
+IceInternal::NativeInfo::setCompletedHandler(SocketOperationCompletedHandler^ handler)
+{
+    _completedHandler = handler;
+}
 
 void
 IceInternal::NativeInfo::completed(SocketOperation operation)
@@ -771,12 +936,69 @@ IceInternal::NativeInfo::completed(SocketOperation operation)
     _completedHandler(operation);
 }
 
+bool
+IceInternal::NativeInfo::checkIfErrorOrCompleted(SocketOperation op, IAsyncInfo^ info, 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.
+    //
+    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(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 +1007,7 @@ IceInternal::noMoreFds(int error)
 #endif
 }
 
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
 string
 IceInternal::errorToStringDNS(int)
 {
@@ -803,7 +1025,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,16 +1044,16 @@ 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;
     }
@@ -847,7 +1069,7 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport, Ice::En
 #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;
@@ -895,7 +1117,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,12 +1134,12 @@ 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)
     {
@@ -927,7 +1149,7 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
         throw ex;
     }
 
-    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)
@@ -967,11 +1189,11 @@ IceInternal::getAddresses(const string& host, int port, ProtocolSupport protocol
 }
 #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 +1205,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 +1214,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 +1240,14 @@ 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 +1322,7 @@ IceInternal::compareAddress(const Address& addr1, const Address& addr2)
 #endif
 }
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 bool
 IceInternal::isIPv6Supported()
 {
@@ -1122,7 +1345,7 @@ IceInternal::isIPv6Supported()
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 SOCKET
 IceInternal::createSocket(bool udp, const Address&)
 {
@@ -1136,7 +1359,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)
 {
@@ -1171,7 +1394,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 +1417,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
@@ -1245,7 +1468,7 @@ 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)
     {
@@ -1272,7 +1495,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)
     {
@@ -1427,14 +1650,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,8 +1669,7 @@ 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)
@@ -1464,6 +1686,17 @@ IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport proto
     }
     return hosts;
 }
+
+vector<string>
+IceInternal::getInterfacesForMulticast(const string& intf, ProtocolSupport protocolSupport)
+{
+    vector<string> interfaces = getHostsForEndpointExpand(intf, protocolSupport, true);
+    if(interfaces.empty())
+    {
+        interfaces.push_back(intf);
+    }
+    return interfaces;
+}
 #else
 vector<string>
 IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport protocolSupport, bool includeLoopback)
@@ -1488,12 +1721,32 @@ IceInternal::getHostsForEndpointExpand(const string& host, ProtocolSupport proto
     }
     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);
+        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)
     {
@@ -1515,7 +1768,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 +1776,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);
@@ -1541,7 +1794,7 @@ IceInternal::getPort(const Address& addr)
     //
     // 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 +1805,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 +1820,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 +1847,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 +1942,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)
 {
@@ -1753,7 +2006,7 @@ 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);
@@ -1773,7 +2026,7 @@ 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 ||
@@ -1795,7 +2048,7 @@ IceInternal::getSendBufferSize(SOCKET fd)
 #endif
 }
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setRecvBufferSize(SOCKET, int)
 {
@@ -1817,7 +2070,7 @@ 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 ||
@@ -1834,31 +2087,41 @@ 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
-    {
-        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)
+    vector<string> interfaces = getInterfacesForMulticast(intf, getProtocolSupport(group));
+    set<int> indexes;
+    for(vector<string>::const_iterator p = interfaces.begin(); p != interfaces.end(); ++p)
     {
-        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 = index;
+                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;
+        }
     }
 }
 #else
@@ -1868,9 +2131,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 +2167,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&)
 {
@@ -1909,7 +2197,7 @@ IceInternal::setMcastInterface(SOCKET fd, const string& intf, const Address& add
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setMcastTtl(SOCKET, int, const Address&)
 {
@@ -1937,7 +2225,7 @@ IceInternal::setMcastTtl(SOCKET fd, int ttl, const Address& addr)
 }
 #endif
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 void
 IceInternal::setReuseAddress(SOCKET, bool)
 {
@@ -1957,41 +2245,51 @@ IceInternal::setReuseAddress(SOCKET fd, bool reuse)
 }
 #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 +2313,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,7 +2354,11 @@ 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);
 
@@ -2052,15 +2379,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();
@@ -2293,7 +2621,7 @@ repeatConnect:
         }
     }
 
-#if defined(__linux__)
+#if defined(__linux)
     //
     // Prevent self connect (self connect happens on Linux when a client tries to connect to
     // a server which was just deactivated if the client socket re-uses the same ephemeral
@@ -2372,7 +2700,7 @@ IceInternal::doFinishConnect(SOCKET fd)
         }
     }
 
-#if defined(__linux__)
+#if defined(__linux)
     //
     // Prevent self connect (self connect happens on Linux when a client tries to connect to
     // a server which was just deactivated if the client socket re-uses the same ephemeral
@@ -2417,7 +2745,6 @@ repeatAccept:
     return ret;
 }
 
-
 void
 IceInternal::createPipe(SOCKET fds[2])
 {
@@ -2521,10 +2848,10 @@ 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)
     {
@@ -2554,11 +2881,6 @@ IceInternal::checkConnectErrorCode(const char* file, int line, HRESULT herr, Hos
     {
         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;
     }
     else
@@ -2601,6 +2923,34 @@ IceInternal::checkErrorCode(const char* file, int line, HRESULT herr)
     }
 }
 
+//
+// 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
 
@@ -2644,7 +2994,7 @@ IceInternal::doConnectAsync(SOCKET fd, const Address& addr, const Address& sourc
         throw ex;
     }
 
-    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,8 +3004,8 @@ 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();
@@ -2719,7 +3069,7 @@ IceInternal::doFinishConnectAsync(SOCKET fd, AsyncInfo& info)
         }
     }
 
-    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();
@@ -2728,3 +3078,17 @@ IceInternal::doFinishConnectAsync(SOCKET fd, AsyncInfo& info)
 }
 #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
+}