zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/IceSSL/CertificateI.h

@@ -0,0 +1,69 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#ifndef ICESSL_CERTIFICATE_I_H
+#define ICESSL_CERTIFICATE_I_H
+
+#include <IceSSL/Plugin.h>
+
+#include <vector>
+#include <string>
+
+namespace IceSSL
+{
+
+//
+// Map a certificate OID to its alias
+//
+struct ICESSL_API CertificateOID
+{
+    const char* name;
+    const char* alias;
+};
+
+extern const ICESSL_API CertificateOID certificateOIDS[];
+extern const ICESSL_API int certificateOIDSSize;
+
+//
+// Certificate common implementation
+//
+class ICESSL_API CertificateI : public virtual IceSSL::Certificate
+{
+public:
+
+    virtual bool operator!=(const IceSSL::Certificate&) const;
+
+    virtual std::vector<X509ExtensionPtr> getX509Extensions() const;
+    virtual X509ExtensionPtr getX509Extension(const std::string&) const;
+
+    virtual bool checkValidity() const;
+#  ifdef ICE_CPP11_MAPPING
+    virtual bool checkValidity(const std::chrono::system_clock::time_point& now) const;
+#  else
+    virtual bool checkValidity(const IceUtil::Time& now) const;
+#  endif
+
+    virtual std::string toString() const;
+
+protected:
+
+    //
+    // Implementations that support retrieving X509 extensions must
+    // reimplement this method to lazzy initialize the extensions
+    // list.
+    //
+    // The default implementation just throw FeatureNotSupportedException
+    //
+    virtual void loadX509Extensions() const;
+    mutable std::vector<X509ExtensionPtr> _extensions;
+};
+
+} // IceSSL namespace end
+
+#endif

data/ext/ice/cpp/src/IceSSL/ConnectionInfo.cpp

@@ -1,13 +1,13 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -18,33 +18,61 @@
 // </auto-generated>
 //
 
-#ifndef ICE_SSL_API_EXPORTS
-#   define ICE_SSL_API_EXPORTS
+#ifndef ICESSL_API_EXPORTS
+#   define ICESSL_API_EXPORTS
 #endif
 #include <IceSSL/ConnectionInfo.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 > 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
 }
 
-ICE_SSL_API ::Ice::LocalObject* IceSSL::upCast(::IceSSL::ConnectionInfo* p) { return p; }
+IceSSL::ConnectionInfo::~ConnectionInfo()
+{
+}
+
+#else // C++98 mapping
 
-ICE_SSL_API ::Ice::LocalObject* IceSSL::upCast(::IceSSL::WSSConnectionInfo* p) { return p; }
+namespace
+{
+
+}
+
+IceSSL::ConnectionInfo::~ConnectionInfo()
+{
+}
+
+ICESSL_API ::Ice::LocalObject* IceSSL::upCast(::IceSSL::ConnectionInfo* p) { return p; }
+
+namespace Ice
+{
+}
+
+#endif

data/ext/ice/cpp/src/{Ice/ObjectFactoryF.cpp → IceSSL/ConnectionInfoF.cpp}

@@ -1,44 +1,66 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
-// Generated from file `ObjectFactoryF.ice'
+// Generated from file `ConnectionInfoF.ice'
 //
 // Warning: do not edit this file.
 //
 // </auto-generated>
 //
 
-#ifndef ICE_API_EXPORTS
-#   define ICE_API_EXPORTS
+#ifndef ICESSL_API_EXPORTS
+#   define ICESSL_API_EXPORTS
 #endif
-#include <Ice/ObjectFactoryF.h>
+#include <IceSSL/ConnectionInfoF.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <IceUtil/Iterator.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
 #   if ICE_INT_VERSION % 100 > 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+namespace
+{
+
+}
+
+#else // C++98 mapping
+
 namespace
 {
 
 }
+
+namespace Ice
+{
+}
+
+#endif

data/ext/ice/cpp/src/IceSSL/ConnectorI.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,12 +10,9 @@
 #include <IceSSL/ConnectorI.h>
 #include <IceSSL/Instance.h>
 
-#include <IceSSL/OpenSSLTransceiverI.h>
-#include <IceSSL/SecureTransportTransceiverI.h>
-#include <IceSSL/SChannelTransceiverI.h>
-
 #include <IceSSL/EndpointI.h>
 #include <IceSSL/Util.h>
+#include <IceSSL/SSLEngine.h>
 #include <Ice/Communicator.h>
 #include <Ice/LocalException.h>
 #include <Ice/StreamSocket.h>
@@ -39,20 +36,19 @@ IceSSL::ConnectorI::connect()
         throw ex;
     }
 
-    IceInternal::StreamSocketPtr stream = new IceInternal::StreamSocket(_instance, _proxy, _addr, _sourceAddr);
-    return new TransceiverI(_instance, stream, _host, false);
+    return _instance->engine()->createTransceiver(_instance, _delegate->connect(), _host, false);
 }
 
 Short
 IceSSL::ConnectorI::type() const
 {
-    return _instance->type();
+    return _delegate->type();
 }
 
 string
 IceSSL::ConnectorI::toString() const
 {
-    return IceInternal::addrToString(!_proxy ? _addr : _proxy->getAddress());
+    return _delegate->toString();
 }
 
 bool
@@ -64,22 +60,12 @@ IceSSL::ConnectorI::operator==(const IceInternal::Connector& r) const
         return false;
     }
 
-    if(IceInternal::compareAddress(_addr, p->_addr) != 0)
+    if(this == p)
     {
-        return false;
-    }
-
-    if(_timeout != p->_timeout)
-    {
-        return false;
-    }
-
-    if(IceInternal::compareAddress(_sourceAddr, p->_sourceAddr) != 0)
-    {
-        return false;
+        return true;
     }
 
-    if(_connectionId != p->_connectionId)
+    if(_delegate != p->_delegate)
     {
         return false;
     }
@@ -87,12 +73,6 @@ IceSSL::ConnectorI::operator==(const IceInternal::Connector& r) const
     return true;
 }
 
-bool
-IceSSL::ConnectorI::operator!=(const IceInternal::Connector& r) const
-{
-    return !operator==(r);
-}
-
 bool
 IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
 {
@@ -102,47 +82,25 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
         return type() < r.type();
     }
 
-    if(_timeout < p->_timeout)
-    {
-        return true;
-    }
-    else if(p->_timeout < _timeout)
-    {
-        return false;
-    }
-
-    int rc = compareAddress(_sourceAddr, p->_sourceAddr);
-    if(rc < 0)
-    {
-        return true;
-    }
-    else if(rc > 0)
+    if(this == p)
     {
         return false;
     }
 
-    if(_connectionId < p->_connectionId)
+    if(_delegate < p->_delegate)
     {
         return true;
     }
-    else if(p->_connectionId < _connectionId)
+    else if(p->_delegate < _delegate)
     {
         return false;
     }
 
-    return IceInternal::compareAddress(_addr, p->_addr) == -1;
+    return false;
 }
 
-IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const string& host, const IceInternal::Address& addr,
-                               const IceInternal::NetworkProxyPtr& proxy, const IceInternal::Address& sourceAddr,
-                               Ice::Int timeout, const string& connectionId) :
-    _instance(instance),
-    _host(host),
-    _addr(addr),
-    _proxy(proxy),
-    _sourceAddr(sourceAddr),
-    _timeout(timeout),
-    _connectionId(connectionId)
+IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const IceInternal::ConnectorPtr& del, const string& h) :
+    _instance(instance), _delegate(del), _host(h)
 {
 }
 

data/ext/ice/cpp/src/IceSSL/ConnectorI.h

@@ -1,14 +1,14 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
-#ifndef ICE_SSL_CONNECTOR_I_H
-#define ICE_SSL_CONNECTOR_I_H
+#ifndef ICESSL_CONNECTOR_I_H
+#define ICESSL_CONNECTOR_I_H
 
 #include <Ice/TransceiverF.h>
 #include <Ice/Connector.h>
@@ -31,26 +31,19 @@ public:
     virtual std::string toString() const;
 
     virtual bool operator==(const IceInternal::Connector&) const;
-    virtual bool operator!=(const IceInternal::Connector&) const;
     virtual bool operator<(const IceInternal::Connector&) const;
 
 private:
 
-    ConnectorI(const InstancePtr&, const std::string&, const IceInternal::Address&,
-               const IceInternal::NetworkProxyPtr&, const IceInternal::Address&,
-               Ice::Int, const std::string&);
+    ConnectorI(const InstancePtr&, const IceInternal::ConnectorPtr&, const std::string&);
     virtual ~ConnectorI();
     friend class EndpointI;
 
     const InstancePtr _instance;
+    const IceInternal::ConnectorPtr _delegate;
     const std::string _host;
-    const IceInternal::Address _addr;
-    const IceInternal::NetworkProxyPtr _proxy;
-    const IceInternal::Address _sourceAddr;
-    const Ice::Int _timeout;
-    const std::string _connectionId;
 };
 
-}
+} // IceSSL namespace end
 
 #endif

data/ext/ice/cpp/src/IceSSL/EndpointI.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.
@@ -11,104 +11,141 @@
 #include <IceSSL/AcceptorI.h>
 #include <IceSSL/ConnectorI.h>
 #include <IceSSL/Instance.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/LocalException.h>
 #include <Ice/DefaultsAndOverrides.h>
 #include <Ice/Object.h>
 #include <Ice/HashUtil.h>
+#include <Ice/Comparable.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceSSL;
 
-IceUtil::Shared* IceSSL::upCast(EndpointI* p) { return p; }
+namespace
+{
 
-IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const string& ho, Int po,
-                             const IceInternal::Address& sourceAddr, Int ti, const string& conId, bool co) :
-    IceInternal::IPEndpointI(instance, ho, po, sourceAddr, conId),
-    _instance(instance),
-    _timeout(ti),
-    _compress(co)
+Ice::IPEndpointInfoPtr
+getIPEndpointInfo(const Ice::EndpointInfoPtr& info)
 {
+    for(Ice::EndpointInfoPtr p = info; p; p = p->underlying)
+    {
+        Ice::IPEndpointInfoPtr ipInfo = ICE_DYNAMIC_CAST(Ice::IPEndpointInfo, p);
+        if(ipInfo)
+        {
+            return ipInfo;
+        }
+    }
+    return ICE_NULLPTR;
 }
 
-IceSSL::EndpointI::EndpointI(const InstancePtr& instance) :
-    IceInternal::IPEndpointI(instance),
-    _instance(instance),
-    _timeout(instance->defaultTimeout()),
-    _compress(false)
+}
+
+#ifndef ICE_CPP11_MAPPING
+IceUtil::Shared* IceSSL::upCast(EndpointI* p) { return p; }
+#endif
+
+IceSSL::EndpointI::EndpointI(const InstancePtr& instance, const IceInternal::EndpointIPtr& del) :
+    _instance(instance), _delegate(del)
 {
 }
 
-IceSSL::EndpointI::EndpointI(const InstancePtr& instance, IceInternal::BasicStream* s) :
-    IPEndpointI(instance, s),
-    _instance(instance),
-    _timeout(-1),
-    _compress(false)
+void
+IceSSL::EndpointI::streamWriteImpl(Ice::OutputStream* stream) const
 {
-    s->read(const_cast<Int&>(_timeout));
-    s->read(const_cast<bool&>(_compress));
+    _delegate->streamWriteImpl(stream);
 }
 
 Ice::EndpointInfoPtr
 IceSSL::EndpointI::getInfo() const
 {
-    EndpointInfoPtr info = new IceInternal::InfoI<EndpointInfo>(const_cast<EndpointI*>(this));
-    fillEndpointInfo(info.get());
+    EndpointInfoPtr info = ICE_MAKE_SHARED(IceInternal::InfoI<EndpointInfo>, ICE_SHARED_FROM_CONST_THIS(EndpointI));
+    info->underlying = _delegate->getInfo();
+    info->compress = info->underlying->compress;
+    info->timeout = info->underlying->timeout;
     return info;
 }
 
-Ice::EndpointInfoPtr
-IceSSL::EndpointI::getWSInfo(const string& resource) const
+Ice::Short
+IceSSL::EndpointI::type() const
 {
-    WSSEndpointInfoPtr info = new IceInternal::InfoI<WSSEndpointInfo>(const_cast<EndpointI*>(this));
-    fillEndpointInfo(info.get());
-    info->resource = resource;
-    return info;
+    return _delegate->type();
+}
+
+const std::string&
+IceSSL::EndpointI::protocol() const
+{
+    return _delegate->protocol();
 }
 
 Int
 IceSSL::EndpointI::timeout() const
 {
-    return _timeout;
+    return _delegate->timeout();
 }
 
 IceInternal::EndpointIPtr
 IceSSL::EndpointI::timeout(Int timeout) const
 {
-    if(timeout == _timeout)
+    if(timeout == _delegate->timeout())
+    {
+        return ICE_SHARED_FROM_CONST_THIS(EndpointI);
+    }
+    else
+    {
+        return ICE_MAKE_SHARED(EndpointI, _instance, _delegate->timeout(timeout));
+    }
+}
+
+const string&
+IceSSL::EndpointI::connectionId() const
+{
+    return _delegate->connectionId();
+}
+
+IceInternal::EndpointIPtr
+IceSSL::EndpointI::connectionId(const string& connectionId) const
+{
+    if(connectionId == _delegate->connectionId())
     {
-        return const_cast<EndpointI*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(EndpointI);
     }
     else
     {
-        return new EndpointI(_instance, _host, _port, _sourceAddr, timeout, _connectionId, _compress);
+        return ICE_MAKE_SHARED(EndpointI, _instance, _delegate->connectionId(connectionId));
     }
 }
 
 bool
 IceSSL::EndpointI::compress() const
 {
-    return _compress;
+    return _delegate->compress();
 }
 
 IceInternal::EndpointIPtr
 IceSSL::EndpointI::compress(bool compress) const
 {
-    if(compress == _compress)
+    if(compress == _delegate->compress())
     {
-        return const_cast<EndpointI*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(EndpointI);
     }
     else
     {
-        return new EndpointI(_instance, _host, _port, _sourceAddr, _timeout, _connectionId, compress);
+        return ICE_MAKE_SHARED(EndpointI, _instance, _delegate->compress(compress));
     }
 }
 
 bool
 IceSSL::EndpointI::datagram() const
 {
-    return false;
+    return _delegate->datagram();
+}
+
+bool
+IceSSL::EndpointI::secure() const
+{
+    return _delegate->secure();
 }
 
 IceInternal::TransceiverPtr
@@ -117,56 +154,139 @@ IceSSL::EndpointI::transceiver() const
     return 0;
 }
 
-IceInternal::AcceptorPtr
-IceSSL::EndpointI::acceptor(const string& adapterName) const
+void
+IceSSL::EndpointI::connectors_async(Ice::EndpointSelectionType selType,
+                                    const IceInternal::EndpointI_connectorsPtr& callback) const
 {
-    return new AcceptorI(const_cast<EndpointI*>(this), _instance, adapterName, _host, _port);
+    class CallbackI : public IceInternal::EndpointI_connectors
+    {
+    public:
+
+        CallbackI(const IceInternal::EndpointI_connectorsPtr& callback, const InstancePtr& instance,
+                  const string& host) :
+            _callback(callback), _instance(instance), _host(host)
+        {
+        }
+
+        virtual void connectors(const vector<IceInternal::ConnectorPtr>& c)
+        {
+            vector<IceInternal::ConnectorPtr> connectors = c;
+            for(vector<IceInternal::ConnectorPtr>::iterator p = connectors.begin(); p != connectors.end(); ++p)
+            {
+                *p = new ConnectorI(_instance, *p, _host);
+            }
+            _callback->connectors(connectors);
+        }
+
+        virtual void exception(const Ice::LocalException& ex)
+        {
+            _callback->exception(ex);
+        }
+
+    private:
+
+        const IceInternal::EndpointI_connectorsPtr _callback;
+        const InstancePtr _instance;
+        const string _host;
+    };
+
+    IPEndpointInfoPtr info = getIPEndpointInfo(_delegate->getInfo());
+    _delegate->connectors_async(selType, ICE_MAKE_SHARED(CallbackI, callback, _instance, info ? info->host : string()));
 }
 
-EndpointIPtr
-IceSSL::EndpointI::endpoint(const AcceptorIPtr& acceptor) const
+IceInternal::AcceptorPtr
+IceSSL::EndpointI::acceptor(const string& adapterName) const
 {
-    return new EndpointI(_instance, _host, acceptor->effectivePort(), _sourceAddr, _timeout, _connectionId, _compress);
+    return new AcceptorI(ICE_SHARED_FROM_CONST_THIS(EndpointI), _instance, _delegate->acceptor(adapterName), adapterName);
 }
 
-string
-IceSSL::EndpointI::options() const
+EndpointIPtr
+IceSSL::EndpointI::endpoint(const IceInternal::EndpointIPtr& delEndp) const
 {
-    //
-    // WARNING: Certain features, such as proxy validation in Glacier2,
-    // depend on the format of proxy strings. Changes to toString() and
-    // methods called to generate parts of the reference string could break
-    // these features. Please review for all features that depend on the
-    // format of proxyToString() before changing this and related code.
-    //
-    ostringstream s;
-    s << IPEndpointI::options();
-
-    if(_timeout == -1)
+    if(delEndp.get() == _delegate.get())
     {
-        s << " -t infinite";
+        return ICE_DYNAMIC_CAST(EndpointI, ICE_SHARED_FROM_CONST_THIS(EndpointI));
     }
     else
     {
-        s << " -t " << _timeout;
+        return ICE_MAKE_SHARED(EndpointI, _instance, delEndp);
     }
+}
 
-    if(_compress)
+vector<IceInternal::EndpointIPtr>
+IceSSL::EndpointI::expandIfWildcard() const
+{
+    vector<IceInternal::EndpointIPtr> endps = _delegate->expandIfWildcard();
+    for(vector<IceInternal::EndpointIPtr>::iterator p = endps.begin(); p != endps.end(); ++p)
     {
-        s << " -z";
+        if(p->get() == _delegate.get())
+        {
+            *p = ICE_SHARED_FROM_CONST_THIS(EndpointI);
+        }
+        else
+        {
+            *p = ICE_MAKE_SHARED(EndpointI, _instance, *p);
+        }
     }
+    return endps;
+}
 
-    return s.str();
+vector<IceInternal::EndpointIPtr>
+IceSSL::EndpointI::expandHost(IceInternal::EndpointIPtr& publish) const
+{
+    vector<IceInternal::EndpointIPtr> endps = _delegate->expandHost(publish);
+    if(publish.get() == _delegate.get())
+    {
+        publish = ICE_SHARED_FROM_CONST_THIS(EndpointI);
+    }
+    else if(publish.get())
+    {
+        publish = ICE_MAKE_SHARED(EndpointI, _instance, publish);
+    }
+    for(vector<IceInternal::EndpointIPtr>::iterator p = endps.begin(); p != endps.end(); ++p)
+    {
+        if(p->get() == _delegate.get())
+        {
+            *p = ICE_SHARED_FROM_CONST_THIS(EndpointI);
+        }
+        else
+        {
+            *p = ICE_MAKE_SHARED(EndpointI, _instance, *p);
+        }
+    }
+    return endps;
 }
 
 bool
-IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const
+IceSSL::EndpointI::equivalent(const IceInternal::EndpointIPtr& endpoint) const
 {
-    if(!IPEndpointI::operator==(r))
+    const EndpointI* endpointI = dynamic_cast<const EndpointI*>(endpoint.get());
+    if(!endpointI)
     {
         return false;
     }
+    return _delegate->equivalent(endpointI->_delegate);
+}
+
+Ice::Int
+IceSSL::EndpointI::hash() const
+{
+    return _delegate->hash();
+}
+
+string
+IceSSL::EndpointI::options() const
+{
+    return _delegate->options();
+}
 
+bool
+#ifdef ICE_CPP11_MAPPING
+IceSSL::EndpointI::operator==(const Ice::Endpoint& r) const
+#else
+IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const
+#endif
+{
     const EndpointI* p = dynamic_cast<const EndpointI*>(&r);
     if(!p)
     {
@@ -178,12 +298,7 @@ IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const
         return true;
     }
 
-    if(_timeout != p->_timeout)
-    {
-        return false;
-    }
-
-    if(_compress != p->_compress)
+    if(!Ice::targetEqualTo(_delegate, p->_delegate))
     {
         return false;
     }
@@ -192,7 +307,11 @@ IceSSL::EndpointI::operator==(const Ice::LocalObject& r) const
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceSSL::EndpointI::operator<(const Ice::Endpoint& r) const
+#else
 IceSSL::EndpointI::operator<(const Ice::LocalObject& r) const
+#endif
 {
     const EndpointI* p = dynamic_cast<const EndpointI*>(&r);
     if(!p)
@@ -210,160 +329,49 @@ IceSSL::EndpointI::operator<(const Ice::LocalObject& r) const
         return false;
     }
 
-    if(_timeout < p->_timeout)
+    if(Ice::targetLess(_delegate, p->_delegate))
     {
         return true;
     }
-    else if(p->_timeout < _timeout)
+    else if (Ice::targetLess(p->_delegate, _delegate))
     {
         return false;
     }
 
-    if(!_compress && p->_compress)
-    {
-        return true;
-    }
-    else if(p->_compress < _compress)
-    {
-        return false;
-    }
-
-    return IPEndpointI::operator<(r);
-}
-
-void
-IceSSL::EndpointI::streamWriteImpl(IceInternal::BasicStream* s) const
-{
-    IPEndpointI::streamWriteImpl(s);
-    s->write(_timeout);
-    s->write(_compress);
-}
-
-void
-IceSSL::EndpointI::hashInit(Ice::Int& h) const
-{
-    IPEndpointI::hashInit(h);
-    IceInternal::hashAdd(h, _timeout);
-    IceInternal::hashAdd(h, _compress);
-}
-
-void
-IceSSL::EndpointI::fillEndpointInfo(IPEndpointInfo* info) const
-{
-    IPEndpointI::fillEndpointInfo(info);
-    info->timeout = _timeout;
-    info->compress = _compress;
+    return false;
 }
 
 bool
 IceSSL::EndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
 {
-    if(IPEndpointI::checkOption(option, argument, endpoint))
-    {
-        return true;
-    }
-
-    switch(option[1])
-    {
-    case 't':
-    {
-        if(argument.empty())
-        {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -t option in endpoint " + endpoint;
-            throw ex;
-        }
-
-        if(argument == "infinite")
-        {
-            const_cast<Int&>(_timeout) = -1;
-        }
-        else
-        {
-            istringstream t(argument);
-            if(!(t >> const_cast<Int&>(_timeout)) || !t.eof() || _timeout < 1)
-            {
-                EndpointParseException ex(__FILE__, __LINE__);
-                ex.str = "invalid timeout value `" + argument + "' in endpoint " + endpoint;
-                throw ex;
-            }
-        }
-        return true;
-    }
-
-    case 'z':
-    {
-        if(!argument.empty())
-        {
-            EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "unexpected argument `" + argument + "' provided for -z option in " + endpoint;
-            throw ex;
-        }
-        const_cast<bool&>(_compress) = true;
-        return true;
-    }
-
-    default:
-    {
-        return false;
-    }
-    }
-}
-
-IceInternal::ConnectorPtr
-IceSSL::EndpointI::createConnector(const IceInternal::Address& address, const IceInternal::NetworkProxyPtr& proxy) const
-{
-    return new ConnectorI(_instance, _host, address, proxy, _sourceAddr, _timeout, _connectionId);
-}
-
-IceInternal::IPEndpointIPtr
-IceSSL::EndpointI::createEndpoint(const string& host, int port, const string& connectionId) const
-{
-    return new EndpointI(_instance, host, port, _sourceAddr, _timeout, connectionId, _compress);
-}
-
-IceSSL::EndpointFactoryI::EndpointFactoryI(const InstancePtr& instance) : _instance(instance)
-{
+    return false;
 }
 
-IceSSL::EndpointFactoryI::~EndpointFactoryI()
+IceSSL::EndpointFactoryI::EndpointFactoryI(const InstancePtr& instance, Short type) :
+    IceInternal::EndpointFactoryWithUnderlying(instance, type), _instance(instance.get())
 {
 }
 
-Short
-IceSSL::EndpointFactoryI::type() const
+void
+IceSSL::EndpointFactoryI::destroy()
 {
-    return _instance->type();
+    _instance = 0;
 }
 
-string
-IceSSL::EndpointFactoryI::protocol() const
+IceInternal::EndpointFactoryPtr
+IceSSL::EndpointFactoryI::cloneWithUnderlying(const IceInternal::ProtocolInstancePtr& instance, Short underlying) const
 {
-    return _instance->protocol();
+    return new EndpointFactoryI(new Instance(_instance->engine(), instance->type(), instance->protocol()), underlying);
 }
 
 IceInternal::EndpointIPtr
-IceSSL::EndpointFactoryI::create(vector<string>& args, bool oaEndpoint) const
+IceSSL::EndpointFactoryI::createWithUnderlying(const IceInternal::EndpointIPtr& underlying, vector<string>&, bool) const
 {
-    IceInternal::IPEndpointIPtr endpt = new EndpointI(_instance);
-    endpt->initWithOptions(args, oaEndpoint);
-    return endpt;
+    return ICE_MAKE_SHARED(EndpointI, _instance, underlying);
 }
 
 IceInternal::EndpointIPtr
-IceSSL::EndpointFactoryI::read(IceInternal::BasicStream* s) const
-{
-    return new EndpointI(_instance, s);
-}
-
-void
-IceSSL::EndpointFactoryI::destroy()
-{
-    _instance = 0;
-}
-
-IceInternal::EndpointFactoryPtr
-IceSSL::EndpointFactoryI::clone(const IceInternal::ProtocolInstancePtr& instance) const
+IceSSL::EndpointFactoryI::readWithUnderlying(const IceInternal::EndpointIPtr& underlying, Ice::InputStream* s) const
 {
-    return new EndpointFactoryI(new Instance(_instance->engine(), instance->type(), instance->protocol()));
+    return ICE_MAKE_SHARED(EndpointI, _instance, underlying);
 }