zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,63 +1,87 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Config.h>
+#include "Ice/Config.h"
 
 #if !defined(__APPLE__) || TARGET_OS_IPHONE == 0
 
-#include <Ice/TcpEndpointI.h>
-#include <Ice/Network.h>
-#include <Ice/TcpAcceptor.h>
-#include <Ice/TcpConnector.h>
-#include <Ice/TcpTransceiver.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/LocalException.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/HashUtil.h>
+#    include "HashUtil.h"
+#    include "Ice/InputStream.h"
+#    include "Ice/LocalExceptions.h"
+#    include "Ice/OutputStream.h"
+#    include "Network.h"
+#    include "ProtocolInstance.h"
+#    include "TcpAcceptor.h"
+#    include "TcpConnector.h"
+#    include "TcpEndpointI.h"
+
+#    include "TcpTransceiver.h"
+#    include <utility>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(TcpEndpointI* p) { return p; }
-#endif
-
-extern "C"
+namespace
 {
+    const char* const tcpPluginName = "IceTCP";
+
+    Plugin* createIceTCP(const CommunicatorPtr& c, const string& name, const StringSeq&)
+    {
+        string pluginName{tcpPluginName};
 
-Plugin*
-createIceTCP(const CommunicatorPtr& c, const string&, const StringSeq&)
+        if (name != pluginName)
+        {
+            throw PluginInitializationException{
+                __FILE__,
+                __LINE__,
+                "the TCP plug-in must be named '" + pluginName + "'"};
+        }
+
+        return new EndpointFactoryPlugin(
+            c,
+            make_shared<TcpEndpointFactory>(make_shared<ProtocolInstance>(c, TCPEndpointType, "tcp", false)));
+    }
+}
+
+Ice::PluginFactory
+Ice::tcpPluginFactory()
 {
-    return new EndpointFactoryPlugin(c, new TcpEndpointFactory(new ProtocolInstance(c, TCPEndpointType, "tcp", false)));
+    return {tcpPluginName, createIceTCP};
 }
 
+namespace
+{
+    const int32_t defaultTimeout = 60000; // 60,000 ms.
 }
 
-IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance, const string& host, Int port,
-                                        const Address& sourceAddr, Int timeout, const string& connectionId,
-                                        bool compress) :
-    IPEndpointI(instance, host, port, sourceAddr, connectionId),
-    _timeout(timeout),
-    _compress(compress)
+IceInternal::TcpEndpointI::TcpEndpointI(
+    const ProtocolInstancePtr& instance,
+    const string& host,
+    int32_t port,
+    const Address& sourceAddr,
+    int32_t timeout,
+    const string& connectionId,
+    bool compress)
+    : IPEndpointI(instance, host, port, sourceAddr, connectionId),
+      _timeout(timeout),
+      _compress(compress)
 {
 }
 
-IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance) :
-    IPEndpointI(instance),
-    _timeout(instance->defaultTimeout()),
-    _compress(false)
+IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance)
+    : IPEndpointI(instance),
+      // This timeout is not used in Ice 3.8 and greater.
+      _timeout(defaultTimeout),
+      _compress(false)
 {
 }
 
-IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance, InputStream* s) :
-    IPEndpointI(instance, s),
-    _timeout(-1),
-    _compress(false)
+IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance, InputStream* s)
+    : IPEndpointI(instance, s),
+      _timeout(-1),
+      _compress(false)
 {
-    s->read(const_cast<Int&>(_timeout));
+    s->read(const_cast<int32_t&>(_timeout));
     s->read(const_cast<bool&>(_compress));
 }
 
@@ -70,29 +94,27 @@ IceInternal::TcpEndpointI::streamWriteImpl(OutputStream* s) const
 }
 
 EndpointInfoPtr
-IceInternal::TcpEndpointI::getInfo() const ICE_NOEXCEPT
+IceInternal::TcpEndpointI::getInfo() const noexcept
 {
-    TCPEndpointInfoPtr info = ICE_MAKE_SHARED(InfoI<Ice::TCPEndpointInfo>, ICE_SHARED_FROM_CONST_THIS(TcpEndpointI));
-    fillEndpointInfo(info.get());
-    return info;
+    return make_shared<TCPEndpointInfo>(_compress, _host, _port, inetAddrToString(_sourceAddr), type(), secure());
 }
 
-Int
+int32_t
 IceInternal::TcpEndpointI::timeout() const
 {
     return _timeout;
 }
 
 EndpointIPtr
-IceInternal::TcpEndpointI::timeout(Int timeout) const
+IceInternal::TcpEndpointI::timeout(int32_t timeout) const
 {
-    if(timeout == _timeout)
+    if (timeout == _timeout)
     {
-        return ICE_SHARED_FROM_CONST_THIS(TcpEndpointI);
+        return const_cast<TcpEndpointI*>(this)->shared_from_this();
     }
     else
     {
-        return ICE_MAKE_SHARED(TcpEndpointI, _instance, _host, _port, _sourceAddr, timeout, _connectionId, _compress);
+        return make_shared<TcpEndpointI>(_instance, _host, _port, _sourceAddr, timeout, _connectionId, _compress);
     }
 }
 
@@ -105,13 +127,13 @@ IceInternal::TcpEndpointI::compress() const
 EndpointIPtr
 IceInternal::TcpEndpointI::compress(bool compress) const
 {
-    if(compress == _compress)
+    if (compress == _compress)
     {
-        return ICE_SHARED_FROM_CONST_THIS(TcpEndpointI);
+        return const_cast<TcpEndpointI*>(this)->shared_from_this();
     }
     else
     {
-        return ICE_MAKE_SHARED(TcpEndpointI, _instance, _host, _port, _sourceAddr, _timeout, _connectionId, compress);
+        return make_shared<TcpEndpointI>(_instance, _host, _port, _sourceAddr, _timeout, _connectionId, compress);
     }
 }
 
@@ -121,29 +143,49 @@ IceInternal::TcpEndpointI::datagram() const
     return false;
 }
 
+shared_ptr<EndpointI>
+IceInternal::TcpEndpointI::toPublishedEndpoint(string publishedHost) const
+{
+    // A server endpoint can't have a source address or connection ID.
+    assert(!isAddressValid(_sourceAddr) && _connectionId.empty());
+
+    if (publishedHost.empty())
+    {
+        return const_cast<TcpEndpointI*>(this)->shared_from_this();
+    }
+    else
+    {
+        return make_shared<TcpEndpointI>(_instance, publishedHost, _port, Address{}, _timeout, "", _compress);
+    }
+}
+
 TransceiverPtr
 IceInternal::TcpEndpointI::transceiver() const
 {
-    return ICE_NULLPTR;
+    return nullptr;
 }
 
 AcceptorPtr
-IceInternal::TcpEndpointI::acceptor(const string&) const
+IceInternal::TcpEndpointI::acceptor(const string&, const optional<Ice::SSL::ServerAuthenticationOptions>&) const
 {
-    return new TcpAcceptor(ICE_DYNAMIC_CAST(TcpEndpointI, ICE_SHARED_FROM_CONST_THIS(TcpEndpointI)), _instance, _host, _port);
+    return make_shared<TcpAcceptor>(
+        dynamic_pointer_cast<TcpEndpointI>(const_cast<TcpEndpointI*>(this)->shared_from_this()),
+        _instance,
+        _host,
+        _port);
 }
 
 TcpEndpointIPtr
 IceInternal::TcpEndpointI::endpoint(const TcpAcceptorPtr& acceptor) const
 {
     int port = acceptor->effectivePort();
-    if(_port == port)
+    if (_port == port)
     {
-        return ICE_DYNAMIC_CAST(TcpEndpointI, ICE_SHARED_FROM_CONST_THIS(TcpEndpointI));
+        return dynamic_pointer_cast<TcpEndpointI>(const_cast<TcpEndpointI*>(this)->shared_from_this());
     }
     else
     {
-        return ICE_MAKE_SHARED(TcpEndpointI, _instance, _host, port, _sourceAddr, _timeout, _connectionId, _compress);
+        return make_shared<TcpEndpointI>(_instance, _host, port, _sourceAddr, _timeout, _connectionId, _compress);
     }
 }
 
@@ -158,19 +200,22 @@ IceInternal::TcpEndpointI::options() const
     // format of proxyToString() before changing this and related code.
     //
     ostringstream s;
-
     s << IPEndpointI::options();
 
-    if(_timeout == -1)
-    {
-        s << " -t infinite";
-    }
-    else
+    // -t is totally ignored by Ice as of Ice 3.8. To avoid confusion, we don't output it when set to the default value.
+    if (_timeout != defaultTimeout)
     {
-        s << " -t " << _timeout;
+        if (_timeout == -1)
+        {
+            s << " -t infinite";
+        }
+        else
+        {
+            s << " -t " << to_string(_timeout);
+        }
     }
 
-    if(_compress)
+    if (_compress)
     {
         s << " -z";
     }
@@ -179,34 +224,30 @@ IceInternal::TcpEndpointI::options() const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::TcpEndpointI::operator==(const Endpoint& r) const
-#else
-IceInternal::TcpEndpointI::operator==(const LocalObject& r) const
-#endif
 {
-    if(!IPEndpointI::operator==(r))
+    if (!IPEndpointI::operator==(r))
     {
         return false;
     }
 
-    const TcpEndpointI* p = dynamic_cast<const TcpEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const TcpEndpointI*>(&r);
+    if (!p)
     {
         return false;
     }
 
-    if(this == p)
+    if (this == p)
     {
         return true;
     }
 
-    if(_timeout != p->_timeout)
+    if (_timeout != p->_timeout)
     {
         return false;
     }
 
-    if(_compress != p->_compress)
+    if (_compress != p->_compress)
     {
         return false;
     }
@@ -214,42 +255,38 @@ IceInternal::TcpEndpointI::operator==(const LocalObject& r) const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::TcpEndpointI::operator<(const Endpoint& r) const
-#else
-IceInternal::TcpEndpointI::operator<(const LocalObject& r) const
-#endif
 {
-    const TcpEndpointI* p = dynamic_cast<const TcpEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const TcpEndpointI*>(&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(_timeout < p->_timeout)
+    if (_timeout < p->_timeout)
     {
         return true;
     }
-    else if(p->_timeout < _timeout)
+    else if (p->_timeout < _timeout)
     {
         return false;
     }
 
-    if(!_compress && p->_compress)
+    if (!_compress && p->_compress)
     {
         return true;
     }
-    else if(p->_compress < _compress)
+    else if (p->_compress < _compress)
     {
         return false;
     }
@@ -257,95 +294,90 @@ IceInternal::TcpEndpointI::operator<(const LocalObject& r) const
     return IPEndpointI::operator<(r);
 }
 
-void
-IceInternal::TcpEndpointI::hashInit(Ice::Int& h) const
+size_t
+IceInternal::TcpEndpointI::hash() const noexcept
 {
-    IPEndpointI::hashInit(h);
+    size_t h = IPEndpointI::hash();
     hashAdd(h, _timeout);
     hashAdd(h, _compress);
-}
-
-void
-IceInternal::TcpEndpointI::fillEndpointInfo(IPEndpointInfo* info) const
-{
-    IPEndpointI::fillEndpointInfo(info);
-    info->timeout = _timeout;
-    info->compress = _compress;
+    return h;
 }
 
 bool
 IceInternal::TcpEndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
 {
-    if(IPEndpointI::checkOption(option, argument, endpoint))
+    if (IPEndpointI::checkOption(option, argument, endpoint))
     {
         return true;
     }
 
-    switch(option[1])
-    {
-    case 't':
+    switch (option[1])
     {
-        if(argument.empty())
+        case 't':
         {
-            throw EndpointParseException(__FILE__, __LINE__, "no argument provided for -t option in endpoint " +
-                                         endpoint);
-        }
+            if (argument.empty())
+            {
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "no argument provided for -t option in endpoint '" + endpoint + "'");
+            }
 
-        if(argument == "infinite")
-        {
-            const_cast<Int&>(_timeout) = -1;
+            if (argument == "infinite")
+            {
+                const_cast<int32_t&>(_timeout) = -1;
+            }
+            else
+            {
+                istringstream t(argument);
+                if (!(t >> const_cast<int32_t&>(_timeout)) || !t.eof() || _timeout < 1)
+                {
+                    throw ParseException(
+                        __FILE__,
+                        __LINE__,
+                        "invalid timeout value '" + argument + "' in endpoint '" + endpoint + "'");
+                }
+            }
+            return true;
         }
-        else
+
+        case 'z':
         {
-            istringstream t(argument);
-            if(!(t >> const_cast<Int&>(_timeout)) || !t.eof() || _timeout < 1)
+            if (!argument.empty())
             {
-                throw EndpointParseException(__FILE__, __LINE__, "invalid timeout value `" + argument +
-                                             "' in endpoint " + endpoint);
+                throw ParseException(
+                    __FILE__,
+                    __LINE__,
+                    "unexpected argument '" + argument + "' provided for -z option in endpoint '" + endpoint + "'");
             }
+            const_cast<bool&>(_compress) = true;
+            return true;
         }
-        return true;
-    }
 
-    case 'z':
-    {
-        if(!argument.empty())
+        default:
         {
-            throw EndpointParseException(__FILE__, __LINE__, "unexpected argument `" + argument +
-                                         "' provided for -z option in " + endpoint);
+            return false;
         }
-        const_cast<bool&>(_compress) = true;
-        return true;
-    }
-
-    default:
-    {
-        return false;
-    }
     }
 }
 
 ConnectorPtr
 IceInternal::TcpEndpointI::createConnector(const Address& address, const NetworkProxyPtr& proxy) const
 {
-    return new TcpConnector(_instance, address, proxy, _sourceAddr, _timeout, _connectionId);
+    return make_shared<TcpConnector>(_instance, address, proxy, _sourceAddr, _timeout, _connectionId);
 }
 
 IPEndpointIPtr
 IceInternal::TcpEndpointI::createEndpoint(const string& host, int port, const string& connectionId) const
 {
-    return ICE_MAKE_SHARED(TcpEndpointI, _instance, host, port, _sourceAddr, _timeout, connectionId, _compress);
+    return make_shared<TcpEndpointI>(_instance, host, port, _sourceAddr, _timeout, connectionId, _compress);
 }
 
-IceInternal::TcpEndpointFactory::TcpEndpointFactory(const ProtocolInstancePtr& instance) : _instance(instance)
-{
-}
+IceInternal::TcpEndpointFactory::TcpEndpointFactory(ProtocolInstancePtr instance) : _instance(std::move(instance)) {}
 
-IceInternal::TcpEndpointFactory::~TcpEndpointFactory()
-{
-}
+IceInternal::TcpEndpointFactory::~TcpEndpointFactory() = default;
 
-Short
+int16_t
 IceInternal::TcpEndpointFactory::type() const
 {
     return _instance->type();
@@ -360,7 +392,7 @@ IceInternal::TcpEndpointFactory::protocol() const
 EndpointIPtr
 IceInternal::TcpEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
 {
-    IPEndpointIPtr endpt = ICE_MAKE_SHARED(TcpEndpointI, _instance);
+    IPEndpointIPtr endpt = make_shared<TcpEndpointI>(_instance);
     endpt->initWithOptions(args, oaEndpoint);
     return endpt;
 }
@@ -368,18 +400,12 @@ IceInternal::TcpEndpointFactory::create(vector<string>& args, bool oaEndpoint) c
 EndpointIPtr
 IceInternal::TcpEndpointFactory::read(InputStream* s) const
 {
-    return ICE_MAKE_SHARED(TcpEndpointI, _instance, s);
-}
-
-void
-IceInternal::TcpEndpointFactory::destroy()
-{
-    _instance = 0;
+    return make_shared<TcpEndpointI>(_instance, s);
 }
 
 EndpointFactoryPtr
 IceInternal::TcpEndpointFactory::clone(const ProtocolInstancePtr& instance) const
 {
-    return new TcpEndpointFactory(instance);
+    return make_shared<TcpEndpointFactory>(instance);
 }
 #endif