zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/WSAcceptor.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,18 +21,12 @@ IceInternal::WSAcceptor::getNativeInfo()
     return _delegate->getNativeInfo();
 }
 
-#if defined(ICE_USE_IOCP)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 IceInternal::AsyncInfo*
 IceInternal::WSAcceptor::getAsyncInfo(IceInternal::SocketOperation status)
 {
     return _delegate->getNativeInfo()->getAsyncInfo(status);
 }
-#elif defined(ICE_OS_WINRT)
-void
-IceInternal::WSAcceptor::setCompletedHandler(IceInternal::SocketOperationCompletedHandler^ handler)
-{
-    _delegate->getNativeInfo()->setCompletedHandler(handler);
-}
 #endif
 
 void
@@ -48,7 +42,7 @@ IceInternal::WSAcceptor::listen()
     return _endpoint;
 }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 void
 IceInternal::WSAcceptor::startAccept()
 {

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

@@ -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.
@@ -26,15 +26,13 @@ class WSAcceptor : public Acceptor, public NativeInfo
 public:
 
     virtual NativeInfoPtr getNativeInfo();
-#if defined(ICE_USE_IOCP)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     virtual AsyncInfo* getAsyncInfo(SocketOperation);
-#elif defined(ICE_OS_WINRT)
-    virtual void setCompletedHandler(SocketOperationCompletedHandler^);
 #endif
 
     virtual void close();
     virtual EndpointIPtr listen();
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     virtual void startAccept();
     virtual void finishAccept();
 #endif
@@ -43,8 +41,6 @@ public:
     virtual std::string toString() const;
     virtual std::string toDetailedString() const;
 
-    virtual AcceptorPtr delegate() const { return _delegate; }
-
 private:
 
     WSAcceptor(const WSEndpointPtr&, const ProtocolInstancePtr&, const AcceptorPtr&);

data/ext/ice/cpp/src/Ice/WSConnector.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.
@@ -19,7 +19,7 @@ using namespace IceInternal;
 TransceiverPtr
 IceInternal::WSConnector::connect()
 {
-    return new WSTransceiver(_instance, _delegate->connect(), _host, _port, _resource);
+    return new WSTransceiver(_instance, _delegate->connect(), _host, _resource);
 }
 
 Short
@@ -61,12 +61,6 @@ IceInternal::WSConnector::operator==(const Connector& r) const
     return true;
 }
 
-bool
-IceInternal::WSConnector::operator!=(const Connector& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceInternal::WSConnector::operator<(const Connector& r) const
 {
@@ -102,9 +96,9 @@ IceInternal::WSConnector::operator<(const Connector& r) const
     return false;
 }
 
-IceInternal::WSConnector::WSConnector(const ProtocolInstancePtr& instance, const ConnectorPtr& del, const string& host, 
-                                        int port, const string& resource) :
-    _instance(instance), _delegate(del), _host(host), _port(port), _resource(resource)
+IceInternal::WSConnector::WSConnector(const ProtocolInstancePtr& instance, const ConnectorPtr& del, const string& host,
+                                      const string& resource) :
+    _instance(instance), _delegate(del), _host(host), _resource(resource)
 {
 }
 

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

@@ -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.
@@ -30,19 +30,16 @@ public:
     virtual std::string toString() const;
 
     virtual bool operator==(const Connector&) const;
-    virtual bool operator!=(const Connector&) const;
     virtual bool operator<(const Connector&) const;
 
-
-    WSConnector(const ProtocolInstancePtr&, const ConnectorPtr&, const std::string&, int, const std::string&);
+    WSConnector(const ProtocolInstancePtr&, const ConnectorPtr&, const std::string&, const std::string&);
     virtual ~WSConnector();
 
 private:
-    
+
     const ProtocolInstancePtr _instance;
     const ConnectorPtr _delegate;
     const std::string _host;
-    const int _port;
     const std::string _resource;
 };
 

data/ext/ice/cpp/src/Ice/WSEndpoint.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.
@@ -10,25 +10,107 @@
 #include <Ice/WSEndpoint.h>
 #include <Ice/WSAcceptor.h>
 #include <Ice/WSConnector.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/LocalException.h>
 #include <Ice/IPEndpointI.h>
 #include <Ice/HashUtil.h>
 #include <Ice/EndpointFactoryManager.h>
+#include <Ice/Comparable.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
+namespace
+{
+
+class WSEndpointFactoryPlugin : public Plugin
+{
+public:
+
+    WSEndpointFactoryPlugin(const CommunicatorPtr&);
+    virtual void initialize();
+    virtual void destroy();
+};
+
+IPEndpointInfoPtr
+getIPEndpointInfo(const EndpointInfoPtr& info)
+{
+    for(EndpointInfoPtr p = info; p; p = p->underlying)
+    {
+        IPEndpointInfoPtr ipInfo = ICE_DYNAMIC_CAST(IPEndpointInfo, p);
+        if(ipInfo)
+        {
+            return ipInfo;
+        }
+    }
+    return ICE_NULLPTR;
+}
+
+}
+
+extern "C"
+{
+
+Plugin*
+createIceWS(const CommunicatorPtr& c, const string&, const StringSeq&)
+{
+    return new WSEndpointFactoryPlugin(c);
+}
+
+}
+
+namespace Ice
+{
+
+ICE_API void
+registerIceWS(bool loadOnInitialize)
+{
+    registerPluginFactory("IceWS", createIceWS, loadOnInitialize);
+}
+
+}
+
+//
+// Objective-C function to allow Objective-C programs to register plugin.
+//
+extern "C" ICE_API void
+ICEregisterIceWS(bool loadOnInitialize)
+{
+    Ice::registerIceWS(loadOnInitialize);
+}
+
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(WSEndpoint* p) { return p; }
+#endif
+
+WSEndpointFactoryPlugin::WSEndpointFactoryPlugin(const CommunicatorPtr& communicator)
+{
+    assert(communicator);
+
+    const EndpointFactoryManagerPtr efm = getInstance(communicator)->endpointFactoryManager();
+    efm->add(new WSEndpointFactory(new ProtocolInstance(communicator, WSEndpointType, "ws", false), TCPEndpointType));
+    efm->add(new WSEndpointFactory(new ProtocolInstance(communicator, WSSEndpointType, "wss", true), SSLEndpointType));
+}
+
+void
+WSEndpointFactoryPlugin::initialize()
+{
+}
+
+void
+WSEndpointFactoryPlugin::destroy()
+{
+}
 
 IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, const string& res) :
-    _instance(instance), _delegate(IPEndpointIPtr::dynamicCast(del)), _resource(res)
+    _instance(instance), _delegate(del), _resource(res)
 {
 }
 
 IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& inst, const EndpointIPtr& del, vector<string>& args) :
-    _instance(inst), _delegate(IPEndpointIPtr::dynamicCast(del))
+    _instance(inst), _delegate(del)
 {
     initWithOptions(args);
 
@@ -38,20 +120,24 @@ IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& inst, const Endpo
     }
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, BasicStream* s) :
-    _instance(instance), _delegate(IPEndpointIPtr::dynamicCast(del))
+IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, InputStream* s) :
+    _instance(instance), _delegate(del)
 {
     s->read(const_cast<string&>(_resource), false);
 }
 
-Ice::EndpointInfoPtr
+EndpointInfoPtr
 IceInternal::WSEndpoint::getInfo() const
 {
-    assert(dynamic_cast<WSEndpointDelegate*>(_delegate.get()));
-    return dynamic_cast<WSEndpointDelegate*>(_delegate.get())->getWSInfo(_resource);
+    WSEndpointInfoPtr info = ICE_MAKE_SHARED(InfoI<WSEndpointInfo>, ICE_SHARED_FROM_CONST_THIS(WSEndpoint));
+    info->underlying = _delegate->getInfo();
+    info->compress = info->underlying->compress;
+    info->timeout = info->underlying->timeout;
+    info->resource = _resource;
+    return info;
 }
 
-Ice::Short
+Short
 IceInternal::WSEndpoint::type() const
 {
     return _delegate->type();
@@ -64,12 +150,10 @@ IceInternal::WSEndpoint::protocol() const
 }
 
 void
-IceInternal::WSEndpoint::streamWrite(BasicStream* s) const
+IceInternal::WSEndpoint::streamWriteImpl(OutputStream* s) const
 {
-    s->startWriteEncaps();
     _delegate->streamWriteImpl(s);
     s->write(_resource, false);
-    s->endWriteEncaps();
 }
 
 Int
@@ -83,11 +167,11 @@ IceInternal::WSEndpoint::timeout(Int timeout) const
 {
     if(timeout == _delegate->timeout())
     {
-        return const_cast<WSEndpoint*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
     }
     else
     {
-        return new WSEndpoint(_instance, _delegate->timeout(timeout), _resource);
+        return ICE_MAKE_SHARED(WSEndpoint, _instance, _delegate->timeout(timeout), _resource);
     }
 }
 
@@ -102,11 +186,11 @@ IceInternal::WSEndpoint::connectionId(const string& connectionId) const
 {
     if(connectionId == _delegate->connectionId())
     {
-        return const_cast<WSEndpoint*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
     }
     else
     {
-        return new WSEndpoint(_instance, _delegate->connectionId(connectionId), _resource);
+        return ICE_MAKE_SHARED(WSEndpoint, _instance, _delegate->connectionId(connectionId), _resource);
     }
 }
 
@@ -121,11 +205,11 @@ IceInternal::WSEndpoint::compress(bool compress) const
 {
     if(compress == _delegate->compress())
     {
-        return const_cast<WSEndpoint*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
     }
     else
     {
-        return new WSEndpoint(_instance, _delegate->compress(compress), _resource);
+        return ICE_MAKE_SHARED(WSEndpoint, _instance, _delegate->compress(compress), _resource);
     }
 }
 
@@ -148,7 +232,7 @@ IceInternal::WSEndpoint::transceiver() const
 }
 
 void
-IceInternal::WSEndpoint::connectors_async(Ice::EndpointSelectionType selType,
+IceInternal::WSEndpoint::connectors_async(EndpointSelectionType selType,
                                          const EndpointI_connectorsPtr& callback) const
 {
     class CallbackI : public EndpointI_connectors
@@ -156,8 +240,8 @@ IceInternal::WSEndpoint::connectors_async(Ice::EndpointSelectionType selType,
     public:
 
         CallbackI(const EndpointI_connectorsPtr& callback, const ProtocolInstancePtr& instance,
-                  const string& host, int port, const string& resource) :
-            _callback(callback), _instance(instance), _host(host), _port(port), _resource(resource)
+                  const string& host, const string& resource) :
+            _callback(callback), _instance(instance), _host(host), _resource(resource)
         {
         }
 
@@ -166,12 +250,12 @@ IceInternal::WSEndpoint::connectors_async(Ice::EndpointSelectionType selType,
             vector<ConnectorPtr> connectors = c;
             for(vector<ConnectorPtr>::iterator p = connectors.begin(); p != connectors.end(); ++p)
             {
-                *p = new WSConnector(_instance, *p, _host, _port, _resource);
+                *p = new WSConnector(_instance, *p, _host, _resource);
             }
             _callback->connectors(connectors);
         }
 
-        virtual void exception(const Ice::LocalException& ex)
+        virtual void exception(const LocalException& ex)
         {
             _callback->exception(ex);
         }
@@ -181,33 +265,78 @@ IceInternal::WSEndpoint::connectors_async(Ice::EndpointSelectionType selType,
         const EndpointI_connectorsPtr _callback;
         const ProtocolInstancePtr _instance;
         const string _host;
-        const int _port;
         const string _resource;
     };
-    _delegate->connectors_async(selType, new CallbackI(callback, _instance, _delegate->host(), _delegate->port(),
-                                                       _resource));
+
+    ostringstream host;
+    IPEndpointInfoPtr info = getIPEndpointInfo(_delegate->getInfo());
+    if(info)
+    {
+        host << info->host << ":" << info->port;
+    }
+    _delegate->connectors_async(selType, ICE_MAKE_SHARED(CallbackI, callback, _instance, host.str(), _resource));
 }
 
 AcceptorPtr
 IceInternal::WSEndpoint::acceptor(const string& adapterName) const
 {
     AcceptorPtr delAcc = _delegate->acceptor(adapterName);
-    return new WSAcceptor(const_cast<WSEndpoint*>(this), _instance, delAcc);
+    return new WSAcceptor(ICE_SHARED_FROM_CONST_THIS(WSEndpoint), _instance, delAcc);
 }
 
 WSEndpointPtr
 IceInternal::WSEndpoint::endpoint(const EndpointIPtr& delEndp) const
 {
-    return new WSEndpoint(_instance, delEndp, _resource);
+    if(delEndp.get() == _delegate.get())
+    {
+        return ICE_DYNAMIC_CAST(WSEndpoint, ICE_SHARED_FROM_CONST_THIS(WSEndpoint));
+    }
+    else
+    {
+        return ICE_MAKE_SHARED(WSEndpoint, _instance, delEndp, _resource);
+    }
 }
 
 vector<EndpointIPtr>
-IceInternal::WSEndpoint::expand() const
+IceInternal::WSEndpoint::expandIfWildcard() const
 {
-    vector<EndpointIPtr> endps = _delegate->expand();
+    vector<EndpointIPtr> endps = _delegate->expandIfWildcard();
     for(vector<EndpointIPtr>::iterator p = endps.begin(); p != endps.end(); ++p)
     {
-        *p = p->get() == _delegate.get() ? const_cast<WSEndpoint*>(this) : new WSEndpoint(_instance, *p, _resource);
+        if(p->get() == _delegate.get())
+        {
+            *p = ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
+        }
+        else
+        {
+            *p = ICE_MAKE_SHARED(WSEndpoint, _instance, *p, _resource);
+        }
+    }
+    return endps;
+}
+
+vector<EndpointIPtr>
+IceInternal::WSEndpoint::expandHost(EndpointIPtr& publish) const
+{
+    vector<EndpointIPtr> endps = _delegate->expandHost(publish);
+    if(publish.get() == _delegate.get())
+    {
+        publish = ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
+    }
+    else if(publish.get())
+    {
+        publish = ICE_MAKE_SHARED(WSEndpoint, _instance, publish, _resource);
+    }
+    for(vector<EndpointIPtr>::iterator p = endps.begin(); p != endps.end(); ++p)
+    {
+        if(p->get() == _delegate.get())
+        {
+            *p = ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
+        }
+        else
+        {
+            *p = ICE_MAKE_SHARED(WSEndpoint, _instance, *p, _resource);
+        }
     }
     return endps;
 }
@@ -223,7 +352,7 @@ IceInternal::WSEndpoint::equivalent(const EndpointIPtr& endpoint) const
     return _delegate->equivalent(wsEndpointI->_delegate);
 }
 
-Ice::Int
+Int
 IceInternal::WSEndpoint::hash() const
 {
     int h = _delegate->hash();
@@ -262,14 +391,12 @@ IceInternal::WSEndpoint::options() const
     return s.str();
 }
 
-EndpointIPtr
-IceInternal::WSEndpoint::delegate() const
-{
-    return EndpointIPtr::dynamicCast(_delegate);
-}
-
 bool
-IceInternal::WSEndpoint::operator==(const Ice::LocalObject& r) const
+#ifdef ICE_CPP11_MAPPING
+IceInternal::WSEndpoint::operator==(const Endpoint& r) const
+#else
+IceInternal::WSEndpoint::operator==(const LocalObject& r) const
+#endif
 {
     const WSEndpoint* p = dynamic_cast<const WSEndpoint*>(&r);
     if(!p)
@@ -282,7 +409,7 @@ IceInternal::WSEndpoint::operator==(const Ice::LocalObject& r) const
         return true;
     }
 
-    if(_delegate != p->_delegate)
+    if(!targetEqualTo(_delegate, p->_delegate))
     {
         return false;
     }
@@ -296,12 +423,16 @@ IceInternal::WSEndpoint::operator==(const Ice::LocalObject& r) const
 }
 
 bool
-IceInternal::WSEndpoint::operator<(const Ice::LocalObject& r) const
+#ifdef ICE_CPP11_MAPPING
+IceInternal::WSEndpoint::operator<(const Endpoint& r) const
+#else
+IceInternal::WSEndpoint::operator<(const LocalObject& r) const
+#endif
 {
     const WSEndpoint* p = dynamic_cast<const WSEndpoint*>(&r);
     if(!p)
     {
-        const EndpointI* e = dynamic_cast<const WSEndpoint*>(&r);
+        const EndpointI* e = dynamic_cast<const EndpointI*>(&r);
         if(!e)
         {
             return false;
@@ -314,11 +445,11 @@ IceInternal::WSEndpoint::operator<(const Ice::LocalObject& r) const
         return false;
     }
 
-    if(_delegate < p->_delegate)
+    if(targetLess(_delegate, p->_delegate))
     {
         return true;
     }
-    else if (p->_delegate < _delegate)
+    else if (targetLess(p->_delegate, _delegate))
     {
         return false;
     }
@@ -333,7 +464,6 @@ IceInternal::WSEndpoint::operator<(const Ice::LocalObject& r) const
     }
 
     return false;
-
 }
 
 bool
@@ -360,50 +490,25 @@ IceInternal::WSEndpoint::checkOption(const string& option, const string& argumen
     }
 }
 
-IceInternal::WSEndpointFactory::WSEndpointFactory(const ProtocolInstancePtr& instance, const EndpointFactoryPtr& del) :
-    _instance(instance),
-    _delegate(del)
-{
-}
-
-IceInternal::WSEndpointFactory::~WSEndpointFactory()
-{
-}
-
-Short
-IceInternal::WSEndpointFactory::type() const
+IceInternal::WSEndpointFactory::WSEndpointFactory(const ProtocolInstancePtr& instance, Short type) :
+    EndpointFactoryWithUnderlying(instance, type)
 {
-    return _instance->type();
 }
 
-string
-IceInternal::WSEndpointFactory::protocol() const
+EndpointFactoryPtr
+IceInternal::WSEndpointFactory::cloneWithUnderlying(const ProtocolInstancePtr& instance, Short underlying) const
 {
-    return _instance->protocol();
+    return new WSEndpointFactory(instance, underlying);
 }
 
 EndpointIPtr
-IceInternal::WSEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
+IceInternal::WSEndpointFactory::createWithUnderlying(const EndpointIPtr& underlying, vector<string>& args, bool) const
 {
-    return new WSEndpoint(_instance, _delegate->create(args, oaEndpoint), args);
+    return ICE_MAKE_SHARED(WSEndpoint, _instance, underlying, args);
 }
 
 EndpointIPtr
-IceInternal::WSEndpointFactory::read(BasicStream* s) const
-{
-    return new WSEndpoint(_instance, _delegate->read(s), s);
-}
-
-void
-IceInternal::WSEndpointFactory::destroy()
-{
-    _delegate->destroy();
-    _instance = 0;
-}
-
-EndpointFactoryPtr
-IceInternal::WSEndpointFactory::clone(const ProtocolInstancePtr&) const
+IceInternal::WSEndpointFactory::readWithUnderlying(const EndpointIPtr& underlying, InputStream* s) const
 {
-    assert(false); // We don't support cloning this transport.
-    return 0;
+    return ICE_MAKE_SHARED(WSEndpoint, _instance, underlying, s);
 }