Added support for EndpointInfo and ConnectionInfo to python.

Set endpoint in Connection getInfo implementations.
Removed unused _stateTime from ConnectionI.
Remove ["cpp:virtual"] from SSLEndpointInfo slice definition.

21 files changed, 111 insertions, 95 deletions

diff --git a/cpp/src/Ice/ConnectionI.cpp b/cpp/src/Ice/ConnectionI.cpp
index 605e898042e..696c966b591 100644
--- a/cpp/src/Ice/ConnectionI.cpp
+++ b/cpp/src/Ice/ConnectionI.cpp
@@ -1521,8 +1521,7 @@ Ice::ConnectionI::ConnectionI(const InstancePtr& instance,
     _readStream(_instance.get()),
     _writeStream(_instance.get()),
     _dispatchCount(0),
-    _state(StateNotInitialized),
-    _stateTime(IceUtil::Time::now(IceUtil::Time::Monotonic))
+    _state(StateNotInitialized)
 {
 
     int& compressionLevel = const_cast<int&>(_compressionLevel);
@@ -1786,7 +1785,6 @@ Ice::ConnectionI::setState(State state)
     }
 
     _state = state;
-    _stateTime = IceUtil::Time::now(IceUtil::Time::Monotonic);
 
     notifyAll();
 
diff --git a/cpp/src/Ice/ConnectionI.h b/cpp/src/Ice/ConnectionI.h
index a023767a63f..5c844ea5cb7 100644
--- a/cpp/src/Ice/ConnectionI.h
+++ b/cpp/src/Ice/ConnectionI.h
@@ -308,7 +308,6 @@ private:
     int _dispatchCount;
 
     State _state; // The current state.
-    IceUtil::Time _stateTime; // The last time when the state was changed.
 };
 
 }
diff --git a/cpp/src/Ice/TcpAcceptor.cpp b/cpp/src/Ice/TcpAcceptor.cpp
index 1b0e4251ba5..9574f7bce0a 100644
--- a/cpp/src/Ice/TcpAcceptor.cpp
+++ b/cpp/src/Ice/TcpAcceptor.cpp
@@ -9,6 +9,7 @@
 
 #include <Ice/TcpAcceptor.h>
 #include <Ice/TcpTransceiver.h>
+#include <Ice/Endpoint.h>
 #include <Ice/Instance.h>
 #include <Ice/TraceLevels.h>
 #include <Ice/LoggerUtil.h>
@@ -168,7 +169,7 @@ IceInternal::TcpAcceptor::accept()
         Trace out(_logger, _traceLevels->networkCat);
         out << "accepted tcp connection\n" << fdToString(fd);
     }
-    return new TcpTransceiver(_instance, fd, true);
+    return new TcpTransceiver(_instance, _endpointInfo, fd, true);
 }
 
 string
@@ -183,11 +184,12 @@ IceInternal::TcpAcceptor::effectivePort() const
     return getPort(_addr);
 }
 
-IceInternal::TcpAcceptor::TcpAcceptor(const InstancePtr& instance, const string& host, int port) :
+IceInternal::TcpAcceptor::TcpAcceptor(const InstancePtr& instance, const TcpEndpointInfoPtr& endpointInfo) :
     _instance(instance),
+    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
-    _addr(getAddressForServer(host, port, instance->protocolSupport()))
+    _addr(getAddressForServer(endpointInfo->host, endpointInfo->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 64406b330be..b4067c9a711 100644
--- a/cpp/src/Ice/TcpAcceptor.h
+++ b/cpp/src/Ice/TcpAcceptor.h
@@ -23,8 +23,6 @@
 namespace IceInternal
 {
 
-class TcpEndpoint;
-
 class TcpAcceptor : public Acceptor, public NativeInfo
 {
 public:
@@ -47,11 +45,12 @@ public:
 
 private:
 
-    TcpAcceptor(const InstancePtr&, const std::string&, int);
+    TcpAcceptor(const InstancePtr&, const Ice::TcpEndpointInfoPtr&);
     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 9d45fdf82bd..e1fdf982cdc 100644
--- a/cpp/src/Ice/TcpConnector.cpp
+++ b/cpp/src/Ice/TcpConnector.cpp
@@ -31,7 +31,8 @@ IceInternal::TcpConnector::connect()
 
     try
     {
-        TransceiverPtr transceiver = new TcpTransceiver(_instance, createSocket(false, _addr.ss_family), false);
+        TransceiverPtr transceiver = 
+            new TcpTransceiver(_instance, _endpointInfo, createSocket(false, _addr.ss_family), false);
         dynamic_cast<TcpTransceiver*>(transceiver.get())->connect(_addr);
         return transceiver;
     }
@@ -120,13 +121,16 @@ IceInternal::TcpConnector::operator<(const Connector& r) const
     return compareAddress(_addr, p->_addr) == -1;
 }
 
-IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance, const struct sockaddr_storage& addr,
-                                        Ice::Int timeout, const string& connectionId) :
+IceInternal::TcpConnector::TcpConnector(const InstancePtr& instance,
+                                        const TcpEndpointInfoPtr& endpointInfo,
+                                        const struct sockaddr_storage& addr,
+                                        const string& connectionId) :
     _instance(instance),
+    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _addr(addr),
-    _timeout(timeout),
+    _timeout(_endpointInfo->timeout),
     _connectionId(connectionId)
 {
 }
diff --git a/cpp/src/Ice/TcpConnector.h b/cpp/src/Ice/TcpConnector.h
index 6f83719cdb8..72453a40c80 100644
--- a/cpp/src/Ice/TcpConnector.h
+++ b/cpp/src/Ice/TcpConnector.h
@@ -11,6 +11,7 @@
 #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>
@@ -40,11 +41,13 @@ public:
 
 private:
     
-    TcpConnector(const InstancePtr&, const struct sockaddr_storage&, Ice::Int, const std::string&);
+    TcpConnector(const InstancePtr&, const Ice::TcpEndpointInfoPtr&, const struct sockaddr_storage&,
+                 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 9d8c761231f..9b18fc3c4ac 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, _host, _port);
+    TcpAcceptor* p = new TcpAcceptor(_instance, TcpEndpointInfoPtr::dynamicCast(getInfo()));
     endp = new TcpEndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
     return p;
 }
@@ -503,7 +503,8 @@ 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, addresses[i], _timeout, _connectionId));
+        connectors.push_back(new TcpConnector(_instance, TcpEndpointInfoPtr::dynamicCast(getInfo()), addresses[i],
+                                              _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/Ice/TcpTransceiver.cpp b/cpp/src/Ice/TcpTransceiver.cpp
index 959c3ce6f87..33ffb3f9e43 100644
--- a/cpp/src/Ice/TcpTransceiver.cpp
+++ b/cpp/src/Ice/TcpTransceiver.cpp
@@ -459,6 +459,7 @@ 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;
 }
@@ -472,8 +473,12 @@ IceInternal::TcpTransceiver::checkSendSize(const Buffer& buf, size_t messageSize
     }
 }
 
-IceInternal::TcpTransceiver::TcpTransceiver(const InstancePtr& instance, SOCKET fd, bool connected) :
+IceInternal::TcpTransceiver::TcpTransceiver(const InstancePtr& instance,
+                                            const TcpEndpointInfoPtr& endpointInfo,
+                                            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 2f131531d0a..81ca7d07c30 100644
--- a/cpp/src/Ice/TcpTransceiver.h
+++ b/cpp/src/Ice/TcpTransceiver.h
@@ -55,7 +55,7 @@ public:
 
 private:
 
-    TcpTransceiver(const InstancePtr&, SOCKET, bool);
+    TcpTransceiver(const InstancePtr&, const Ice::TcpEndpointInfoPtr&, SOCKET, bool);
     virtual ~TcpTransceiver();
 
     void connect(const struct sockaddr_storage&);
@@ -63,6 +63,7 @@ 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 d8a4c5588df..6f6f9b6b8ff 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, _addr, _mcastInterface, _mcastTtl);
+    return new UdpTransceiver(_instance, _endpointInfo, _addr);
 }
 
 Short
@@ -54,32 +54,32 @@ IceInternal::UdpConnector::operator==(const Connector& r) const
         return false;
     }
 
-    if(_protocolMajor != p->_protocolMajor)
+    if(_endpointInfo->protocolMajor != p->_endpointInfo->protocolMajor)
     {
         return false;
     }
 
-    if(_protocolMinor != p->_protocolMinor)
+    if(_endpointInfo->protocolMinor != p->_endpointInfo->protocolMinor)
     {
         return false;
     }
 
-    if(_encodingMajor != p->_encodingMajor)
+    if(_endpointInfo->encodingMajor != p->_endpointInfo->encodingMajor)
     {
         return false;
     }
 
-    if(_encodingMinor != p->_encodingMinor)
+    if(_endpointInfo->encodingMinor != p->_endpointInfo->encodingMinor)
     {
         return false;
     }
 
-    if(_mcastTtl != p->_mcastTtl)
+    if(_endpointInfo->mcastTtl != p->_endpointInfo->mcastTtl)
     {
         return false;
     }
 
-    if(_mcastInterface != p->_mcastInterface)
+    if(_endpointInfo->mcastInterface != p->_endpointInfo->mcastInterface)
     {
         return false;
     }
@@ -111,56 +111,56 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
         return false;
     }
 
-    if(_protocolMajor < p->_protocolMajor)
+    if(_endpointInfo->protocolMajor < p->_endpointInfo->protocolMajor)
     {
         return true;
     }
-    else if(p->_protocolMajor < _protocolMajor)
+    else if(p->_endpointInfo->protocolMajor < _endpointInfo->protocolMajor)
     {
         return false;
     }
 
-    if(_protocolMinor < p->_protocolMinor)
+    if(_endpointInfo->protocolMinor < p->_endpointInfo->protocolMinor)
     {
         return true;
     }
-    else if(p->_protocolMinor < _protocolMinor)
+    else if(p->_endpointInfo->protocolMinor < _endpointInfo->protocolMinor)
     {
         return false;
     }
 
-    if(_encodingMajor < p->_encodingMajor)
+    if(_endpointInfo->encodingMajor < p->_endpointInfo->encodingMajor)
     {
         return true;
     }
-    else if(p->_encodingMajor < _encodingMajor)
+    else if(p->_endpointInfo->encodingMajor < _endpointInfo->encodingMajor)
     {
         return false;
     }
 
-    if(_encodingMinor < p->_encodingMinor)
+    if(_endpointInfo->encodingMinor < p->_endpointInfo->encodingMinor)
     {
         return true;
     }
-    else if(p->_encodingMinor < _encodingMinor)
+    else if(p->_endpointInfo->encodingMinor < _endpointInfo->encodingMinor)
     {
         return false;
     }
 
-    if(_mcastTtl < p->_mcastTtl)
+    if(_endpointInfo->mcastTtl < p->_endpointInfo->mcastTtl)
     {
         return true;
     }
-    else if(p->_mcastTtl < _mcastTtl)
+    else if(p->_endpointInfo->mcastTtl < _endpointInfo->mcastTtl)
     {
         return false;
     }
 
-    if(_mcastInterface < p->_mcastInterface)
+    if(_endpointInfo->mcastInterface < p->_endpointInfo->mcastInterface)
     {
         return true;
     }
-    else if(p->_mcastInterface < _mcastInterface)
+    else if(p->_endpointInfo->mcastInterface < _endpointInfo->mcastInterface)
     {
         return false;
     }
@@ -169,18 +169,13 @@ IceInternal::UdpConnector::operator<(const Connector& r) const
 }
 
 
-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,
+IceInternal::UdpConnector::UdpConnector(const InstancePtr& instance,
+                                        const UdpEndpointInfoPtr& endpointInfo,
+                                        const struct sockaddr_storage& addr, 
                                         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 4e27190ac1e..924d02bba7c 100644
--- a/cpp/src/Ice/UdpConnector.h
+++ b/cpp/src/Ice/UdpConnector.h
@@ -11,6 +11,7 @@
 #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>
@@ -39,19 +40,14 @@ public:
 
 private:
     
-    UdpConnector(const InstancePtr&, const struct sockaddr_storage&, const std::string&, int, Ice::Byte, Ice::Byte, 
-                 Ice::Byte, Ice::Byte, const std::string&);
+    UdpConnector(const InstancePtr&, const Ice::UdpEndpointInfoPtr&, const struct sockaddr_storage&,
+                 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 bbd273cfa54..298bb72b800 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, _host, _port, _mcastInterface, _connect);
+    UdpTransceiver* p = new UdpTransceiver(_instance, UdpEndpointInfoPtr::dynamicCast(getInfo()), _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, addresses[i], _mcastInterface, _mcastTtl, _protocolMajor,
-                                              _protocolMinor, _encodingMajor, _encodingMinor, _connectionId));
+        connectors.push_back(new UdpConnector(_instance, UdpEndpointInfoPtr::dynamicCast(getInfo()), addresses[i],
+                                              _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/Ice/UdpTransceiver.cpp b/cpp/src/Ice/UdpTransceiver.cpp
index fbf00a1048a..8cd68d76edb 100644
--- a/cpp/src/Ice/UdpTransceiver.cpp
+++ b/cpp/src/Ice/UdpTransceiver.cpp
@@ -457,6 +457,7 @@ 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;
@@ -482,8 +483,10 @@ IceInternal::UdpTransceiver::effectivePort() const
     return getPort(_addr);
 }
 
-IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance, const struct sockaddr_storage& addr,
-                                            const string& mcastInterface, int mcastTtl) :
+IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance,
+                                            const Ice::UdpEndpointInfoPtr& endpointInfo,
+                                            const struct sockaddr_storage& addr) :
+    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _stats(instance->initializationData().stats),
@@ -510,24 +513,26 @@ IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance, const s
     
     if(isMulticast(_addr))
     {
-        if(mcastInterface.length() > 0)
+        if(endpointInfo->mcastInterface.length() > 0)
         {
-            setMcastInterface(_fd, mcastInterface, _addr.ss_family == AF_INET);
+            setMcastInterface(_fd, endpointInfo->mcastInterface, _addr.ss_family == AF_INET);
         }
-        if(mcastTtl != -1)
+        if(endpointInfo->mcastTtl != -1)
         {
-            setMcastTtl(_fd, mcastTtl, _addr.ss_family == AF_INET);
+            setMcastTtl(_fd, endpointInfo->mcastTtl, _addr.ss_family == AF_INET);
         }
     }
 }
 
-IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance, const string& host, int port,
-                                            const string& mcastInterface, bool connect) :
+IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance,
+                                            const Ice::UdpEndpointInfoPtr& endpointInfo,
+                                            bool connect) :
+    _endpointInfo(endpointInfo),
     _traceLevels(instance->traceLevels()),
     _logger(instance->initializationData().logger),
     _stats(instance->initializationData().stats),
     _incoming(true),
-    _addr(getAddressForServer(host, port, instance->protocolSupport())),
+    _addr(getAddressForServer(_endpointInfo->host, _endpointInfo->port, instance->protocolSupport())),
     _connect(connect),
     _warn(instance->initializationData().properties->getPropertyAsInt("Ice.Warn.Datagrams") > 0)
 #ifdef ICE_USE_IOCP
@@ -564,7 +569,7 @@ IceInternal::UdpTransceiver::UdpTransceiver(const InstancePtr& instance, const s
         {
             setPort(_mcastAddr, getPort(_addr));
         }
-        setMcastGroup(_fd, _mcastAddr, mcastInterface);
+        setMcastGroup(_fd, _mcastAddr, _endpointInfo->mcastInterface);
     }
     else
     {
diff --git a/cpp/src/Ice/UdpTransceiver.h b/cpp/src/Ice/UdpTransceiver.h
index f7c918184a8..a8a3194a607 100644
--- a/cpp/src/Ice/UdpTransceiver.h
+++ b/cpp/src/Ice/UdpTransceiver.h
@@ -61,8 +61,8 @@ public:
 
 private:
 
-    UdpTransceiver(const InstancePtr&, const struct sockaddr_storage&, const std::string&, int);
-    UdpTransceiver(const InstancePtr&, const std::string&, int, const std::string&, bool);
+    UdpTransceiver(const InstancePtr&, const Ice::UdpEndpointInfoPtr&, const struct sockaddr_storage&);
+    UdpTransceiver(const InstancePtr&, const Ice::UdpEndpointInfoPtr&, bool);
     virtual ~UdpTransceiver();
 
     void setBufSize(const InstancePtr&);
@@ -70,6 +70,7 @@ 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 c82a77dc4dc..e8de9f97a87 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, fd, _adapterName);
+    return new TransceiverI(_instance, _endpointInfo, fd, _adapterName);
 }
 
 string
@@ -210,11 +210,13 @@ IceSSL::AcceptorI::effectivePort() const
     }
 }
 
-IceSSL::AcceptorI::AcceptorI(const InstancePtr& instance, const string& adapterName, const string& host, int port) :
+IceSSL::AcceptorI::AcceptorI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo,
+                             const string& adapterName) :
     _instance(instance),
+    _endpointInfo(endpointInfo),
     _adapterName(adapterName),
     _logger(instance->communicator()->getLogger()),
-    _addr(IceInternal::getAddressForServer(host, port, instance->protocolSupport()))
+    _addr(IceInternal::getAddressForServer(_endpointInfo->host, _endpointInfo->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 71ce3991b2b..df84201cd9f 100644
--- a/cpp/src/IceSSL/AcceptorI.h
+++ b/cpp/src/IceSSL/AcceptorI.h
@@ -15,6 +15,7 @@
 #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
@@ -49,11 +50,12 @@ public:
 
 private:
 
-    AcceptorI(const InstancePtr&, const std::string&, const std::string&, int);
+    AcceptorI(const InstancePtr&, const SSLEndpointInfoPtr&, const std::string&);
     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 9b5e14a6fe9..fad1c651c13 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, IceInternal::createSocket(false, _addr.ss_family), _host, _addr);
+        return new TransceiverI(_instance, _endpointInfo, IceInternal::createSocket(false, _addr.ss_family), _addr);
     }
     catch(const Ice::LocalException& ex)
     {
@@ -81,7 +81,7 @@ IceSSL::ConnectorI::operator==(const IceInternal::Connector& r) const
         return false;
     }
 
-    if(_timeout != p->_timeout)
+    if(_endpointInfo->timeout != p->_endpointInfo->timeout)
     {
         return false;
     }
@@ -109,11 +109,11 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
         return type() < r.type();
     }
 
-    if(_timeout < p->_timeout)
+    if(_endpointInfo->timeout < p->_endpointInfo->timeout)
     {
         return true;
     }
-    else if(p->_timeout < _timeout)
+    else if(p->_endpointInfo->timeout < _endpointInfo->timeout)
     {
         return false;
     }
@@ -130,13 +130,12 @@ IceSSL::ConnectorI::operator<(const IceInternal::Connector& r) const
     return IceInternal::compareAddress(_addr, p->_addr) == -1;
 }
 
-IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const string& host, const struct sockaddr_storage& addr,
-                               Ice::Int timeout, const string& connectionId) :
+IceSSL::ConnectorI::ConnectorI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo,
+                               const struct sockaddr_storage& addr, 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 d8c79a6e0c4..163f87d5add 100644
--- a/cpp/src/IceSSL/ConnectorI.h
+++ b/cpp/src/IceSSL/ConnectorI.h
@@ -14,6 +14,7 @@
 #include <Ice/TransceiverF.h>
 #include <Ice/Connector.h>
 #include <IceSSL/InstanceF.h>
+#include <IceSSL/EndpointInfo.h>
 
 #ifdef _WIN32
 #   include <winsock2.h>
@@ -41,15 +42,14 @@ public:
 
 private:
     
-    ConnectorI(const InstancePtr&, const std::string&, const struct sockaddr_storage&, Ice::Int, const std::string&);
+    ConnectorI(const InstancePtr&, const SSLEndpointInfoPtr&, const struct sockaddr_storage&, 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 c21db89353c..8166574bf65 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, adapterName, _host, _port);
+    AcceptorI* p = new AcceptorI(_instance, SSLEndpointInfoPtr::dynamicCast(getInfo()), adapterName);
     endp = new EndpointI(_instance, _host, p->effectivePort(), _timeout, _connectionId, _compress);
     return p;
 }
@@ -502,7 +502,8 @@ 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, _host, addresses[i], _timeout, _connectionId));
+        connectors.push_back(new ConnectorI(_instance, SSLEndpointInfoPtr::dynamicCast(getInfo()), addresses[i],
+                                            _connectionId));
     }
     return connectors;
 }
diff --git a/cpp/src/IceSSL/TransceiverI.cpp b/cpp/src/IceSSL/TransceiverI.cpp
index 28f59e93756..1c95553e46a 100644
--- a/cpp/src/IceSSL/TransceiverI.cpp
+++ b/cpp/src/IceSSL/TransceiverI.cpp
@@ -234,7 +234,7 @@ IceSSL::TransceiverI::initialize()
             }
         }
 
-        _instance->verifyPeer(_ssl, _fd, _host, _adapterName, _incoming);
+        _instance->verifyPeer(_ssl, _fd, _endpointInfo->host, _adapterName, _incoming);
         _state = StateHandshakeComplete;
     }
     catch(const Ice::LocalException& ex)
@@ -784,6 +784,7 @@ 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);
 
     //
@@ -841,14 +842,14 @@ IceSSL::TransceiverI::getConnectionInfo() const
     return populateConnectionInfo(_ssl, _fd, _adapterName, _incoming);
 }
 
-IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const string& host, 
+IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo, SOCKET fd,
                                    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
@@ -879,9 +880,11 @@ IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const
 #endif
 }
 
-IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, SOCKET fd, const string& adapterName) :
+IceSSL::TransceiverI::TransceiverI(const InstancePtr& instance, const SSLEndpointInfoPtr& endpointInfo, 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 f852d7df7c6..526e5b9d47c 100644
--- a/cpp/src/IceSSL/TransceiverI.h
+++ b/cpp/src/IceSSL/TransceiverI.h
@@ -12,6 +12,7 @@
 
 #include <IceSSL/InstanceF.h>
 #include <IceSSL/Plugin.h>
+#include <IceSSL/EndpointInfo.h>
 
 #include <Ice/LoggerF.h>
 #include <Ice/StatsF.h>
@@ -62,8 +63,8 @@ public:
 
 private:
 
-    TransceiverI(const InstancePtr&, SOCKET, const std::string&, const struct sockaddr_storage&);
-    TransceiverI(const InstancePtr&, SOCKET, const std::string&);
+    TransceiverI(const InstancePtr&, const SSLEndpointInfoPtr&, SOCKET, const struct sockaddr_storage&);
+    TransceiverI(const InstancePtr&, const SSLEndpointInfoPtr&, SOCKET, const std::string&);
     virtual ~TransceiverI();
  
 #ifdef ICE_USE_IOCP
@@ -75,13 +76,12 @@ 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;