zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_NETWORK_H
 #define ICE_NETWORK_H
@@ -24,8 +19,8 @@
 #include <Ice/ProtocolInstanceF.h>
 #include <Ice/EndpointTypes.h>
 
-#ifdef ICE_OS_WINRT
-#   include <Ice/EventHandlerF.h>
+#if defined(ICE_OS_UWP)
+#   include <ppltasks.h>
 #elif defined(_WIN32)
 #   include <winsock2.h>
 #   include <ws2tcpip.h>
@@ -50,7 +45,7 @@ typedef int ssize_t;
 #elif defined(__APPLE__) && !defined(ICE_NO_CFSTREAM)
 #   define ICE_USE_CFSTREAM 1
 #elif defined(_WIN32)
-#  if defined(ICE_OS_WINRT)
+#  if defined(ICE_OS_UWP)
 #  elif !defined(ICE_NO_IOCP)
 #     define ICE_USE_IOCP 1
 #  else
@@ -68,7 +63,7 @@ typedef int socklen_t;
 #   define SOCKET int
 #   define INVALID_SOCKET -1
 #   define SOCKET_ERROR -1
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
     typedef Platform::Object^ SOCKET;
 #   define INVALID_SOCKET nullptr
 #   define SOCKET_ERROR -1
@@ -115,7 +110,7 @@ namespace IceInternal
 //
 // Use Address struct or union depending on the platform
 //
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 struct ICE_API Address
 {
     Windows::Networking::HostName^ host;
@@ -152,17 +147,7 @@ enum SocketOperation
 };
 
 //
-// On WinRT, wait only for read to return, on IOCP/Win32 wait for
-// both pending read and write operations to complete (#ICE-6695).
-//
-#if defined(ICE_OS_WINRT)
-const int SocketOperationWaitForClose = 1;
-#elif defined(ICE_USE_IOCP)
-const int SocketOperationWaitForClose = 3;
-#endif
-
-//
-// AsyncInfo struct for Windows IOCP or WinRT holds the result of
+// AsyncInfo struct for Windows IOCP or UWP holds the result of
 // asynchronous operations after it completed.
 //
 #if defined(ICE_USE_IOCP)
@@ -174,11 +159,13 @@ struct ICE_API AsyncInfo : WSAOVERLAPPED
     WSABUF buf;
     DWORD flags;
     DWORD count;
-    int error;
+    DWORD error;
 };
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
 struct ICE_API AsyncInfo
 {
+    Windows::Foundation::AsyncOperationCompletedHandler<unsigned int>^ completedHandler;
+    Windows::Foundation::IAsyncInfo^ operation;
     int count;
     int error;
 };
@@ -186,11 +173,26 @@ struct ICE_API AsyncInfo
 delegate void SocketOperationCompletedHandler(int);
 #endif
 
-class ICE_API NativeInfo : virtual public IceUtil::Shared
+class ICE_API ReadyCallback : public virtual ::IceUtil::Shared
+{
+public:
+
+    virtual ~ReadyCallback();
+
+    virtual void ready(SocketOperation, bool) = 0;
+};
+typedef IceUtil::Handle<ReadyCallback> ReadyCallbackPtr;
+
+class ICE_API NativeInfo : public virtual IceUtil::Shared
 {
 public:
 
+    virtual ~NativeInfo();
+
     NativeInfo(SOCKET socketFd = INVALID_SOCKET) : _fd(socketFd)
+#if !defined(ICE_USE_IOCP) && !defined(ICE_OS_UWP)
+        , _newFd(INVALID_SOCKET)
+#endif
     {
     }
 
@@ -199,27 +201,55 @@ public:
         return _fd;
     }
 
+    void setReadyCallback(const ReadyCallbackPtr& callback);
+
+    void ready(SocketOperation operation, bool value)
+    {
+        assert(_readyCallback);
+        _readyCallback->ready(operation, value);
+    }
+
     //
     // This is implemented by transceiver and acceptor implementations.
     //
 #if defined(ICE_USE_IOCP)
     virtual AsyncInfo* getAsyncInfo(SocketOperation) = 0;
     void initialize(HANDLE, ULONG_PTR);
-    void completed(SocketOperation operation);
-#elif defined(ICE_OS_WINRT)
-    virtual void setCompletedHandler(SocketOperationCompletedHandler^) = 0;
-    void completed(SocketOperation operation);
+    void completed(SocketOperation);
+#elif defined(ICE_OS_UWP)
+    virtual AsyncInfo* getAsyncInfo(SocketOperation) = 0;
+    void queueAction(SocketOperation, Windows::Foundation::IAsyncAction^, bool = false);
+    void queueOperation(SocketOperation, Windows::Foundation::IAsyncOperation<unsigned int>^);
+    void setCompletedHandler(SocketOperationCompletedHandler^);
+    void completed(SocketOperation);
+#else
+    bool newFd();
+    void setNewFd(SOCKET);
 #endif
 
 protected:
 
     SOCKET _fd;
+    ReadyCallbackPtr _readyCallback;
 
 #if defined(ICE_USE_IOCP)
     HANDLE _handle;
     ULONG_PTR _key;
-#elif defined(ICE_OS_WINRT)
+#elif defined(ICE_OS_UWP)
+    bool checkIfErrorOrCompleted(SocketOperation, Windows::Foundation::IAsyncInfo^, Windows::Foundation::AsyncStatus, bool = false);
     SocketOperationCompletedHandler^ _completedHandler;
+#else
+    SOCKET _newFd;
+#endif
+
+private:
+
+#if defined(ICE_OS_UWP)
+    void queueActionCompleted(SocketOperation, AsyncInfo* asyncInfo, Windows::Foundation::IAsyncAction^,
+                              Windows::Foundation::AsyncStatus);
+    void queueOperationCompleted(SocketOperation, AsyncInfo* asyncInfo,
+                                 Windows::Foundation::IAsyncOperation<unsigned int>^,
+                                 Windows::Foundation::AsyncStatus);
 #endif
 };
 typedef IceUtil::Handle<NativeInfo> NativeInfoPtr;
@@ -229,7 +259,7 @@ ICE_API std::string errorToStringDNS(int);
 ICE_API std::vector<Address> getAddresses(const std::string&, int, ProtocolSupport, Ice::EndpointSelectionType, bool,
                                           bool);
 ICE_API ProtocolSupport getProtocolSupport(const Address&);
-ICE_API Address getAddressForServer(const std::string&, int, ProtocolSupport, bool);
+ICE_API Address getAddressForServer(const std::string&, int, ProtocolSupport, bool, bool);
 ICE_API int compareAddress(const Address&, const Address&);
 
 ICE_API bool isIPv6Supported();
@@ -249,6 +279,7 @@ ICE_API std::string addressesToString(const Address&, const Address&, bool);
 ICE_API bool isAddressValid(const Address&);
 
 ICE_API std::vector<std::string> getHostsForEndpointExpand(const std::string&, ProtocolSupport, bool);
+ICE_API std::vector<std::string> getInterfacesForMulticast(const std::string&, ProtocolSupport);
 
 ICE_API std::string inetAddrToString(const Address&);
 ICE_API int getPort(const Address&);
@@ -268,10 +299,10 @@ ICE_API void setMcastGroup(SOCKET, const Address&, const std::string&);
 ICE_API void setMcastInterface(SOCKET, const std::string&, const Address&);
 ICE_API void setMcastTtl(SOCKET, int, const Address&);
 ICE_API void setReuseAddress(SOCKET, bool);
+ICE_API Address doBind(SOCKET, const Address&, const std::string& intf = "");
+ICE_API void doListen(SOCKET, int);
 
-ICE_API Address doBind(SOCKET, const Address&);
-
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 ICE_API bool interrupted();
 ICE_API bool acceptInterrupted();
 ICE_API bool noBuffers();
@@ -284,7 +315,6 @@ ICE_API bool connectionRefused();
 ICE_API bool connectInProgress();
 ICE_API bool connectionLost();
 
-ICE_API void doListen(SOCKET, int);
 ICE_API bool doConnect(SOCKET, const Address&, const Address&);
 ICE_API void doFinishConnect(SOCKET);
 ICE_API SOCKET doAccept(SOCKET);
@@ -295,14 +325,47 @@ ICE_API int getSocketErrno();
 
 ICE_API Address getNumericAddress(const std::string&);
 #else
-ICE_API void checkConnectErrorCode(const char*, int, HRESULT, Windows::Networking::HostName^);
+ICE_API void checkConnectErrorCode(const char*, int, HRESULT);
 ICE_API void checkErrorCode(const char*, int, HRESULT);
+
+//
+// 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::wait, this helper method is used to
+// workaround this limitation.
+//
+template<typename T>
+T runSync(Windows::Foundation::IAsyncOperation<T>^ operation)
+{
+    std::promise<T> p;
+    concurrency::create_task(operation).then(
+        [&p](concurrency::task<T> t)
+        {
+            try
+            {
+                p.set_value(t.get());
+            }
+            catch(...)
+            {
+                p.set_exception(std::current_exception());
+            }
+        },
+        concurrency::task_continuation_context::use_arbitrary());
+
+    return p.get_future().get();
+}
+
+ICE_API void runSync(Windows::Foundation::IAsyncAction^ action);
+
 #endif
 
 #if defined(ICE_USE_IOCP)
 ICE_API void doConnectAsync(SOCKET, const Address&, const Address&, AsyncInfo&);
 ICE_API void doFinishConnectAsync(SOCKET, AsyncInfo&);
 #endif
+
+ICE_API bool isIpAddress(const std::string&);
+
 }
 
 #endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_NETWORK_F_H
 #define ICE_NETWORK_F_H
@@ -17,7 +12,7 @@
 namespace IceInternal
 {
 
-#ifdef ICE_OS_WINRT
+#ifdef ICE_OS_UWP
 struct ICE_API Address;
 #else
 union Address;

data/ext/ice/cpp/src/Ice/NetworkProxy.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/NetworkProxy.h>
 #include <Ice/HttpParser.h>
@@ -17,7 +12,12 @@ using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(NetworkProxy* p) { return p; }
 
-#ifndef ICE_OS_WINRT
+NetworkProxy::~NetworkProxy()
+{
+    // Out of line to avoid weak vtable
+}
+
+#ifndef ICE_OS_UWP
 
 namespace
 {
@@ -118,7 +118,7 @@ SOCKSNetworkProxy::beginWrite(const Address& addr, Buffer& buf)
 SocketOperation
 SOCKSNetworkProxy::endWrite(Buffer& buf)
 {
-    // Once the request is sent, read the response 
+    // Once the request is sent, read the response
     return buf.i != buf.b.end() ? SocketOperationWrite : SocketOperationRead;
 }
 
@@ -162,7 +162,7 @@ NetworkProxyPtr
 SOCKSNetworkProxy::resolveHost(ProtocolSupport protocol) const
 {
     assert(!_host.empty());
-    return new SOCKSNetworkProxy(getAddresses(_host, _port, protocol, Ice::Random, false, true)[0]);
+    return new SOCKSNetworkProxy(getAddresses(_host, _port, protocol, Ice::ICE_ENUM(EndpointSelectionType, Random), false, true)[0]);
 }
 
 Address
@@ -184,13 +184,13 @@ SOCKSNetworkProxy::getProtocolSupport() const
     return EnableIPv4;
 }
 
-HTTPNetworkProxy::HTTPNetworkProxy(const string& host, int port) : 
+HTTPNetworkProxy::HTTPNetworkProxy(const string& host, int port) :
     _host(host), _port(port), _protocol(EnableBoth)
 {
     assert(!host.empty());
 }
 
-HTTPNetworkProxy::HTTPNetworkProxy(const Address& addr, ProtocolSupport protocol) : 
+HTTPNetworkProxy::HTTPNetworkProxy(const Address& addr, ProtocolSupport protocol) :
     _port(0), _address(addr), _protocol(protocol)
 {
 }
@@ -212,7 +212,7 @@ HTTPNetworkProxy::beginWrite(const Address& addr, Buffer& buf)
 SocketOperation
 HTTPNetworkProxy::endWrite(Buffer& buf)
 {
-    // Once the request is sent, read the response 
+    // Once the request is sent, read the response
     return buf.i != buf.b.end() ? SocketOperationWrite : SocketOperationRead;
 }
 
@@ -240,7 +240,7 @@ HTTPNetworkProxy::endRead(Buffer& buf)
         // Read one more byte, we can't easily read bytes in advance
         // since the transport implenentation might be be able to read
         // the data from the memory instead of the socket. This is for
-        // instance the case with the OpenSSL transport (or we would 
+        // instance the case with the OpenSSL transport (or we would
         // have to use a buffering BIO).
         //
         buf.b.resize(buf.b.size() + 1);
@@ -265,7 +265,7 @@ NetworkProxyPtr
 HTTPNetworkProxy::resolveHost(ProtocolSupport protocol) const
 {
     assert(!_host.empty());
-    return new HTTPNetworkProxy(getAddresses(_host, _port, protocol, Ice::Random, false, true)[0], protocol);
+    return new HTTPNetworkProxy(getAddresses(_host, _port, protocol, Ice::ICE_ENUM(EndpointSelectionType, Random), false, true)[0], protocol);
 }
 
 Address
@@ -297,8 +297,9 @@ IceInternal::createNetworkProxy(const Ice::PropertiesPtr& properties, ProtocolSu
     proxyHost = properties->getProperty("Ice.SOCKSProxyHost");
     if(!proxyHost.empty())
     {
-#ifdef ICE_OS_WINRT
-        throw Ice::InitializationException(__FILE__, __LINE__, "SOCKS proxy not supported with WinRT");
+#ifdef ICE_OS_UWP
+        UNREFERENCED_PARAMETER(protocolSupport);
+        throw Ice::InitializationException(__FILE__, __LINE__, "SOCKS proxy not supported with UWP");
 #else
         if(protocolSupport == EnableIPv6)
         {
@@ -312,12 +313,12 @@ IceInternal::createNetworkProxy(const Ice::PropertiesPtr& properties, ProtocolSu
     proxyHost = properties->getProperty("Ice.HTTPProxyHost");
     if(!proxyHost.empty())
     {
-#ifdef ICE_OS_WINRT
-        throw Ice::InitializationException(__FILE__, __LINE__, "HTTP proxy not supported with WinRT");
+#ifdef ICE_OS_UWP
+        throw Ice::InitializationException(__FILE__, __LINE__, "HTTP proxy not supported with UWP");
 #else
         return new HTTPNetworkProxy(proxyHost, properties->getPropertyAsIntWithDefault("Ice.HTTPProxyPort", 1080));
 #endif
     }
-    
+
     return 0;
 }

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

@@ -1,24 +1,22 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_NETWORK_PROXY_H
 #define ICE_NETWORK_PROXY_H
 
 #include <Ice/Network.h>
+#include <Ice/Buffer.h>
 
 namespace IceInternal
 {
 
-class ICE_API NetworkProxy : virtual public IceUtil::Shared
+class ICE_API NetworkProxy : public virtual IceUtil::Shared
 {
 public:
 
+    virtual ~NetworkProxy();
+
     //
     // Write the connection request on the connection established
     // with the network proxy server. This is called right after

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_NETWORK_PROXY_F_H
 #define ICE_NETWORK_PROXY_F_H

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

@@ -0,0 +1,57 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifdef ICE_SWIFT
+
+#include <Ice/OSLogLoggerI.h>
+#include <os/log.h>
+
+using namespace std;
+using namespace Ice;
+
+Ice::OSLogLoggerI::OSLogLoggerI(const std::string& prefix) : _prefix(prefix)
+{
+    const string subsystem = prefix.empty() ? "com.zeroc.ice" : "com.zeroc.ice." + prefix;
+    _log.reset(os_log_create(subsystem.c_str(), ""));
+}
+
+void
+Ice::OSLogLoggerI::print(const std::string& message)
+{
+    os_log_with_type(_log.get(), OS_LOG_TYPE_DEFAULT, "%{public}s.", message.c_str());
+}
+
+void
+Ice::OSLogLoggerI::trace(const std::string& category, const std::string& message)
+{
+    const string subsystem = _prefix.empty() ? "com.zeroc.ice" : "com.zeroc.ice." + _prefix;
+    IceInternal::UniqueRef<os_log_t> log(os_log_create(subsystem.c_str(), category.c_str()));
+    os_log_with_type(log.get(), OS_LOG_TYPE_INFO, "%{public}s.", message.c_str());
+}
+
+void
+Ice::OSLogLoggerI::warning(const std::string& message)
+{
+    os_log_with_type(_log.get(), OS_LOG_TYPE_ERROR, "%{public}s.", message.c_str());
+}
+
+void
+Ice::OSLogLoggerI::error(const std::string& message)
+{
+    os_log_with_type(_log.get(), OS_LOG_TYPE_FAULT, "%{public}s.", message.c_str());
+}
+
+std::string
+Ice::OSLogLoggerI::getPrefix()
+{
+    return _prefix;
+}
+
+LoggerPtr
+Ice::OSLogLoggerI::cloneWithPrefix(const std::string& prefix)
+{
+    return ICE_MAKE_SHARED(OSLogLoggerI, prefix);
+}
+
+#endif