zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/WSEndpoint.cpp

@@ -1,17 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/WSEndpoint.h>
-#include <Ice/WSAcceptor.h>
-#include <Ice/WSConnector.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>
+// Copyright (c) ZeroC, Inc.
+
+#include "WSEndpoint.h"
+#include "EndpointFactoryManager.h"
+#include "HashUtil.h"
+#include "IPEndpointI.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+#include "TargetCompare.h"
+#include "WSAcceptor.h"
+#include "WSConnector.h"
+
+#include <algorithm>
 
 using namespace std;
 using namespace Ice;
@@ -19,74 +19,62 @@ using namespace IceInternal;
 
 namespace
 {
+    const char* const wsPluginName = "IceWS";
 
-class WSEndpointFactoryPlugin : public Plugin
-{
-public:
-
-    WSEndpointFactoryPlugin(const CommunicatorPtr&);
-    virtual void initialize();
-    virtual void destroy();
-};
+    class WSEndpointFactoryPlugin : public Plugin
+    {
+    public:
+        WSEndpointFactoryPlugin(const CommunicatorPtr&);
+        void initialize() override;
+        void destroy() override;
+    };
 
-IPEndpointInfoPtr
-getIPEndpointInfo(const EndpointInfoPtr& info)
-{
-    for(EndpointInfoPtr p = info; p; p = p->underlying)
+    IPEndpointInfoPtr getIPEndpointInfo(const EndpointInfoPtr& info)
     {
-        IPEndpointInfoPtr ipInfo = ICE_DYNAMIC_CAST(IPEndpointInfo, p);
-        if(ipInfo)
+        for (EndpointInfoPtr p = info; p; p = p->underlying)
         {
-            return ipInfo;
+            IPEndpointInfoPtr ipInfo = dynamic_pointer_cast<IPEndpointInfo>(p);
+            if (ipInfo)
+            {
+                return ipInfo;
+            }
         }
+        return nullptr;
     }
-    return ICE_NULLPTR;
-}
-
-}
-
-extern "C"
-{
-
-Plugin*
-createIceWS(const CommunicatorPtr& c, const string&, const StringSeq&)
-{
-    return new WSEndpointFactoryPlugin(c);
-}
-
-}
 
-namespace Ice
-{
+    Plugin* createIceWS(const CommunicatorPtr& c, const string& name, const StringSeq&)
+    {
+        string pluginName{wsPluginName};
 
-ICE_API void
-registerIceWS(bool loadOnInitialize)
-{
-    registerPluginFactory("IceWS", createIceWS, loadOnInitialize);
-}
+        if (name != pluginName)
+        {
+            throw PluginInitializationException{
+                __FILE__,
+                __LINE__,
+                "the WebSocket plug-in must be named '" + pluginName + "'"};
+        }
 
+        return new WSEndpointFactoryPlugin(c);
+    }
 }
 
-//
-// Objective-C function to allow Objective-C programs to register plugin.
-//
-extern "C" ICE_API void
-ICEregisterIceWS(bool loadOnInitialize)
+Ice::PluginFactory
+Ice::wsPluginFactory()
 {
-    Ice::registerIceWS(loadOnInitialize);
+    return {wsPluginName, createIceWS};
 }
 
-#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));
+    efm->add(make_shared<WSEndpointFactory>(
+        make_shared<ProtocolInstance>(communicator, WSEndpointType, "ws", false),
+        TCPEndpointType));
+    efm->add(make_shared<WSEndpointFactory>(
+        make_shared<ProtocolInstance>(communicator, WSSEndpointType, "wss", true),
+        SSLEndpointType));
 }
 
 void
@@ -99,40 +87,39 @@ WSEndpointFactoryPlugin::destroy()
 {
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, const string& res) :
-    _instance(instance), _delegate(del), _resource(res)
+IceInternal::WSEndpoint::WSEndpoint(ProtocolInstancePtr instance, EndpointIPtr del, string res)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _resource(std::move(res))
 {
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& inst, const EndpointIPtr& del, vector<string>& args) :
-    _instance(inst), _delegate(del)
+IceInternal::WSEndpoint::WSEndpoint(ProtocolInstancePtr inst, EndpointIPtr del, vector<string>& args)
+    : _instance(std::move(inst)),
+      _delegate(std::move(del))
 {
     initWithOptions(args);
 
-    if(_resource.empty())
+    if (_resource.empty())
     {
         const_cast<string&>(_resource) = "/";
     }
 }
 
-IceInternal::WSEndpoint::WSEndpoint(const ProtocolInstancePtr& instance, const EndpointIPtr& del, InputStream* s) :
-    _instance(instance), _delegate(del)
+IceInternal::WSEndpoint::WSEndpoint(ProtocolInstancePtr instance, EndpointIPtr del, InputStream* s)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del))
 {
     s->read(const_cast<string&>(_resource), false);
 }
 
 EndpointInfoPtr
-IceInternal::WSEndpoint::getInfo() const ICE_NOEXCEPT
+IceInternal::WSEndpoint::getInfo() const noexcept
 {
-    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;
+    return make_shared<WSEndpointInfo>(_delegate->getInfo(), _resource);
 }
 
-Short
+int16_t
 IceInternal::WSEndpoint::type() const
 {
     return _delegate->type();
@@ -151,22 +138,22 @@ IceInternal::WSEndpoint::streamWriteImpl(OutputStream* s) const
     s->write(_resource, false);
 }
 
-Int
+int32_t
 IceInternal::WSEndpoint::timeout() const
 {
     return _delegate->timeout();
 }
 
 EndpointIPtr
-IceInternal::WSEndpoint::timeout(Int timeout) const
+IceInternal::WSEndpoint::timeout(int32_t timeout) const
 {
-    if(timeout == _delegate->timeout())
+    if (timeout == _delegate->timeout())
     {
-        return ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
+        return const_cast<WSEndpoint*>(this)->shared_from_this();
     }
     else
     {
-        return ICE_MAKE_SHARED(WSEndpoint, _instance, _delegate->timeout(timeout), _resource);
+        return make_shared<WSEndpoint>(_instance, _delegate->timeout(timeout), _resource);
     }
 }
 
@@ -179,13 +166,13 @@ IceInternal::WSEndpoint::connectionId() const
 EndpointIPtr
 IceInternal::WSEndpoint::connectionId(const string& connectionId) const
 {
-    if(connectionId == _delegate->connectionId())
+    if (connectionId == _delegate->connectionId())
     {
-        return ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
+        return const_cast<WSEndpoint*>(this)->shared_from_this();
     }
     else
     {
-        return ICE_MAKE_SHARED(WSEndpoint, _instance, _delegate->connectionId(connectionId), _resource);
+        return make_shared<WSEndpoint>(_instance, _delegate->connectionId(connectionId), _resource);
     }
 }
 
@@ -198,13 +185,13 @@ IceInternal::WSEndpoint::compress() const
 EndpointIPtr
 IceInternal::WSEndpoint::compress(bool compress) const
 {
-    if(compress == _delegate->compress())
+    if (compress == _delegate->compress())
     {
-        return ICE_SHARED_FROM_CONST_THIS(WSEndpoint);
+        return const_cast<WSEndpoint*>(this)->shared_from_this();
     }
     else
     {
-        return ICE_MAKE_SHARED(WSEndpoint, _instance, _delegate->compress(compress), _resource);
+        return make_shared<WSEndpoint>(_instance, _delegate->compress(compress), _resource);
     }
 }
 
@@ -223,134 +210,100 @@ IceInternal::WSEndpoint::secure() const
 TransceiverPtr
 IceInternal::WSEndpoint::transceiver() const
 {
-    return 0;
+    return nullptr;
 }
 
 void
-IceInternal::WSEndpoint::connectors_async(EndpointSelectionType selType,
-                                         const EndpointI_connectorsPtr& callback) const
+IceInternal::WSEndpoint::connectorsAsync(
+    function<void(vector<IceInternal::ConnectorPtr>)> response,
+    function<void(exception_ptr)> exception) const
 {
-    class CallbackI : public EndpointI_connectors
+    string host;
+    IPEndpointInfoPtr info = getIPEndpointInfo(_delegate->getInfo());
+    if (info)
     {
-    public:
-
-        CallbackI(const EndpointI_connectorsPtr& callback, const ProtocolInstancePtr& instance,
-                  const string& host, const string& resource) :
-            _callback(callback), _instance(instance), _host(host), _resource(resource)
-        {
-        }
+        ostringstream os;
+        // Use to_string for locale independent formatting.
+        os << info->host << ":" << to_string(info->port);
+        host = os.str();
+    }
 
-        virtual void connectors(const vector<ConnectorPtr>& c)
+    auto self = const_cast<WSEndpoint*>(this)->shared_from_this();
+    _delegate->connectorsAsync(
+        [response, host, self](vector<ConnectorPtr> connectors)
         {
-            vector<ConnectorPtr> connectors = c;
-            for(vector<ConnectorPtr>::iterator p = connectors.begin(); p != connectors.end(); ++p)
+            for (auto& connector : connectors)
             {
-                *p = new WSConnector(_instance, *p, _host, _resource);
+                connector = make_shared<WSConnector>(self->_instance, connector, host, self->_resource);
             }
-            _callback->connectors(connectors);
-        }
-
-        virtual void exception(const LocalException& ex)
-        {
-            _callback->exception(ex);
-        }
-
-    private:
-
-        const EndpointI_connectorsPtr _callback;
-        const ProtocolInstancePtr _instance;
-        const string _host;
-        const string _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));
+            response(std::move(connectors));
+        },
+        exception);
 }
 
 AcceptorPtr
-IceInternal::WSEndpoint::acceptor(const string& adapterName) const
+IceInternal::WSEndpoint::acceptor(
+    const string& adapterName,
+    const optional<Ice::SSL::ServerAuthenticationOptions>& serverAuthenticationOptions) const
 {
-    AcceptorPtr delAcc = _delegate->acceptor(adapterName);
-    return new WSAcceptor(ICE_SHARED_FROM_CONST_THIS(WSEndpoint), _instance, delAcc);
+    AcceptorPtr acceptor = _delegate->acceptor(adapterName, serverAuthenticationOptions);
+    return make_shared<WSAcceptor>(const_cast<WSEndpoint*>(this)->shared_from_this(), _instance, acceptor);
 }
 
 WSEndpointPtr
 IceInternal::WSEndpoint::endpoint(const EndpointIPtr& delEndp) const
 {
-    if(delEndp.get() == _delegate.get())
+    if (delEndp.get() == _delegate.get())
     {
-        return ICE_DYNAMIC_CAST(WSEndpoint, ICE_SHARED_FROM_CONST_THIS(WSEndpoint));
+        return dynamic_pointer_cast<WSEndpoint>(const_cast<WSEndpoint*>(this)->shared_from_this());
     }
     else
     {
-        return ICE_MAKE_SHARED(WSEndpoint, _instance, delEndp, _resource);
+        return make_shared<WSEndpoint>(_instance, delEndp, _resource);
     }
 }
 
 vector<EndpointIPtr>
-IceInternal::WSEndpoint::expandIfWildcard() const
+IceInternal::WSEndpoint::expandHost() const
 {
-    vector<EndpointIPtr> endps = _delegate->expandIfWildcard();
-    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;
+    vector<EndpointIPtr> endpoints = _delegate->expandHost();
+
+    transform(
+        endpoints.begin(),
+        endpoints.end(),
+        endpoints.begin(),
+        [this](const EndpointIPtr& p) { return endpoint(p); });
+
+    return endpoints;
 }
 
-vector<EndpointIPtr>
-IceInternal::WSEndpoint::expandHost(EndpointIPtr& publish) const
+bool
+IceInternal::WSEndpoint::isLoopbackOrMulticast() 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;
+    return _delegate->isLoopbackOrMulticast();
+}
+
+shared_ptr<EndpointI>
+IceInternal::WSEndpoint::toPublishedEndpoint(string publishedHost) const
+{
+    return endpoint(_delegate->toPublishedEndpoint(std::move(publishedHost)));
 }
 
 bool
 IceInternal::WSEndpoint::equivalent(const EndpointIPtr& endpoint) const
 {
-    const WSEndpoint* wsEndpointI = dynamic_cast<const WSEndpoint*>(endpoint.get());
-    if(!wsEndpointI)
+    auto wsEndpointI = dynamic_pointer_cast<WSEndpoint>(endpoint);
+    if (!wsEndpointI)
     {
         return false;
     }
     return _delegate->equivalent(wsEndpointI->_delegate);
 }
 
-Int
-IceInternal::WSEndpoint::hash() const
+size_t
+IceInternal::WSEndpoint::hash() const noexcept
 {
-    int h = _delegate->hash();
+    size_t h = _delegate->hash();
     hashAdd(h, _resource);
     return h;
 }
@@ -368,16 +321,16 @@ IceInternal::WSEndpoint::options() const
     ostringstream s;
     s << _delegate->options();
 
-    if(!_resource.empty())
+    if (!_resource.empty())
     {
         s << " -r ";
         bool addQuote = _resource.find(':') != string::npos;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
         s << _resource;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
@@ -387,29 +340,25 @@ IceInternal::WSEndpoint::options() const
 }
 
 bool
-#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 auto* p = dynamic_cast<const WSEndpoint*>(&r);
+    if (!p)
     {
         return false;
     }
 
-    if(this == p)
+    if (this == p)
     {
         return true;
     }
 
-    if(!targetEqualTo(_delegate, p->_delegate))
+    if (!targetEqualTo(_delegate, p->_delegate))
     {
         return false;
     }
 
-    if(_resource != p->_resource)
+    if (_resource != p->_resource)
     {
         return false;
     }
@@ -418,29 +367,25 @@ IceInternal::WSEndpoint::operator==(const LocalObject& r) const
 }
 
 bool
-#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 auto* p = dynamic_cast<const WSEndpoint*>(&r);
+    if (!p)
     {
-        const EndpointI* e = dynamic_cast<const EndpointI*>(&r);
-        if(!e)
+        const auto* e = dynamic_cast<const EndpointI*>(&r);
+        if (!e)
         {
             return false;
         }
         return type() < e->type();
     }
 
-    if(this == p)
+    if (this == p)
     {
         return false;
     }
 
-    if(targetLess(_delegate, p->_delegate))
+    if (targetLess(_delegate, p->_delegate))
     {
         return true;
     }
@@ -449,7 +394,7 @@ IceInternal::WSEndpoint::operator<(const LocalObject& r) const
         return false;
     }
 
-    if(_resource < p->_resource)
+    if (_resource < p->_resource)
     {
         return true;
     }
@@ -464,45 +409,47 @@ IceInternal::WSEndpoint::operator<(const LocalObject& r) const
 bool
 IceInternal::WSEndpoint::checkOption(const string& option, const string& argument, const string& endpoint)
 {
-    switch(option[1])
+    switch (option[1])
     {
-    case 'r':
-    {
-        if(argument.empty())
+        case 'r':
         {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for -r option in endpoint " +
-                                         endpoint + _delegate->options());
+            if (argument.empty())
+            {
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "no argument provided for -r option in endpoint '" + endpoint + _delegate->options() + "'");
+            }
+            const_cast<string&>(_resource) = argument;
+            return true;
         }
-        const_cast<string&>(_resource) = argument;
-        return true;
-    }
 
-    default:
-    {
-        return false;
-    }
+        default:
+        {
+            return false;
+        }
     }
 }
 
-IceInternal::WSEndpointFactory::WSEndpointFactory(const ProtocolInstancePtr& instance, Short type) :
-    EndpointFactoryWithUnderlying(instance, type)
+IceInternal::WSEndpointFactory::WSEndpointFactory(const ProtocolInstancePtr& instance, int16_t type)
+    : EndpointFactoryWithUnderlying(instance, type)
 {
 }
 
 EndpointFactoryPtr
-IceInternal::WSEndpointFactory::cloneWithUnderlying(const ProtocolInstancePtr& instance, Short underlying) const
+IceInternal::WSEndpointFactory::cloneWithUnderlying(const ProtocolInstancePtr& instance, int16_t underlying) const
 {
-    return new WSEndpointFactory(instance, underlying);
+    return make_shared<WSEndpointFactory>(instance, underlying);
 }
 
 EndpointIPtr
 IceInternal::WSEndpointFactory::createWithUnderlying(const EndpointIPtr& underlying, vector<string>& args, bool) const
 {
-    return ICE_MAKE_SHARED(WSEndpoint, _instance, underlying, args);
+    return make_shared<WSEndpoint>(_instance, underlying, args);
 }
 
 EndpointIPtr
 IceInternal::WSEndpointFactory::readWithUnderlying(const EndpointIPtr& underlying, InputStream* s) const
 {
-    return ICE_MAKE_SHARED(WSEndpoint, _instance, underlying, s);
+    return make_shared<WSEndpoint>(_instance, underlying, s);
 }