zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,93 +1,84 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/UdpEndpointI.h>
-#include <Ice/Network.h>
-#include <Ice/UdpConnector.h>
-#include <Ice/UdpTransceiver.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/LocalException.h>
-#include <Ice/Protocol.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/HashUtil.h>
-#include <Ice/Logger.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "UdpEndpointI.h"
+#include "HashUtil.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Logger.h"
+#include "Ice/OutputStream.h"
+#include "Network.h"
+#include "ProtocolInstance.h"
+#include "UdpConnector.h"
+#include "UdpTransceiver.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(UdpEndpointI* p) { return p; }
-#endif
-
-extern "C"
-{
-
-Plugin*
-createIceUDP(const CommunicatorPtr& c, const string&, const StringSeq&)
+namespace
 {
-    return new EndpointFactoryPlugin(c, new UdpEndpointFactory(new ProtocolInstance(c, UDPEndpointType, "udp", false)));
-}
+    const char* const udpPluginName = "IceUDP";
 
-}
-
-namespace Ice
-{
+    Plugin* createIceUDP(const CommunicatorPtr& c, const string& name, const StringSeq&)
+    {
+        string pluginName{udpPluginName};
 
-ICE_API void
-registerIceUDP(bool loadOnInitialize)
-{
-    Ice::registerPluginFactory("IceUDP", createIceUDP, loadOnInitialize);
-}
+        if (name != pluginName)
+        {
+            throw PluginInitializationException{
+                __FILE__,
+                __LINE__,
+                "the UDP plug-in must be named '" + pluginName + "'"};
+        }
 
+        return new EndpointFactoryPlugin(
+            c,
+            make_shared<UdpEndpointFactory>(make_shared<ProtocolInstance>(c, UDPEndpointType, "udp", false)));
+    }
 }
 
-//
-// Objective-C function to allow Objective-C programs to register plugin.
-//
-extern "C" ICE_API void
-ICEregisterIceUDP(bool loadOnInitialize)
+Ice::PluginFactory
+Ice::udpPluginFactory()
 {
-    Ice::registerIceUDP(loadOnInitialize);
+    return {udpPluginName, createIceUDP};
 }
 
-IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, const string& host, Int port,
-                                        const Address& sourceAddr, const string& mcastInterface, Int mttl, bool conn,
-                                        const string& conId, bool co) :
-    IPEndpointI(instance, host, port, sourceAddr, conId),
-    _mcastTtl(mttl),
-    _mcastInterface(mcastInterface),
-    _connect(conn),
-    _compress(co)
+IceInternal::UdpEndpointI::UdpEndpointI(
+    const ProtocolInstancePtr& instance,
+    const string& host,
+    int32_t port,
+    const Address& sourceAddr,
+    string mcastInterface,
+    int32_t mttl,
+    const string& connectionId,
+    bool compress)
+    : IPEndpointI(instance, host, port, sourceAddr, connectionId),
+      _mcastTtl(mttl),
+      _mcastInterface(std::move(mcastInterface)),
+      _compress(compress)
 {
 }
 
-IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance) :
-    IPEndpointI(instance),
-    _mcastTtl(-1),
-    _connect(false),
-    _compress(false)
+IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance)
+    : IPEndpointI(instance),
+      _mcastTtl(-1),
+      _compress(false)
 {
 }
 
-IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, InputStream* s) :
-    IPEndpointI(instance, s),
-    _mcastTtl(-1),
-    _connect(false),
-    _compress(false)
+IceInternal::UdpEndpointI::UdpEndpointI(const ProtocolInstancePtr& instance, InputStream* s)
+    : IPEndpointI(instance, s),
+      _mcastTtl(-1),
+      _compress(false)
 {
-    if(s->getEncoding() == Ice::Encoding_1_0)
+    if (s->getEncoding() == Ice::Encoding_1_0)
     {
-        Ice::Byte b;
+        uint8_t b;
         s->read(b);
         s->read(b);
         s->read(b);
         s->read(b);
     }
-    // Not transmitted.
-    //s->read(const_cast<bool&>(_connect));
     s->read(const_cast<bool&>(_compress));
 }
 
@@ -95,35 +86,36 @@ void
 IceInternal::UdpEndpointI::streamWriteImpl(OutputStream* s) const
 {
     IPEndpointI::streamWriteImpl(s);
-    if(s->getEncoding() == Ice::Encoding_1_0)
+    if (s->getEncoding() == Ice::Encoding_1_0)
     {
-        s->write(Ice::Protocol_1_0);
+        s->write(Protocol_1_0);
         s->write(Ice::Encoding_1_0);
     }
-    // Not transmitted.
-    //s->write(_connect);
     s->write(_compress);
 }
 
 EndpointInfoPtr
-IceInternal::UdpEndpointI::getInfo() const ICE_NOEXCEPT
+IceInternal::UdpEndpointI::getInfo() const noexcept
 {
-    Ice::UDPEndpointInfoPtr info = ICE_MAKE_SHARED(InfoI<Ice::UDPEndpointInfo>,
-                                                   ICE_DYNAMIC_CAST(UdpEndpointI, ICE_SHARED_FROM_CONST_THIS(UdpEndpointI)));
-    fillEndpointInfo(info.get());
-    return info;
+    return make_shared<UDPEndpointInfo>(
+        _compress,
+        _host,
+        _port,
+        inetAddrToString(_sourceAddr),
+        _mcastInterface,
+        _mcastTtl);
 }
 
-Int
+int32_t
 IceInternal::UdpEndpointI::timeout() const
 {
     return -1;
 }
 
 EndpointIPtr
-IceInternal::UdpEndpointI::timeout(Int) const
+IceInternal::UdpEndpointI::timeout(int32_t) const
 {
-    return ICE_SHARED_FROM_CONST_THIS(UdpEndpointI);
+    return const_cast<UdpEndpointI*>(this)->shared_from_this();
 }
 
 bool
@@ -135,14 +127,14 @@ IceInternal::UdpEndpointI::compress() const
 EndpointIPtr
 IceInternal::UdpEndpointI::compress(bool compress) const
 {
-    if(compress == _compress)
+    if (compress == _compress)
     {
-        return ICE_SHARED_FROM_CONST_THIS(UdpEndpointI);
+        return const_cast<UdpEndpointI*>(this)->shared_from_this();
     }
     else
     {
-        return ICE_MAKE_SHARED(UdpEndpointI, _instance, _host, _port, _sourceAddr, _mcastInterface, _mcastTtl,
-                               _connect, _connectionId, compress);
+        return make_shared<
+            UdpEndpointI>(_instance, _host, _port, _sourceAddr, _mcastInterface, _mcastTtl, _connectionId, compress);
     }
 }
 
@@ -152,31 +144,49 @@ IceInternal::UdpEndpointI::datagram() const
     return true;
 }
 
+shared_ptr<EndpointI>
+IceInternal::UdpEndpointI::toPublishedEndpoint(string publishedHost) const
+{
+    return make_shared<UdpEndpointI>(
+        _instance,
+        publishedHost.empty() ? _host : publishedHost,
+        _port,
+        Address{},
+        "",
+        -1,
+        "",
+        _compress);
+}
+
 TransceiverPtr
 IceInternal::UdpEndpointI::transceiver() const
 {
-    return new UdpTransceiver(ICE_DYNAMIC_CAST(UdpEndpointI, ICE_SHARED_FROM_CONST_THIS(UdpEndpointI)), _instance,
-                              _host, _port, _mcastInterface, _connect);
+    return make_shared<UdpTransceiver>(
+        dynamic_pointer_cast<UdpEndpointI>(const_cast<UdpEndpointI*>(this)->shared_from_this()),
+        _instance,
+        _host,
+        _port,
+        _mcastInterface);
 }
 
 AcceptorPtr
-IceInternal::UdpEndpointI::acceptor(const string&) const
+IceInternal::UdpEndpointI::acceptor(const string&, const optional<Ice::SSL::ServerAuthenticationOptions>&) const
 {
-    return 0;
+    return nullptr;
 }
 
 UdpEndpointIPtr
 IceInternal::UdpEndpointI::endpoint(const UdpTransceiverPtr& transceiver) const
 {
     int port = transceiver->effectivePort();
-    if(port == _port)
+    if (port == _port)
     {
-        return ICE_DYNAMIC_CAST(UdpEndpointI, ICE_SHARED_FROM_CONST_THIS(UdpEndpointI));
+        return dynamic_pointer_cast<UdpEndpointI>(const_cast<UdpEndpointI*>(this)->shared_from_this());
     }
     else
     {
-        return ICE_MAKE_SHARED(UdpEndpointI, _instance, _host, port, _sourceAddr, _mcastInterface,_mcastTtl, _connect,
-                               _connectionId, _compress);
+        return make_shared<
+            UdpEndpointI>(_instance, _host, port, _sourceAddr, _mcastInterface, _mcastTtl, _connectionId, _compress);
     }
 }
 
@@ -185,16 +195,18 @@ IceInternal::UdpEndpointI::initWithOptions(vector<string>& args, bool oaEndpoint
 {
     IPEndpointI::initWithOptions(args, oaEndpoint);
 
-    if(_mcastInterface == "*")
+    if (_mcastInterface == "*")
     {
-        if(oaEndpoint)
+        if (oaEndpoint)
         {
             const_cast<string&>(_mcastInterface) = string();
         }
         else
         {
-            throw EndpointParseException(__FILE__, __LINE__, "`--interface *' not valid for proxy endpoint `" +
-                                         toString() + "'");
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "'--interface *' not valid for proxy endpoint '" + toString() + "'");
         }
     }
 }
@@ -212,32 +224,28 @@ IceInternal::UdpEndpointI::options() const
     ostringstream s;
     s << IPEndpointI::options();
 
-    if(_mcastInterface.length() > 0)
+    if (_mcastInterface.length() > 0)
     {
         s << " --interface ";
         bool addQuote = _mcastInterface.find(':') != string::npos;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
         s << _mcastInterface;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
     }
 
-    if(_mcastTtl != -1)
-    {
-        s << " --ttl " << _mcastTtl;
-    }
-
-    if(_connect)
+    if (_mcastTtl != -1)
     {
-        s << " -c";
+        // Use to_string for locale independent formatting.
+        s << " --ttl " << to_string(_mcastTtl);
     }
 
-    if(_compress)
+    if (_compress)
     {
         s << " -z";
     }
@@ -246,44 +254,35 @@ IceInternal::UdpEndpointI::options() const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::UdpEndpointI::operator==(const Endpoint& r) const
-#else
-IceInternal::UdpEndpointI::operator==(const LocalObject& r) const
-#endif
 {
-    if(!IPEndpointI::operator==(r))
+    if (!IPEndpointI::operator==(r))
     {
         return false;
     }
 
-    const UdpEndpointI* p = dynamic_cast<const UdpEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const UdpEndpointI*>(&r);
+    if (!p)
     {
         return false;
     }
 
-    if(this == p)
+    if (this == p)
     {
         return true;
     }
 
-    if(_compress != p->_compress)
+    if (_compress != p->_compress)
     {
         return false;
     }
 
-    if(_connect != p->_connect)
+    if (_mcastTtl != p->_mcastTtl)
     {
         return false;
     }
 
-    if(_mcastTtl != p->_mcastTtl)
-    {
-        return false;
-    }
-
-    if(_mcastInterface != p->_mcastInterface)
+    if (_mcastInterface != p->_mcastInterface)
     {
         return false;
     }
@@ -292,60 +291,47 @@ IceInternal::UdpEndpointI::operator==(const LocalObject& r) const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::UdpEndpointI::operator<(const Endpoint& r) const
-#else
-IceInternal::UdpEndpointI::operator<(const LocalObject& r) const
-#endif
 {
-    const UdpEndpointI* p = dynamic_cast<const UdpEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const UdpEndpointI*>(&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(!_compress && p->_compress)
+    if (!_compress && p->_compress)
     {
         return true;
     }
-    else if(p->_compress < _compress)
+    else if (p->_compress < _compress)
     {
         return false;
     }
 
-    if(!_connect && p->_connect)
+    if (_mcastTtl < p->_mcastTtl)
     {
         return true;
     }
-    else if(!p->_connect && _connect)
+    else if (p->_mcastTtl < _mcastTtl)
     {
         return false;
     }
 
-    if(_mcastTtl < p->_mcastTtl)
+    if (_mcastInterface < p->_mcastInterface)
     {
         return true;
     }
-    else if(p->_mcastTtl < _mcastTtl)
-    {
-        return false;
-    }
-
-    if(_mcastInterface < p->_mcastInterface)
-    {
-        return true;
-    }
-    else if(p->_mcastInterface < _mcastInterface)
+    else if (p->_mcastInterface < _mcastInterface)
     {
         return false;
     }
@@ -353,99 +339,88 @@ IceInternal::UdpEndpointI::operator<(const LocalObject& r) const
     return IPEndpointI::operator<(r);
 }
 
-void
-IceInternal::UdpEndpointI::hashInit(Ice::Int& h) const
+size_t
+IceInternal::UdpEndpointI::hash() const noexcept
 {
-    IPEndpointI::hashInit(h);
+    size_t h = IPEndpointI::hash();
     hashAdd(h, _mcastInterface);
     hashAdd(h, _mcastTtl);
-    hashAdd(h, _connect);
     hashAdd(h, _compress);
-}
-
-void
-IceInternal::UdpEndpointI::fillEndpointInfo(IPEndpointInfo* info) const
-{
-    IPEndpointI::fillEndpointInfo(info);
-    UDPEndpointInfo* udpInfo = dynamic_cast<UDPEndpointInfo*>(info);
-    if(udpInfo)
-    {
-        udpInfo->timeout = -1;
-        udpInfo->compress = _compress;
-        udpInfo->mcastTtl = _mcastTtl;
-        udpInfo->mcastInterface = _mcastInterface;
-    }
+    return h;
 }
 
 bool
 IceInternal::UdpEndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
 {
-    if(IPEndpointI::checkOption(option, argument, endpoint))
+    if (IPEndpointI::checkOption(option, argument, endpoint))
     {
         return true;
     }
 
-    if(option == "-c")
+    if (option == "-z")
     {
-        if(!argument.empty())
+        if (!argument.empty())
         {
-            throw EndpointParseException(__FILE__, __LINE__,  "unexpected argument `" + argument +
-                                         "' provided for -c option in " + endpoint);
-        }
-        const_cast<bool&>(_connect) = true;
-    }
-    else if(option == "-z")
-    {
-        if(!argument.empty())
-        {
-            throw EndpointParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                         "' provided for -z option in " + endpoint);
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "unexpected argument '" + argument + "' provided for -z option in endpoint '" + endpoint + "'");
         }
         const_cast<bool&>(_compress) = true;
     }
-    else if(option == "-v" || option == "-e")
+    else if (option == "-v" || option == "-e")
     {
-        if(argument.empty())
+        if (argument.empty())
         {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for " + option +
-                                         " option in endpoint " + endpoint);
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "no argument provided for " + option + " option in endpoint '" + endpoint + "'");
         }
         try
         {
-            Ice::Byte major, minor;
+            uint8_t major, minor;
             IceInternal::stringToMajorMinor(argument, major, minor);
-            if(major != 1 || minor != 0)
+            if (major != 1 || minor != 0)
             {
                 _instance->logger()->warning("deprecated udp endpoint option: " + option);
             }
         }
-        catch(const VersionParseException& ex)
+        catch (const ParseException& ex)
         {
-            throw EndpointParseException(__FILE__, __LINE__, "invalid version `" + argument + "' in endpoint " +
-                                         endpoint + ":\n" + ex.str);
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "invalid version '" + argument + "' in endpoint '" + endpoint + "':\n" + ex.what());
         }
     }
-    else if(option == "--interface")
+    else if (option == "--interface")
     {
-        if(argument.empty())
+        if (argument.empty())
         {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for --interface option in endpoint "
-                                         + endpoint);
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "no argument provided for --interface option in endpoint '" + endpoint + "'");
         }
         const_cast<string&>(_mcastInterface) = argument;
     }
-    else if(option == "--ttl")
+    else if (option == "--ttl")
     {
-        if(argument.empty())
+        if (argument.empty())
         {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for --ttl option in endpoint " +
-                                         endpoint);
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "no argument provided for --ttl option in endpoint '" + endpoint + "'");
         }
         istringstream p(argument);
-        if(!(p >> const_cast<Int&>(_mcastTtl)) || !p.eof())
+        if (!(p >> const_cast<int32_t&>(_mcastTtl)) || !p.eof())
         {
-            throw EndpointParseException(__FILE__, __LINE__, "invalid TTL value `" + argument + "' in endpoint " +
-                                         endpoint);
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "invalid TTL value '" + argument + "' in endpoint '" + endpoint + "'");
         }
     }
     else
@@ -458,25 +433,21 @@ IceInternal::UdpEndpointI::checkOption(const string& option, const string& argum
 ConnectorPtr
 IceInternal::UdpEndpointI::createConnector(const Address& address, const NetworkProxyPtr&) const
 {
-    return new UdpConnector(_instance, address, _sourceAddr, _mcastInterface, _mcastTtl, _connectionId);
+    return make_shared<UdpConnector>(_instance, address, _sourceAddr, _mcastInterface, _mcastTtl, _connectionId);
 }
 
 IPEndpointIPtr
 IceInternal::UdpEndpointI::createEndpoint(const string& host, int port, const string& connectionId) const
 {
-    return ICE_MAKE_SHARED(UdpEndpointI, _instance, host, port, _sourceAddr, _mcastInterface, _mcastTtl, _connect,
-                           connectionId, _compress);
+    return make_shared<
+        UdpEndpointI>(_instance, host, port, _sourceAddr, _mcastInterface, _mcastTtl, connectionId, _compress);
 }
 
-IceInternal::UdpEndpointFactory::UdpEndpointFactory(const ProtocolInstancePtr& instance) : _instance(instance)
-{
-}
+IceInternal::UdpEndpointFactory::UdpEndpointFactory(ProtocolInstancePtr instance) : _instance(std::move(instance)) {}
 
-IceInternal::UdpEndpointFactory::~UdpEndpointFactory()
-{
-}
+IceInternal::UdpEndpointFactory::~UdpEndpointFactory() = default;
 
-Short
+int16_t
 IceInternal::UdpEndpointFactory::type() const
 {
     return _instance->type();
@@ -491,7 +462,7 @@ IceInternal::UdpEndpointFactory::protocol() const
 EndpointIPtr
 IceInternal::UdpEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
 {
-    IPEndpointIPtr endpt = ICE_MAKE_SHARED(UdpEndpointI, _instance);
+    auto endpt = make_shared<UdpEndpointI>(_instance);
     endpt->initWithOptions(args, oaEndpoint);
     return endpt;
 }
@@ -499,17 +470,11 @@ IceInternal::UdpEndpointFactory::create(vector<string>& args, bool oaEndpoint) c
 EndpointIPtr
 IceInternal::UdpEndpointFactory::read(InputStream* s) const
 {
-    return ICE_MAKE_SHARED(UdpEndpointI, _instance, s);
-}
-
-void
-IceInternal::UdpEndpointFactory::destroy()
-{
-    _instance = 0;
+    return make_shared<UdpEndpointI>(_instance, s);
 }
 
 EndpointFactoryPtr
 IceInternal::UdpEndpointFactory::clone(const ProtocolInstancePtr& instance) const
 {
-    return new UdpEndpointFactory(instance);
+    return make_shared<UdpEndpointFactory>(instance);
 }