Added Ruby implemetation of EndpointInfo and ConnectionInfo

20 files changed, 94 insertions, 111 deletions

diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 696c966b591..b8942d42aec 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -1434,7 +1434,9 @@ Ice::ConnectionI::getInfo() const
     {
         _exception->ice_throw();
     }
-    return _transceiver->getInfo();
+    ConnectionInfoPtr info = _transceiver->getInfo();
+    info->endpoint = _endpoint->getInfo();
+    return info;
 }
 
 //
diff --git a/cpp/src/Ice/TcpAcceptor.cpp b/cpp/src/Ice/TcpAcceptor.cpp
index 9574f7bce0a..1b0e4251ba5 100644
--- a/cpp/src/Ice/TcpAcceptor.cpp
+++ b/cpp/src/Ice/TcpAcceptor.cpp
@@ -9,7 +9,6 @@
 
 #include <Ice/TcpAcceptor.h>
 #include <Ice/TcpTransceiver.h>
-#include <Ice/Endpoint.h>
 #include <Ice/Instance.h>
 #include <Ice/TraceLevels.h>
 #include <Ice/LoggerUtil.h>
@@ -169,7 +168,7 @@ IceInternal::TcpAcceptor::accept()
         Trace out(_logger, _traceLevels->networkCat);
         out << "accepted tcp connection\n" << fdToString(fd);
     }
-    return new TcpTransceiver(_instance, _endpointInfo, fd, true);
+    return new TcpTransceiver(_instance, fd, true);
 }
 
 string
@@ -184,12 +183,11 @@ IceInternal::TcpAcceptor::effectivePort() const
     return getPort(_addr);
 }
 
-IceInternal::TcpAcceptor::TcpAcceptor(const InstancePtr& instance, const TcpEndpointInfoPtr& endpointInfo) :
+IceInternal::TcpAcceptor::TcpAcceptor(const InstancePtr& instance, const string& host, int port) :
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
-    _addr(getAddressForServer(endpointInfo->host, endpointInfo->port, instance->protocolSupport()))
+    _addr(getAddressForServer(host, port, instance->protocolSupport()))
 #ifdef ICE_USE_IOCP
     , _acceptFd(INVALID_SOCKET),
     _info(SocketOperationRead)
diff --git a/cpp/src/Ice/TcpAcceptor.h b/cpp/src/Ice/TcpAcceptor.h
index b4067c9a711..64406b330be 100644
--- a/cpp/src/Ice/TcpAcceptor.h
+++ b/cpp/src/Ice/TcpAcceptor.h
@@ -23,6 +23,8 @@
 namespace IceInternal
 {
 
+class TcpEndpoint;
+
 class TcpAcceptor : public Acceptor, public NativeInfo
 {
 public:
@@ -45,12 +47,11 @@ public:
 
 private:
 
-    TcpAcceptor(const InstancePtr&, const Ice::TcpEndpointInfoPtr&);
+    TcpAcceptor(const InstancePtr&, const std::string&, int);
     virtual ~TcpAcceptor();
     friend class TcpEndpointI;
 
     const InstancePtr _instance;
-    const Ice::TcpEndpointInfoPtr _endpointInfo;
     const TraceLevelsPtr _traceLevels;
     const ::Ice::LoggerPtr _logger;
     const struct sockaddr_storage _addr;
diff --git a/cpp/src/Ice/TcpConnector.cpp b/cpp/src/Ice/TcpConnector.cpp
index e1fdf982cdc..9d45fdf82bd 100644
--- a/cpp/src/Ice/TcpConnector.cpp
+++ b/cpp/src/Ice/TcpConnector.cpp
@@ -31,8 +31,7 @@ IceInternal::TcpConnector::connect()
 
     try
     {
-        TransceiverPtr transceiver = 
-            new TcpTransceiver(_instance, _endpointInfo, createSocket(false, _addr.ss_family), false);
+        TransceiverPtr transceiver = new TcpTransceiver(_instance, createSocket(false, _addr.ss_family), false);
         dynamic_cast<TcpTransceiver*>(transceiver.get())->connect(_addr);
         return transceiver;
     }
@@ -121,16 +120,13 @@ IceInternal::TcpConnector::operator<(const Connector& r) const
     return compareAddress(_addr, p->_addr) == -1;
 }
 
-IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance,
-                                        const TcpEndpointInfoPtr& endpointInfo,
-                                        const struct sockaddr_storage& addr,
-                                        const string& connectionId) :
+IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance, const struct sockaddr_storage& addr,
+                                        Ice::Int timeout, const string& connectionId) :
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _addr(addr),
-    _timeout(_endpointInfo->timeout),
+    _timeout(timeout),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/Ice/TcpConnector.h b/cpp/src/Ice/TcpConnector.h
index 72453a40c80..6f83719cdb8 100644
--- a/cpp/src/Ice/TcpConnector.h
+++ b/cpp/src/Ice/TcpConnector.h
@@ -11,7 +11,6 @@
 #define ICE_TCP_CONNECTOR_H
 
 #include <Ice/TransceiverF.h>
-#include <Ice/EndpointF.h>
 #include <Ice/InstanceF.h>
 #include <Ice/TraceLevelsF.h>
 #include <Ice/LoggerF.h>
@@ -41,13 +40,11 @@ public:
 
 private:
     
-    TcpConnector(const InstancePtr&, const Ice::TcpEndpointInfoPtr&, const struct sockaddr_storage&,
-                 const std::string&);
+    TcpConnector(const InstancePtr&, const struct sockaddr_storage&, Ice::Int, const std::string&);
     virtual ~TcpConnector();
     friend class TcpEndpointI;
 
     const InstancePtr _instance;
-    const Ice::TcpEndpointInfoPtr _endpointInfo;
     const TraceLevelsPtr _traceLevels;
     const ::Ice::LoggerPtr _logger;
     const struct sockaddr_storage _addr;
diff --git a/cpp/src/Ice/TcpEndpointI.cpp b/cpp/src/Ice/TcpEndpointI.cpp
index 9b18fc3c4ac..9d8c761231f 100644
--- a/cpp/src/Ice/TcpEndpointI.cpp
+++ b/cpp/src/Ice/TcpEndpointI.cpp
@@ -351,7 +351,7 @@ IceInternal::TcpEndpointI::connectors_async(const EndpointI_connectorsPtr& callb
 AcceptorPtr
 IceInternal::TcpEndpointI::acceptor(EndpointIPtr& endp, const string&) const
 {
-    TcpAcceptor* p = new TcpAcceptor(_instance, TcpEndpointInfoPtr::dynamicCast(getInfo()));
+    TcpAcceptor* p = new TcpAcceptor(_instance, _host, _port);
     endp = new TcpEndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
     return p;
 }
@@ -503,8 +503,7 @@ IceInternal::TcpEndpointI::connectors(const vector<struct sockaddr_storage>& add
     vector<ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new TcpConnector(_instance, TcpEndpointInfoPtr::dynamicCast(getInfo()), addresses[i],
-                                              _connectionId));
+        connectors.push_back(new TcpConnector(_instance, addresses[i], _timeout, _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/Ice/TcpTransceiver.cpp b/cpp/src/Ice/TcpTransceiver.cpp
index 33ffb3f9e43..959c3ce6f87 100644
--- a/cpp/src/Ice/TcpTransceiver.cpp
+++ b/cpp/src/Ice/TcpTransceiver.cpp
@@ -459,7 +459,6 @@ IceInternal::TcpTransceiver::getInfo() const
 {
     assert(_fd != INVALID_SOCKET);
     Ice::TcpConnectionInfoPtr info = new Ice::TcpConnectionInfo();
-    info->endpoint = _endpointInfo;
     fdToAddressAndPort(_fd, info->localAddress, info->localPort, info->remoteAddress, info->remotePort);
     return info;
 }
@@ -473,12 +472,8 @@ IceInternal::TcpTransceiver::checkSendSize(const Buffer& buf, size_t messageSize
     }
 }
 
-IceInternal::TcpTransceiver::TcpTransceiver(const InstancePtr& instance,
-                                            const TcpEndpointInfoPtr& endpointInfo,
-                                            SOCKET fd,
-                                            bool connected) :
+IceInternal::TcpTransceiver::TcpTransceiver(const InstancePtr& instance, SOCKET fd, bool connected) :
     NativeInfo(fd),
-    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _stats(instance->initializationData().stats),
diff --git a/cpp/src/Ice/TcpTransceiver.h b/cpp/src/Ice/TcpTransceiver.h
index 81ca7d07c30..2f131531d0a 100644
--- a/cpp/src/Ice/TcpTransceiver.h
+++ b/cpp/src/Ice/TcpTransceiver.h
@@ -55,7 +55,7 @@ public:
 
 private:
 
-    TcpTransceiver(const InstancePtr&, const Ice::TcpEndpointInfoPtr&, SOCKET, bool);
+    TcpTransceiver(const InstancePtr&, SOCKET, bool);
     virtual ~TcpTransceiver();
 
     void connect(const struct sockaddr_storage&);
@@ -63,7 +63,6 @@ private:
     friend class TcpConnector;
     friend class TcpAcceptor;
 
-    const Ice::TcpEndpointInfoPtr _endpointInfo;
     const TraceLevelsPtr _traceLevels;
     const Ice::LoggerPtr _logger;
     const Ice::StatsPtr _stats;
diff --git a/cpp/src/Ice/UdpConnector.cpp b/cpp/src/Ice/UdpConnector.cpp
index 6f6f9b6b8ff..d8a4c5588df 100644
--- a/cpp/src/Ice/UdpConnector.cpp
+++ b/cpp/src/Ice/UdpConnector.cpp
@@ -20,7 +20,7 @@ using namespace IceInternal;
 TransceiverPtr
 IceInternal::UdpConnector::connect()
 {
-    return new UdpTransceiver(_instance, _endpointInfo, _addr);
+    return new UdpTransceiver(_instance, _addr, _mcastInterface, _mcastTtl);
 }
 
 Short
@@ -54,32 +54,32 @@ IceInternal::UdpConnector::operator==(const Connector& r) const
         return false;
     }
 
-    if(_endpointInfo->protocolMajor != p->_endpointInfo->protocolMajor)
+    if(_protocolMajor != p->_protocolMajor)
     {
         return false;
     }
 
-    if(_endpointInfo->protocolMinor != p->_endpointInfo->protocolMinor)
+    if(_protocolMinor != p->_protocolMinor)
     {
         return false;
     }
 
-    if(_endpointInfo->encodingMajor != p->_endpointInfo->encodingMajor)
+    if(_encodingMajor != p->_encodingMajor)
     {
         return false;
     }
 
-    if(_endpointInfo->encodingMinor != p->_endpointInfo->encodingMinor)
+    if(_encodingMinor != p->_encodingMinor)
     {
         return false;
     }
 
-    if(_endpointInfo->mcastTtl != p->_endpointInfo->mcastTtl)
+    if(_mcastTtl != p->_mcastTtl)
     {
         return false;
     }
 
-    if(_endpointInfo->mcastInterface != p->_endpointInfo->mcastInterface)
+    if(_mcastInterface != p->_mcastInterface)
     {
         return false;
     }
@@ -111,56 +111,56 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
         return false;
     }
 
-    if(_endpointInfo->protocolMajor < p->_endpointInfo->protocolMajor)
+    if(_protocolMajor < p->_protocolMajor)
     {
         return true;
     }
-    else if(p->_endpointInfo->protocolMajor < _endpointInfo->protocolMajor)
+    else if(p->_protocolMajor < _protocolMajor)
     {
         return false;
     }
 
-    if(_endpointInfo->protocolMinor < p->_endpointInfo->protocolMinor)
+    if(_protocolMinor < p->_protocolMinor)
     {
         return true;
     }
-    else if(p->_endpointInfo->protocolMinor < _endpointInfo->protocolMinor)
+    else if(p->_protocolMinor < _protocolMinor)
     {
         return false;
     }
 
-    if(_endpointInfo->encodingMajor < p->_endpointInfo->encodingMajor)
+    if(_encodingMajor < p->_encodingMajor)
     {
         return true;
     }
-    else if(p->_endpointInfo->encodingMajor < _endpointInfo->encodingMajor)
+    else if(p->_encodingMajor < _encodingMajor)
     {
         return false;
     }
 
-    if(_endpointInfo->encodingMinor < p->_endpointInfo->encodingMinor)
+    if(_encodingMinor < p->_encodingMinor)
     {
         return true;
     }
-    else if(p->_endpointInfo->encodingMinor < _endpointInfo->encodingMinor)
+    else if(p->_encodingMinor < _encodingMinor)
     {
         return false;
     }
 
-    if(_endpointInfo->mcastTtl < p->_endpointInfo->mcastTtl)
+    if(_mcastTtl < p->_mcastTtl)
     {
         return true;
     }
-    else if(p->_endpointInfo->mcastTtl < _endpointInfo->mcastTtl)
+    else if(p->_mcastTtl < _mcastTtl)
     {
         return false;
     }
 
-    if(_endpointInfo->mcastInterface < p->_endpointInfo->mcastInterface)
+    if(_mcastInterface < p->_mcastInterface)
     {
         return true;
     }
-    else if(p->_endpointInfo->mcastInterface < _endpointInfo->mcastInterface)
+    else if(p->_mcastInterface < _mcastInterface)
     {
         return false;
     }
@@ -169,13 +169,18 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
 }
 
 
-IceInternal::UdpConnector::UdpConnector(const InstancePtr& instance,
-                                        const UdpEndpointInfoPtr& endpointInfo,
-                                        const struct sockaddr_storage& addr, 
+IceInternal::UdpConnector::UdpConnector(const InstancePtr& instance, const struct sockaddr_storage& addr, 
+                                        const string& mcastInterface, int mcastTtl, Ice::Byte protocolMajor,
+                                        Ice::Byte protocolMinor, Ice::Byte encodingMajor, Ice::Byte encodingMinor,
                                         const std::string& connectionId) :
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _addr(addr),
+    _mcastInterface(mcastInterface),
+    _mcastTtl(mcastTtl),
+    _protocolMajor(protocolMajor),
+    _protocolMinor(protocolMinor),
+    _encodingMajor(encodingMajor),
+    _encodingMinor(encodingMinor),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/Ice/UdpConnector.h b/cpp/src/Ice/UdpConnector.h
index 924d02bba7c..4e27190ac1e 100644
--- a/cpp/src/Ice/UdpConnector.h
+++ b/cpp/src/Ice/UdpConnector.h
@@ -11,7 +11,6 @@
 #define ICE_UDP_CONNECTOR_H
 
 #include <Ice/TransceiverF.h>
-#include <Ice/EndpointF.h>
 #include <Ice/InstanceF.h>
 #include <Ice/Connector.h>
 #include <Ice/Protocol.h>
@@ -40,14 +39,19 @@ public:
 
 private:
     
-    UdpConnector(const InstancePtr&, const Ice::UdpEndpointInfoPtr&, const struct sockaddr_storage&,
-                 const std::string&);
+    UdpConnector(const InstancePtr&, const struct sockaddr_storage&, const std::string&, int, Ice::Byte, Ice::Byte, 
+                 Ice::Byte, Ice::Byte, const std::string&);
     virtual ~UdpConnector();
     friend class UdpEndpointI;
 
     const InstancePtr _instance;
-    const Ice::UdpEndpointInfoPtr _endpointInfo;
     struct sockaddr_storage _addr;
+    const std::string _mcastInterface;
+    const int _mcastTtl;
+    const Ice::Byte _protocolMajor;
+    const Ice::Byte _protocolMinor;
+    const Ice::Byte _encodingMajor;
+    const Ice::Byte _encodingMinor;
     const std::string _connectionId;
 };
 
diff --git a/cpp/src/Ice/UdpEndpointI.cpp b/cpp/src/Ice/UdpEndpointI.cpp
index 298bb72b800..bbd273cfa54 100644
--- a/cpp/src/Ice/UdpEndpointI.cpp
+++ b/cpp/src/Ice/UdpEndpointI.cpp
@@ -536,7 +536,7 @@ IceInternal::UdpEndpointI::secure() const
 TransceiverPtr
 IceInternal::UdpEndpointI::transceiver(EndpointIPtr& endp) const
 {
-    UdpTransceiver* p = new UdpTransceiver(_instance, UdpEndpointInfoPtr::dynamicCast(getInfo()), _connect);
+    UdpTransceiver* p = new UdpTransceiver(_instance, _host, _port, _mcastInterface, _connect);
     endp = new UdpEndpointI(_instance, _host, p->effectivePort(), _mcastInterface, _mcastTtl, _protocolMajor,
                             _protocolMinor, _encodingMajor, _encodingMinor, _connect, _connectionId,
                             _compress);
@@ -794,8 +794,8 @@ IceInternal::UdpEndpointI::connectors(const vector<struct sockaddr_storage>& add
     vector<ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new UdpConnector(_instance, UdpEndpointInfoPtr::dynamicCast(getInfo()), addresses[i],
-                                              _connectionId));
+        connectors.push_back(new UdpConnector(_instance, addresses[i], _mcastInterface, _mcastTtl, _protocolMajor,
+                                              _protocolMinor, _encodingMajor, _encodingMinor, _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/Ice/UdpTransceiver.cpp b/cpp/src/Ice/UdpTransceiver.cpp
index 8cd68d76edb..fbf00a1048a 100644
--- a/cpp/src/Ice/UdpTransceiver.cpp
+++ b/cpp/src/Ice/UdpTransceiver.cpp
@@ -457,7 +457,6 @@ IceInternal::UdpTransceiver::getInfo() const
 {
     assert(_fd != INVALID_SOCKET);
     Ice::UdpConnectionInfoPtr info = new Ice::UdpConnectionInfo();
-    info->endpoint = _endpointInfo;
     fdToAddressAndPort(_fd, info->localAddress, info->localPort, info->remoteAddress, info->remotePort);
     addrToAddressAndPort(_mcastAddr, info->mcastAddress, info->mcastPort);
     return info;
@@ -483,10 +482,8 @@ IceInternal::UdpTransceiver::effectivePort() const
     return getPort(_addr);
 }
 
-IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance,
-                                            const Ice::UdpEndpointInfoPtr& endpointInfo,
-                                            const struct sockaddr_storage& addr) :
-    _endpointInfo(endpointInfo),
+IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance, const struct sockaddr_storage& addr,
+                                            const string& mcastInterface, int mcastTtl) :
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _stats(instance->initializationData().stats),
@@ -513,26 +510,24 @@ IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance,
     
     if(isMulticast(_addr))
     {
-        if(endpointInfo->mcastInterface.length() > 0)
+        if(mcastInterface.length() > 0)
         {
-            setMcastInterface(_fd, endpointInfo->mcastInterface, _addr.ss_family == AF_INET);
+            setMcastInterface(_fd, mcastInterface, _addr.ss_family == AF_INET);
         }
-        if(endpointInfo->mcastTtl != -1)
+        if(mcastTtl != -1)
         {
-            setMcastTtl(_fd, endpointInfo->mcastTtl, _addr.ss_family == AF_INET);
+            setMcastTtl(_fd, mcastTtl, _addr.ss_family == AF_INET);
         }
     }
 }
 
-IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance,
-                                            const Ice::UdpEndpointInfoPtr& endpointInfo,
-                                            bool connect) :
-    _endpointInfo(endpointInfo),
+IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance, const string& host, int port,
+                                            const string& mcastInterface, bool connect) :
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _stats(instance->initializationData().stats),
     _incoming(true),
-    _addr(getAddressForServer(_endpointInfo->host, _endpointInfo->port, instance->protocolSupport())),
+    _addr(getAddressForServer(host, port, instance->protocolSupport())),
     _connect(connect),
     _warn(instance->initializationData().properties->getPropertyAsInt("Ice.Warn.Datagrams") > 0)
 #ifdef ICE_USE_IOCP
@@ -569,7 +564,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance,
         {
             setPort(_mcastAddr, getPort(_addr));
         }
-        setMcastGroup(_fd, _mcastAddr, _endpointInfo->mcastInterface);
+        setMcastGroup(_fd, _mcastAddr, mcastInterface);
     }
     else
     {
diff --git a/cpp/src/Ice/UdpTransceiver.h b/cpp/src/Ice/UdpTransceiver.h
index a8a3194a607..f7c918184a8 100644
--- a/cpp/src/Ice/UdpTransceiver.h
+++ b/cpp/src/Ice/UdpTransceiver.h
@@ -61,8 +61,8 @@ public:
 
 private:
 
-    UdpTransceiver(const InstancePtr&, const Ice::UdpEndpointInfoPtr&, const struct sockaddr_storage&);
-    UdpTransceiver(const InstancePtr&, const Ice::UdpEndpointInfoPtr&, bool);
+    UdpTransceiver(const InstancePtr&, const struct sockaddr_storage&, const std::string&, int);
+    UdpTransceiver(const InstancePtr&, const std::string&, int, const std::string&, bool);
     virtual ~UdpTransceiver();
 
     void setBufSize(const InstancePtr&);
@@ -70,7 +70,6 @@ private:
     friend class UdpEndpointI;
     friend class UdpConnector;
 
-    const Ice::UdpEndpointInfoPtr _endpointInfo;
     const TraceLevelsPtr _traceLevels;
     const Ice::LoggerPtr _logger;
     const Ice::StatsPtr _stats;
diff --git a/cpp/src/IceSSL/AcceptorI.cpp b/cpp/src/IceSSL/AcceptorI.cpp
index e8de9f97a87..c82a77dc4dc 100644
--- a/cpp/src/IceSSL/AcceptorI.cpp
+++ b/cpp/src/IceSSL/AcceptorI.cpp
@@ -188,7 +188,7 @@ IceSSL::AcceptorI::accept()
     // SSL handshaking is performed in TransceiverI::initialize, since
     // accept must not block.
     //
-    return new TransceiverI(_instance, _endpointInfo, fd, _adapterName);
+    return new TransceiverI(_instance, fd, _adapterName);
 }
 
 string
@@ -210,13 +210,11 @@ IceSSL::AcceptorI::effectivePort() const
     }
 }
 
-IceSSL::AcceptorI::AcceptorI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo,
-                             const string& adapterName) :
+IceSSL::AcceptorI::AcceptorI(const InstancePtr& instance, const string& adapterName, const string& host, int port) :
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _adapterName(adapterName),
     _logger(instance->communicator()->getLogger()),
-    _addr(IceInternal::getAddressForServer(_endpointInfo->host, _endpointInfo->port, instance->protocolSupport()))
+    _addr(IceInternal::getAddressForServer(host, port, instance->protocolSupport()))
 #ifdef ICE_USE_IOCP
     , _acceptFd(INVALID_SOCKET),
     _info(IceInternal::SocketOperationRead)
diff --git a/cpp/src/IceSSL/AcceptorI.h b/cpp/src/IceSSL/AcceptorI.h
index df84201cd9f..71ce3991b2b 100644
--- a/cpp/src/IceSSL/AcceptorI.h
+++ b/cpp/src/IceSSL/AcceptorI.h
@@ -15,7 +15,6 @@
 #include <Ice/Acceptor.h>
 #include <Ice/Protocol.h>
 #include <IceSSL/InstanceF.h>
-#include <IceSSL/EndpointInfo.h>
 
 #ifndef _WIN32
 #   include <sys/socket.h> // For struct sockaddr_storage
@@ -50,12 +49,11 @@ public:
 
 private:
 
-    AcceptorI(const InstancePtr&, const SSLEndpointInfoPtr&, const std::string&);
+    AcceptorI(const InstancePtr&, const std::string&, const std::string&, int);
     virtual ~AcceptorI();
     friend class EndpointI;
 
     const InstancePtr _instance;
-    const SSLEndpointInfoPtr _endpointInfo;
     const std::string _adapterName;
     const Ice::LoggerPtr _logger;
     const struct sockaddr_storage _addr;
diff --git a/cpp/src/IceSSL/ConnectorI.cpp b/cpp/src/IceSSL/ConnectorI.cpp
index fad1c651c13..9b5e14a6fe9 100644
--- a/cpp/src/IceSSL/ConnectorI.cpp
+++ b/cpp/src/IceSSL/ConnectorI.cpp
@@ -42,7 +42,7 @@ IceSSL::ConnectorI::connect()
 
     try
     {
-        return new TransceiverI(_instance, _endpointInfo, IceInternal::createSocket(false, _addr.ss_family), _addr);
+        return new TransceiverI(_instance, IceInternal::createSocket(false, _addr.ss_family), _host, _addr);
     }
     catch(const Ice::LocalException& ex)
     {
@@ -81,7 +81,7 @@ IceSSL::ConnectorI::operator==(const IceInternal::Connector& r) const
         return false;
     }
 
-    if(_endpointInfo->timeout != p->_endpointInfo->timeout)
+    if(_timeout != p->_timeout)
     {
         return false;
     }
@@ -109,11 +109,11 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
         return type() < r.type();
     }
 
-    if(_endpointInfo->timeout < p->_endpointInfo->timeout)
+    if(_timeout < p->_timeout)
     {
         return true;
     }
-    else if(p->_endpointInfo->timeout < _endpointInfo->timeout)
+    else if(p->_timeout < _timeout)
     {
         return false;
     }
@@ -130,12 +130,13 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
     return IceInternal::compareAddress(_addr, p->_addr) == -1;
 }
 
-IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo,
-                               const struct sockaddr_storage& addr, const string& connectionId) :
+IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const string& host, const struct sockaddr_storage& addr,
+                               Ice::Int timeout, const string& connectionId) :
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _logger(instance->communicator()->getLogger()),
+    _host(host),
     _addr(addr),
+    _timeout(timeout),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/IceSSL/ConnectorI.h b/cpp/src/IceSSL/ConnectorI.h
index 163f87d5add..d8c79a6e0c4 100644
--- a/cpp/src/IceSSL/ConnectorI.h
+++ b/cpp/src/IceSSL/ConnectorI.h
@@ -14,7 +14,6 @@
 #include <Ice/TransceiverF.h>
 #include <Ice/Connector.h>
 #include <IceSSL/InstanceF.h>
-#include <IceSSL/EndpointInfo.h>
 
 #ifdef _WIN32
 #   include <winsock2.h>
@@ -42,14 +41,15 @@ public:
 
 private:
     
-    ConnectorI(const InstancePtr&, const SSLEndpointInfoPtr&, const struct sockaddr_storage&, const std::string&);
+    ConnectorI(const InstancePtr&, const std::string&, const struct sockaddr_storage&, Ice::Int, const std::string&);
     virtual ~ConnectorI();
     friend class EndpointI;
 
     const InstancePtr _instance;
-    const SSLEndpointInfoPtr _endpointInfo;
     const Ice::LoggerPtr _logger;
+    const std::string _host;
     struct sockaddr_storage _addr;
+    const Ice::Int _timeout;
     const std::string _connectionId;
 };
 
diff --git a/cpp/src/IceSSL/EndpointI.cpp b/cpp/src/IceSSL/EndpointI.cpp
index 8166574bf65..c21db89353c 100644
--- a/cpp/src/IceSSL/EndpointI.cpp
+++ b/cpp/src/IceSSL/EndpointI.cpp
@@ -351,7 +351,7 @@ IceSSL::EndpointI::connectors_async(const IceInternal::EndpointI_connectorsPtr&
 IceInternal::AcceptorPtr
 IceSSL::EndpointI::acceptor(IceInternal::EndpointIPtr& endp, const string& adapterName) const
 {
-    AcceptorI* p = new AcceptorI(_instance, SSLEndpointInfoPtr::dynamicCast(getInfo()), adapterName);
+    AcceptorI* p = new AcceptorI(_instance, adapterName, _host, _port);
     endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
     return p;
 }
@@ -502,8 +502,7 @@ IceSSL::EndpointI::connectors(const vector<struct sockaddr_storage>& addresses)
     vector<IceInternal::ConnectorPtr> connectors;
     for(unsigned int i = 0; i < addresses.size(); ++i)
     {
-        connectors.push_back(new ConnectorI(_instance, SSLEndpointInfoPtr::dynamicCast(getInfo()), addresses[i],
-                                            _connectionId));
+        connectors.push_back(new ConnectorI(_instance, _host, addresses[i], _timeout, _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/IceSSL/TransceiverI.cpp b/cpp/src/IceSSL/TransceiverI.cpp
index 1c95553e46a..28f59e93756 100644
--- a/cpp/src/IceSSL/TransceiverI.cpp
+++ b/cpp/src/IceSSL/TransceiverI.cpp
@@ -234,7 +234,7 @@ IceSSL::TransceiverI::initialize()
             }
         }
 
-        _instance->verifyPeer(_ssl, _fd, _endpointInfo->host, _adapterName, _incoming);
+        _instance->verifyPeer(_ssl, _fd, _host, _adapterName, _incoming);
         _state = StateHandshakeComplete;
     }
     catch(const Ice::LocalException& ex)
@@ -784,7 +784,6 @@ IceSSL::TransceiverI::getInfo() const
     assert(_fd != INVALID_SOCKET && _ssl != 0);
 
     SSLConnectionInfoPtr info = new SSLConnectionInfo();
-    info->endpoint = _endpointInfo;
     IceInternal::fdToAddressAndPort(_fd, info->localAddress, info->localPort, info->remoteAddress, info->remotePort);
 
     //
@@ -842,14 +841,14 @@ IceSSL::TransceiverI::getConnectionInfo() const
     return populateConnectionInfo(_ssl, _fd, _adapterName, _incoming);
 }
 
-IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo, SOCKET fd,
+IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const string& host, 
                                    const struct sockaddr_storage& addr) :
     IceInternal::NativeInfo(fd),
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _logger(instance->communicator()->getLogger()),
     _stats(instance->communicator()->getStats()),
     _ssl(0),
+    _host(host),
     _incoming(false),
     _state(StateNeedConnect)
 #ifdef ICE_USE_IOCP
@@ -880,11 +879,9 @@ IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, const SSLEndpoin
 #endif
 }
 
-IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo, SOCKET fd, 
-                                   const string& adapterName) :
+IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const string& adapterName) :
     IceInternal::NativeInfo(fd),
     _instance(instance),
-    _endpointInfo(endpointInfo),
     _logger(instance->communicator()->getLogger()),
     _stats(instance->communicator()->getStats()),
     _ssl(0),
diff --git a/cpp/src/IceSSL/TransceiverI.h b/cpp/src/IceSSL/TransceiverI.h
index 526e5b9d47c..f852d7df7c6 100644
--- a/cpp/src/IceSSL/TransceiverI.h
+++ b/cpp/src/IceSSL/TransceiverI.h
@@ -12,7 +12,6 @@
 
 #include <IceSSL/InstanceF.h>
 #include <IceSSL/Plugin.h>
-#include <IceSSL/EndpointInfo.h>
 
 #include <Ice/LoggerF.h>
 #include <Ice/StatsF.h>
@@ -63,8 +62,8 @@ public:
 
 private:
 
-    TransceiverI(const InstancePtr&, const SSLEndpointInfoPtr&, SOCKET, const struct sockaddr_storage&);
-    TransceiverI(const InstancePtr&, const SSLEndpointInfoPtr&, SOCKET, const std::string&);
+    TransceiverI(const InstancePtr&, SOCKET, const std::string&, const struct sockaddr_storage&);
+    TransceiverI(const InstancePtr&, SOCKET, const std::string&);
     virtual ~TransceiverI();
  
 #ifdef ICE_USE_IOCP
@@ -76,12 +75,13 @@ private:
     friend class AcceptorI;
 
     const InstancePtr _instance;
-    const SSLEndpointInfoPtr _endpointInfo;
     const Ice::LoggerPtr _logger;
     const Ice::StatsPtr _stats;
     
     SSL* _ssl;
 
+    const std::string _host;
+
     const bool _incoming;
     const std::string _adapterName;