default protocol

11 files changed, 120 insertions, 90 deletions

diff --git a/cpp/slice/Ice/Current.ice b/cpp/slice/Ice/Current.ice
index 09352ed23da..72f6661812a 100644
--- a/cpp/slice/Ice/Current.ice
+++ b/cpp/slice/Ice/Current.ice
@@ -64,7 +64,6 @@ module Ice
      *
      * Set to true if the operation is nonmutating.
      *
-     *
      **/
     bool \nonmutating;
 
diff --git a/cpp/src/Ice/Collector.cpp b/cpp/src/Ice/Collector.cpp
index e465bf6a01f..8bf86162a75 100644
--- a/cpp/src/Ice/Collector.cpp
+++ b/cpp/src/Ice/Collector.cpp
@@ -628,7 +628,7 @@ IceInternal::CollectorFactory::CollectorFactory(const InstancePtr& instance,
 
     try
     {
-	_transceiver = _endpoint->serverTransceiver(_instance, _endpoint);
+	_transceiver = _endpoint->serverTransceiver(_endpoint);
 	if (_transceiver)
 	{
 	    CollectorPtr collector = new Collector(_instance, _adapter, _transceiver, _endpoint);
@@ -636,7 +636,7 @@ IceInternal::CollectorFactory::CollectorFactory(const InstancePtr& instance,
 	}
 	else
 	{
-	    _acceptor = _endpoint->acceptor(_instance, _endpoint);
+	    _acceptor = _endpoint->acceptor(_endpoint);
 	    assert(_acceptor);
 	    _acceptor->listen();
 	    _threadPool = _instance->threadPool();
diff --git a/cpp/src/Ice/Emitter.cpp b/cpp/src/Ice/Emitter.cpp
index 47d24e65404..5990cb68e7e 100644
--- a/cpp/src/Ice/Emitter.cpp
+++ b/cpp/src/Ice/Emitter.cpp
@@ -473,10 +473,10 @@ IceInternal::EmitterFactory::create(const vector<EndpointPtr>& endpoints)
     {
 	try
 	{
-	    TransceiverPtr transceiver = (*q)->clientTransceiver(_instance);
+	    TransceiverPtr transceiver = (*q)->clientTransceiver();
 	    if (!transceiver)
 	    {
-		ConnectorPtr connector = (*q)->connector(_instance);
+		ConnectorPtr connector = (*q)->connector();
 		assert(connector);
 		transceiver = connector->connect((*q)->timeout());
 		assert(transceiver);
diff --git a/cpp/src/Ice/Endpoint.cpp b/cpp/src/Ice/Endpoint.cpp
index 260c1d0a9e6..a5677a81376 100644
--- a/cpp/src/Ice/Endpoint.cpp
+++ b/cpp/src/Ice/Endpoint.cpp
@@ -19,6 +19,7 @@
 #include <Ice/UdpTransceiver.h>
 #include <Ice/BasicStream.h>
 #include <Ice/Exception.h>
+#include <Ice/Instance.h>
 
 using namespace std;
 using namespace Ice;
@@ -28,7 +29,7 @@ void IceInternal::incRef(Endpoint* p) { p->__incRef(); }
 void IceInternal::decRef(Endpoint* p) { p->__decRef(); }
 
 EndpointPtr
-IceInternal::Endpoint::endpointFromString(const string& str)
+IceInternal::Endpoint::endpointFromString(const InstancePtr& instance, const string& str)
 {
     const string delim = " \t\n\r";
 
@@ -44,19 +45,26 @@ IceInternal::Endpoint::endpointFromString(const string& str)
 	end = str.length();
     }
 
-    if (str.compare(beg, end - beg, "tcp") == 0)
+    string protocol = str.substr(beg, end - beg);
+
+    if (protocol == "default")
     {
-	return new TcpEndpoint(str.substr(end));
+	protocol = instance->defaultProtocol();
     }
 
-    if (str.compare(beg, end - beg, "ssl") == 0)
+    if (protocol == "tcp")
     {
-	return new SslEndpoint(str.substr(end));
+	return new TcpEndpoint(instance, str.substr(end));
     }
 
-    if (str.compare(beg, end - beg, "udp") == 0)
+    if (protocol == "ssl")
     {
-	return new UdpEndpoint(str.substr(end));
+	return new SslEndpoint(instance, str.substr(end));
+    }
+
+    if (protocol == "udp")
+    {
+	return new UdpEndpoint(instance, str.substr(end));
     }
 
     throw EndpointParseException(__FILE__, __LINE__);
@@ -96,7 +104,8 @@ IceInternal::Endpoint::streamRead(BasicStream* s, EndpointPtr& v)
     }
 }
 
-IceInternal::UnknownEndpoint::UnknownEndpoint(BasicStream* s)
+IceInternal::UnknownEndpoint::UnknownEndpoint(BasicStream* s) :
+    _instance(s->instance())
 {
     s->read(const_cast<vector<Byte>&>(_rawBytes));
 }
@@ -151,26 +160,26 @@ IceInternal::UnknownEndpoint::secure() const
 }
 
 TransceiverPtr
-IceInternal::UnknownEndpoint::clientTransceiver(const InstancePtr&) const
+IceInternal::UnknownEndpoint::clientTransceiver() const
 {
     return 0;
 }
 
 TransceiverPtr
-IceInternal::UnknownEndpoint::serverTransceiver(const InstancePtr&, EndpointPtr& endp) const
+IceInternal::UnknownEndpoint::serverTransceiver(EndpointPtr& endp) const
 {
     endp = const_cast<UnknownEndpoint*>(this);
     return 0;
 }
 
 ConnectorPtr
-IceInternal::UnknownEndpoint::connector(const InstancePtr& instance) const
+IceInternal::UnknownEndpoint::connector() const
 {
     return 0;
 }
 
 AcceptorPtr
-IceInternal::UnknownEndpoint::acceptor(const InstancePtr& instance, EndpointPtr& endp) const
+IceInternal::UnknownEndpoint::acceptor(EndpointPtr& endp) const
 {
     endp = const_cast<UnknownEndpoint*>(this);
     return 0;
@@ -236,14 +245,16 @@ IceInternal::UnknownEndpoint::operator<(const Endpoint& r) const
     return false;
 }
 
-IceInternal::TcpEndpoint::TcpEndpoint(const string& ho, Int po, Int ti) :
+IceInternal::TcpEndpoint::TcpEndpoint(const InstancePtr& instance, const string& ho, Int po, Int ti) :
+    _instance(instance),
     _host(ho),
     _port(po),
     _timeout(ti)
 {
 }
 
-IceInternal::TcpEndpoint::TcpEndpoint(const string& str) :
+IceInternal::TcpEndpoint::TcpEndpoint(const InstancePtr& instance, const string& str) :
+    _instance(instance),
     _port(0),
     _timeout(-1)
 {
@@ -335,6 +346,7 @@ IceInternal::TcpEndpoint::TcpEndpoint(const string& str) :
 }
 
 IceInternal::TcpEndpoint::TcpEndpoint(BasicStream* s) :
+    _instance(s->instance()),
     _port(0),
     _timeout(-1)
 {
@@ -403,7 +415,7 @@ IceInternal::TcpEndpoint::timeout(Int timeout) const
     }
     else
     {
-	return new TcpEndpoint(_host, _port, timeout);
+	return new TcpEndpoint(_instance, _host, _port, timeout);
     }
 }
 
@@ -420,29 +432,29 @@ IceInternal::TcpEndpoint::secure() const
 }
 
 TransceiverPtr
-IceInternal::TcpEndpoint::clientTransceiver(const InstancePtr&) const
+IceInternal::TcpEndpoint::clientTransceiver() const
 {
     return 0;
 }
 
 TransceiverPtr
-IceInternal::TcpEndpoint::serverTransceiver(const InstancePtr&, EndpointPtr& endp) const
+IceInternal::TcpEndpoint::serverTransceiver(EndpointPtr& endp) const
 {
     endp = const_cast<TcpEndpoint*>(this);
     return 0;
 }
 
 ConnectorPtr
-IceInternal::TcpEndpoint::connector(const InstancePtr& instance) const
+IceInternal::TcpEndpoint::connector() const
 {
-    return new TcpConnector(instance, _host, _port);
+    return new TcpConnector(_instance, _host, _port);
 }
 
 AcceptorPtr
-IceInternal::TcpEndpoint::acceptor(const InstancePtr& instance, EndpointPtr& endp) const
+IceInternal::TcpEndpoint::acceptor(EndpointPtr& endp) const
 {
-    TcpAcceptor* p = new TcpAcceptor(instance, _port);
-    endp = new TcpEndpoint(_host, p->effectivePort(), _timeout);
+    TcpAcceptor* p = new TcpAcceptor(_instance, _port);
+    endp = new TcpEndpoint(_instance, _host, p->effectivePort(), _timeout);
     return p;
 }
 
@@ -562,14 +574,16 @@ IceInternal::TcpEndpoint::operator<(const Endpoint& r) const
     return false;
 }
 
-IceInternal::SslEndpoint::SslEndpoint(const string& ho, Int po, Int ti) :
+IceInternal::SslEndpoint::SslEndpoint(const InstancePtr& instance, const string& ho, Int po, Int ti) :
+    _instance(instance),
     _host(ho),
     _port(po),
     _timeout(ti)
 {
 }
 
-IceInternal::SslEndpoint::SslEndpoint(const string& str) :
+IceInternal::SslEndpoint::SslEndpoint(const InstancePtr& instance, const string& str) :
+    _instance(instance),
     _port(0),
     _timeout(-1)
 {
@@ -647,6 +661,7 @@ IceInternal::SslEndpoint::SslEndpoint(const string& str) :
 }
 
 IceInternal::SslEndpoint::SslEndpoint(BasicStream* s) :
+    _instance(s->instance()),
     _port(0),
     _timeout(-1)
 {
@@ -672,7 +687,7 @@ string
 IceInternal::SslEndpoint::toString() const
 {
     ostringstream s;
-    s << "tcp";
+    s << "ssl";
     if (_host != getLocalHost(true)) // TODO: Whether numeric or not should be configurable
     {
 	s << " -h " << _host;
@@ -715,7 +730,7 @@ IceInternal::SslEndpoint::timeout(Int timeout) const
     }
     else
     {
-	return new SslEndpoint(_host, _port, timeout);
+	return new SslEndpoint(_instance, _host, _port, timeout);
     }
 }
 
@@ -732,29 +747,29 @@ IceInternal::SslEndpoint::secure() const
 }
 
 TransceiverPtr
-IceInternal::SslEndpoint::clientTransceiver(const InstancePtr&) const
+IceInternal::SslEndpoint::clientTransceiver() const
 {
     return 0;
 }
 
 TransceiverPtr
-IceInternal::SslEndpoint::serverTransceiver(const InstancePtr&, EndpointPtr& endp) const
+IceInternal::SslEndpoint::serverTransceiver(EndpointPtr& endp) const
 {
     endp = const_cast<SslEndpoint*>(this);
     return 0;
 }
 
 ConnectorPtr
-IceInternal::SslEndpoint::connector(const InstancePtr& instance) const
+IceInternal::SslEndpoint::connector() const
 {
-    return new SslConnector(instance, _host, _port);
+    return new SslConnector(_instance, _host, _port);
 }
 
 AcceptorPtr
-IceInternal::SslEndpoint::acceptor(const InstancePtr& instance, EndpointPtr& endp) const
+IceInternal::SslEndpoint::acceptor(EndpointPtr& endp) const
 {
-    SslAcceptor* p = new SslAcceptor(instance, _port);
-    endp = new SslEndpoint(_host, p->effectivePort(), _timeout);
+    SslAcceptor* p = new SslAcceptor(_instance, _port);
+    endp = new SslEndpoint(_instance, _host, p->effectivePort(), _timeout);
     return p;
 }
 
@@ -874,13 +889,15 @@ IceInternal::SslEndpoint::operator<(const Endpoint& r) const
     return false;
 }
 
-IceInternal::UdpEndpoint::UdpEndpoint(const string& ho, Int po) :
+IceInternal::UdpEndpoint::UdpEndpoint(const InstancePtr& instance, const string& ho, Int po) :
+    _instance(instance),
     _host(ho),
     _port(po)
 {
 }
 
-IceInternal::UdpEndpoint::UdpEndpoint(const string& str) :
+IceInternal::UdpEndpoint::UdpEndpoint(const InstancePtr& instance, const string& str) :
+    _instance(instance),
     _port(0)
 {
     const string delim = " \t\n\r";
@@ -951,6 +968,7 @@ IceInternal::UdpEndpoint::UdpEndpoint(const string& str) :
 }
 
 IceInternal::UdpEndpoint::UdpEndpoint(BasicStream* s) :
+    _instance(s->instance()),
     _port(0)
 {
     s->startReadEncaps();
@@ -1022,27 +1040,27 @@ IceInternal::UdpEndpoint::secure() const
 }
 
 TransceiverPtr
-IceInternal::UdpEndpoint::clientTransceiver(const InstancePtr& instance) const
+IceInternal::UdpEndpoint::clientTransceiver() const
 {
-    return new UdpTransceiver(instance, _host, _port);
+    return new UdpTransceiver(_instance, _host, _port);
 }
 
 TransceiverPtr
-IceInternal::UdpEndpoint::serverTransceiver(const InstancePtr& instance, EndpointPtr& endp) const
+IceInternal::UdpEndpoint::serverTransceiver(EndpointPtr& endp) const
 {
-    UdpTransceiver* p = new UdpTransceiver(instance, _port);
-    endp = new UdpEndpoint(_host, p->effectivePort());
+    UdpTransceiver* p = new UdpTransceiver(_instance, _port);
+    endp = new UdpEndpoint(_instance, _host, p->effectivePort());
     return p;
 }
 
 ConnectorPtr
-IceInternal::UdpEndpoint::connector(const InstancePtr&) const
+IceInternal::UdpEndpoint::connector() const
 {
     return 0;
 }
 
 AcceptorPtr
-IceInternal::UdpEndpoint::acceptor(const InstancePtr&, EndpointPtr& endp) const
+IceInternal::UdpEndpoint::acceptor(EndpointPtr& endp) const
 {
     endp = const_cast<UdpEndpoint*>(this);
     return 0;
diff --git a/cpp/src/Ice/Endpoint.h b/cpp/src/Ice/Endpoint.h
index d3374b53b4c..8132ccc7acc 100644
--- a/cpp/src/Ice/Endpoint.h
+++ b/cpp/src/Ice/Endpoint.h
@@ -32,12 +32,10 @@ class Endpoint : public ::IceUtil::Shared
 {
 public:
 
-    Endpoint() { }
-
     //
     // Create an endpoint from a string
     //
-    static EndpointPtr endpointFromString(const std::string&);
+    static EndpointPtr endpointFromString(const InstancePtr&, const std::string&);
     
     //
     // Unmarshal an endpoint
@@ -91,7 +89,7 @@ public:
     // Return a client side transceiver for this endpoint, or null if a
     // transceiver can only be created by a connector.
     //
-    virtual TransceiverPtr clientTransceiver(const InstancePtr&) const = 0;
+    virtual TransceiverPtr clientTransceiver() const = 0;
 
     //
     // Return a server side transceiver for this endpoint, or null if a
@@ -100,13 +98,13 @@ public:
     // "effective" endpoint, which might differ from this endpoint,
     // for example, if a dynamic port number is assigned.
     //
-    virtual TransceiverPtr serverTransceiver(const InstancePtr&, EndpointPtr&) const = 0;
+    virtual TransceiverPtr serverTransceiver(EndpointPtr&) const = 0;
 
     //
     // Return a connector for this endpoint, or null if no connector
     // is available.
     //
-    virtual ConnectorPtr connector(const InstancePtr&) const = 0;
+    virtual ConnectorPtr connector() const = 0;
 
     //
     // Return an acceptor for this endpoint, or null if no acceptors
@@ -115,7 +113,7 @@ public:
     // from this endpoint, for example, if a dynamic port number is
     // assigned.
     //
-    virtual AcceptorPtr acceptor(const InstancePtr&, EndpointPtr&) const = 0;
+    virtual AcceptorPtr acceptor(EndpointPtr&) const = 0;
 
     //
     // Check whether the endpoint is equivalent to a specific
@@ -145,10 +143,10 @@ public:
     virtual EndpointPtr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual TransceiverPtr clientTransceiver(const InstancePtr&) const;
-    virtual TransceiverPtr serverTransceiver(const InstancePtr&, EndpointPtr&) const;
-    virtual ConnectorPtr connector(const InstancePtr&) const;
-    virtual AcceptorPtr acceptor(const InstancePtr&, EndpointPtr&) const;
+    virtual TransceiverPtr clientTransceiver() const;
+    virtual TransceiverPtr serverTransceiver(EndpointPtr&) const;
+    virtual ConnectorPtr connector() const;
+    virtual AcceptorPtr acceptor(EndpointPtr&) const;
     virtual bool equivalent(const TransceiverPtr&) const;
     virtual bool equivalent(const AcceptorPtr&) const;
 
@@ -160,6 +158,7 @@ private:
     //
     // All members are const, because endpoints are immutable.
     //
+    const InstancePtr _instance;
     const std::vector< ::Ice::Byte> _rawBytes;
 };
 
@@ -167,8 +166,8 @@ class TcpEndpoint : public Endpoint
 {
 public:
 
-    TcpEndpoint(const std::string&, ::Ice::Int, ::Ice::Int);
-    TcpEndpoint(const std::string&);
+    TcpEndpoint(const InstancePtr&, const std::string&, ::Ice::Int, ::Ice::Int);
+    TcpEndpoint(const InstancePtr&, const std::string&);
     TcpEndpoint(BasicStream*);
 
     virtual void streamWrite(BasicStream*) const;
@@ -179,10 +178,10 @@ public:
     virtual EndpointPtr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual TransceiverPtr clientTransceiver(const InstancePtr&) const;
-    virtual TransceiverPtr serverTransceiver(const InstancePtr&, EndpointPtr&) const;
-    virtual ConnectorPtr connector(const InstancePtr&) const;
-    virtual AcceptorPtr acceptor(const InstancePtr&, EndpointPtr&) const;
+    virtual TransceiverPtr clientTransceiver() const;
+    virtual TransceiverPtr serverTransceiver(EndpointPtr&) const;
+    virtual ConnectorPtr connector() const;
+    virtual AcceptorPtr acceptor(EndpointPtr&) const;
     virtual bool equivalent(const TransceiverPtr&) const;
     virtual bool equivalent(const AcceptorPtr&) const;
 
@@ -194,6 +193,7 @@ private:
     //
     // All members are const, because endpoints are immutable.
     //
+    const InstancePtr _instance;
     const std::string _host;
     const ::Ice::Int _port;
     const ::Ice::Int _timeout;
@@ -203,8 +203,8 @@ class SslEndpoint : public Endpoint
 {
 public:
 
-    SslEndpoint(const std::string&, ::Ice::Int, ::Ice::Int);
-    SslEndpoint(const std::string&);
+    SslEndpoint(const InstancePtr&, const std::string&, ::Ice::Int, ::Ice::Int);
+    SslEndpoint(const InstancePtr&, const std::string&);
     SslEndpoint(BasicStream*);
 
     virtual void streamWrite(BasicStream*) const;
@@ -215,10 +215,10 @@ public:
     virtual EndpointPtr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual TransceiverPtr clientTransceiver(const InstancePtr&) const;
-    virtual TransceiverPtr serverTransceiver(const InstancePtr&, EndpointPtr&) const;
-    virtual ConnectorPtr connector(const InstancePtr&) const;
-    virtual AcceptorPtr acceptor(const InstancePtr&, EndpointPtr&) const;
+    virtual TransceiverPtr clientTransceiver() const;
+    virtual TransceiverPtr serverTransceiver(EndpointPtr&) const;
+    virtual ConnectorPtr connector() const;
+    virtual AcceptorPtr acceptor(EndpointPtr&) const;
     virtual bool equivalent(const TransceiverPtr&) const;
     virtual bool equivalent(const AcceptorPtr&) const;
 
@@ -230,6 +230,7 @@ private:
     //
     // All members are const, because endpoints are immutable.
     //
+    const InstancePtr _instance;
     const std::string _host;
     const ::Ice::Int _port;
     const ::Ice::Int _timeout;
@@ -239,8 +240,8 @@ class UdpEndpoint : public Endpoint
 {
 public:
 
-    UdpEndpoint(const std::string&, ::Ice::Int);
-    UdpEndpoint(const std::string&);
+    UdpEndpoint(const InstancePtr&, const std::string&, ::Ice::Int);
+    UdpEndpoint(const InstancePtr&, const std::string&);
     UdpEndpoint(BasicStream*);
 
     virtual void streamWrite(BasicStream*) const;
@@ -251,10 +252,10 @@ public:
     virtual EndpointPtr timeout(::Ice::Int) const;
     virtual bool datagram() const;
     virtual bool secure() const;
-    virtual TransceiverPtr clientTransceiver(const InstancePtr&) const;
-    virtual TransceiverPtr serverTransceiver(const InstancePtr&, EndpointPtr&) const;
-    virtual ConnectorPtr connector(const InstancePtr&) const;
-    virtual AcceptorPtr acceptor(const InstancePtr&, EndpointPtr&) const;
+    virtual TransceiverPtr clientTransceiver() const;
+    virtual TransceiverPtr serverTransceiver(EndpointPtr&) const;
+    virtual ConnectorPtr connector() const;
+    virtual AcceptorPtr acceptor(EndpointPtr&) const;
     virtual bool equivalent(const TransceiverPtr&) const;
     virtual bool equivalent(const AcceptorPtr&) const;
 
@@ -266,6 +267,7 @@ private:
     //
     // All members are const, because endpoints are immutable.
     //
+    const InstancePtr _instance;
     const std::string _host;
     const ::Ice::Int _port;
 };
diff --git a/cpp/src/Ice/IdentityUtil.cpp b/cpp/src/Ice/IdentityUtil.cpp
index 4dc378b3edf..3de6804841d 100644
--- a/cpp/src/Ice/IdentityUtil.cpp
+++ b/cpp/src/Ice/IdentityUtil.cpp
@@ -28,7 +28,7 @@ Ice::stringToIdentity(const string& s)
     if (pos != string::npos)
     {
 	ident.category = s.substr(0, pos);
-	ident.name = s.substr(pos+1);
+	ident.name = s.substr(pos + 1);
     }
     else
     {
diff --git a/cpp/src/Ice/Instance.cpp b/cpp/src/Ice/Instance.cpp
index 33895d85e31..4740a822b3c 100644
--- a/cpp/src/Ice/Instance.cpp
+++ b/cpp/src/Ice/Instance.cpp
@@ -141,6 +141,14 @@ IceInternal::Instance::threadPool()
     return _threadPool;
 }
 
+string
+IceInternal::Instance::defaultProtocol()
+{
+    // No synchronization necessary
+    // JTCSyncT<JTCMutex> sync(*this);
+    return _defaultProtocol;
+}
+
 IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const PropertiesPtr& properties) :
     _communicator(communicator),
     _properties(properties)
@@ -256,6 +264,11 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Prope
 	_userExceptionFactoryManager = new UserExceptionFactoryManager();
 	_objectAdapterFactory = new ObjectAdapterFactory(this);
 	_threadPool = new ThreadPool(this);
+	_defaultProtocol = _properties->getProperty("Ice.DefaultProtocol");
+	if (_defaultProtocol.empty())
+	{
+	    _defaultProtocol = "tcp";
+	}
     }
     catch(...)
     {
diff --git a/cpp/src/Ice/Instance.h b/cpp/src/Ice/Instance.h
index 2fb52bedca1..76b98602794 100644
--- a/cpp/src/Ice/Instance.h
+++ b/cpp/src/Ice/Instance.h
@@ -50,6 +50,7 @@ public:
     UserExceptionFactoryManagerPtr userExceptionFactoryManager();
     ObjectAdapterFactoryPtr objectAdapterFactory();
     ThreadPoolPtr threadPool();
+    std::string defaultProtocol();
     
 private:
 
@@ -68,6 +69,7 @@ private:
     UserExceptionFactoryManagerPtr _userExceptionFactoryManager;
     ObjectAdapterFactoryPtr _objectAdapterFactory;
     ThreadPoolPtr _threadPool;
+    std::string _defaultProtocol;
 
     //
     // Global state management
diff --git a/cpp/src/Ice/ObjectAdapterI.cpp b/cpp/src/Ice/ObjectAdapterI.cpp
index 37a6d6bd10e..38488430104 100644
--- a/cpp/src/Ice/ObjectAdapterI.cpp
+++ b/cpp/src/Ice/ObjectAdapterI.cpp
@@ -315,7 +315,7 @@ Ice::ObjectAdapterI::ObjectAdapterI(const InstancePtr& instance, const string& n
 	    // might change it, for example, to fill in the real port
 	    // number if a zero port number is given.
 	    //
-	    EndpointPtr endp = Endpoint::endpointFromString(es);
+	    EndpointPtr endp = Endpoint::endpointFromString(instance, es);
 	    _collectorFactories.push_back(new CollectorFactory(instance, this, endp));
 	    
 	    if (end == s.length())
@@ -364,17 +364,7 @@ Ice::ObjectAdapterI::newProxy(const Identity& ident)
     transform(_collectorFactories.begin(), _collectorFactories.end(), back_inserter(endpoints),
 	      Ice::constMemFun(&CollectorFactory::endpoint));
     
-    // TODO: This is a bandaid, and should be replaced by a better approach.
-    bool makeSecure = false;
-    size_t numSecureEndpoints = count_if(endpoints.begin(), endpoints.end(), Ice::constMemFun(&Endpoint::secure));
-
-    if (numSecureEndpoints >= endpoints.size())
-    {
-        makeSecure = true;
-    }
-
-    ReferencePtr reference = new Reference(_instance, ident, "", Reference::ModeTwoway, makeSecure /* false */,
-					   endpoints, endpoints);
+    ReferencePtr reference = new Reference(_instance, ident, "", Reference::ModeTwoway, false, endpoints, endpoints);
     return _instance->proxyFactory()->referenceToProxy(reference);
 }
 
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index 7cc0d97e1ee..cb4851bcb34 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -631,11 +631,17 @@ IceDelegateM::Ice::Object::setup(const ReferencePtr& ref)
 	endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), not1(::Ice::constMemFun(&Endpoint::secure))),
 			endpoints.end());
     }
+//
+// We allow secure connections also if they are not explicitly
+// required.
+//
+/*
     else
     {
 	endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), ::Ice::constMemFun(&Endpoint::secure)),
 			endpoints.end());
     }
+*/
 
     if (endpoints.empty())
     {
diff --git a/cpp/src/Ice/Reference.cpp b/cpp/src/Ice/Reference.cpp
index 12cdcd745a9..4be2445aa9c 100644
--- a/cpp/src/Ice/Reference.cpp
+++ b/cpp/src/Ice/Reference.cpp
@@ -223,7 +223,7 @@ IceInternal::Reference::Reference(const InstancePtr& inst, const string& str) :
 	}
 	
 	string es = s.substr(beg, end - beg);
-	EndpointPtr endp = Endpoint::endpointFromString(es);
+	EndpointPtr endp = Endpoint::endpointFromString(instance, es);
 
 	if (orig)
 	{