zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/ConnectRequestHandler.h

@@ -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.
@@ -12,14 +12,13 @@
 
 #include <IceUtil/Monitor.h>
 #include <IceUtil/Mutex.h>
-#include <IceUtil/UniquePtr.h>
+#include <Ice/UniquePtr.h>
 
 #include <Ice/ConnectRequestHandlerF.h>
 #include <Ice/RequestHandler.h>
 #include <Ice/Reference.h>
 #include <Ice/RouterInfo.h>
 #include <Ice/ProxyF.h>
-#include <Ice/BasicStream.h>
 
 #include <deque>
 #include <set>
@@ -31,19 +30,19 @@ class ConnectRequestHandler : public RequestHandler,
                               public Reference::GetConnectionCallback,
                               public RouterInfo::AddProxyCallback,
                               public IceUtil::Monitor<IceUtil::Mutex>
+#ifdef ICE_CPP11_MAPPING
+                            , public std::enable_shared_from_this<ConnectRequestHandler>
+#endif
 {
 public:
 
-    ConnectRequestHandler(const ReferencePtr&, const Ice::ObjectPrx&);
-    virtual ~ConnectRequestHandler();
+    ConnectRequestHandler(const ReferencePtr&, const Ice::ObjectPrxPtr&);
 
-    RequestHandlerPtr connect(const Ice::ObjectPrx&);
+    RequestHandlerPtr connect(const Ice::ObjectPrxPtr&);
     virtual RequestHandlerPtr update(const RequestHandlerPtr&, const RequestHandlerPtr&);
 
-    virtual bool sendRequest(ProxyOutgoingBase*);
     virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&);
 
-    virtual void requestCanceled(OutgoingBase*, const Ice::LocalException&);
     virtual void asyncRequestCanceled(const OutgoingAsyncBasePtr&, const Ice::LocalException&);
 
     virtual Ice::ConnectionIPtr getConnection();
@@ -59,26 +58,16 @@ private:
     bool initialized();
     void flushRequests();
 
-    struct Request
-    {
-        Request() : out(0)
-        {
-        }
-
-        ProxyOutgoingBase* out;
-        ProxyOutgoingAsyncBasePtr outAsync;
-    };
-
-    Ice::ObjectPrx _proxy;
-    std::set<Ice::ObjectPrx> _proxies;
+    Ice::ObjectPrxPtr _proxy;
+    std::set<Ice::ObjectPrxPtr> _proxies;
 
     Ice::ConnectionIPtr _connection;
     bool _compress;
-    IceUtil::UniquePtr<Ice::LocalException> _exception;
+    IceInternal::UniquePtr<Ice::LocalException> _exception;
     bool _initialized;
     bool _flushing;
 
-    std::deque<Request> _requests;
+    std::deque<ProxyOutgoingAsyncBasePtr> _requests;
 
     RequestHandlerPtr _requestHandler;
 };

data/ext/ice/cpp/src/Ice/ConnectRequestHandlerF.h

@@ -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.
@@ -17,8 +17,12 @@ namespace IceInternal
 {
 
 class ConnectRequestHandler;
-ICE_API IceUtil::Shared* upCast(ConnectRequestHandler*);
+#ifdef ICE_CPP11_MAPPING
+using ConnectRequestHandlerPtr = ::std::shared_ptr<ConnectRequestHandler>;
+#else
+IceUtil::Shared* upCast(ConnectRequestHandler*);
 typedef IceInternal::Handle<ConnectRequestHandler> ConnectRequestHandlerPtr;
+#endif
 
 }
 

data/ext/ice/cpp/src/Ice/Connection.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>
 //
@@ -23,42 +23,122 @@
 #endif
 #include <Ice/Connection.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::ConnectionInfo::~ConnectionInfo()
+{
+}
+
+Ice::Connection::~Connection()
+{
+}
+
+Ice::IPConnectionInfo::~IPConnectionInfo()
+{
+}
+
+Ice::TCPConnectionInfo::~TCPConnectionInfo()
+{
+}
+
+Ice::UDPConnectionInfo::~UDPConnectionInfo()
+{
+}
+
+Ice::WSConnectionInfo::~WSConnectionInfo()
+{
+}
+
 namespace Ice
 {
 }
 
+#else // C++98 mapping
+
+namespace
+{
+
+}
+
+Ice::ConnectionInfo::~ConnectionInfo()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::ConnectionInfo* p) { return p; }
 
-ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::ConnectionCallback* p) { return p; }
+Ice::CloseCallback::~CloseCallback()
+{
+}
+
+ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::CloseCallback* p) { return p; }
+
+Ice::HeartbeatCallback::~HeartbeatCallback()
+{
+}
+
+ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::HeartbeatCallback* p) { return p; }
+
+Ice::Connection::~Connection()
+{
+}
 
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::Connection* p) { return p; }
 
+Ice::IPConnectionInfo::~IPConnectionInfo()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::IPConnectionInfo* p) { return p; }
 
+Ice::TCPConnectionInfo::~TCPConnectionInfo()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::TCPConnectionInfo* p) { return p; }
 
+Ice::UDPConnectionInfo::~UDPConnectionInfo()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::UDPConnectionInfo* p) { return p; }
 
+Ice::WSConnectionInfo::~WSConnectionInfo()
+{
+}
+
 ICE_API ::Ice::LocalObject* Ice::upCast(::Ice::WSConnectionInfo* p) { return p; }
+
+namespace Ice
+{
+}
+
+#endif

data/ext/ice/cpp/src/Ice/ConnectionF.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>
 //
@@ -23,22 +23,44 @@
 #endif
 #include <Ice/ConnectionF.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/Ice/ConnectionFactory.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.
@@ -25,6 +25,7 @@
 #include <Ice/LocalException.h>
 #include <Ice/Functional.h>
 #include <Ice/OutgoingAsync.h>
+#include <Ice/CommunicatorI.h>
 #include <IceUtil/Random.h>
 #include <iterator>
 
@@ -32,8 +33,8 @@
 namespace IceInternal
 {
 
-bool registerForBackgroundNotification(IceInternal::IncomingConnectionFactory*);
-void unregisterForBackgroundNotification(IceInternal::IncomingConnectionFactory*);
+bool registerForBackgroundNotification(const IceInternal::IncomingConnectionFactoryPtr&);
+void unregisterForBackgroundNotification(const IceInternal::IncomingConnectionFactoryPtr&);
 
 }
 #endif
@@ -44,7 +45,10 @@ using namespace Ice::Instrumentation;
 using namespace IceInternal;
 
 IceUtil::Shared* IceInternal::upCast(OutgoingConnectionFactory* p) { return p; }
+
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(IncomingConnectionFactory* p) { return p; }
+#endif
 
 namespace
 {
@@ -57,6 +61,38 @@ struct RandomNumberGenerator : public std::unary_function<ptrdiff_t, ptrdiff_t>
     }
 };
 
+#ifdef ICE_CPP11_MAPPING
+template <typename Map> void
+remove(Map& m, const typename Map::key_type& k, const typename Map::mapped_type& v)
+{
+    auto pr = m.equal_range(k);
+    assert(pr.first != pr.second);
+    for(auto q = pr.first; q != pr.second; ++q)
+    {
+        if(q->second.get() == v.get())
+        {
+            m.erase(q);
+            return;
+        }
+    }
+    assert(false); // Nothing was removed which is an error.
+}
+
+template<typename Map, typename Predicate> typename Map::mapped_type
+find(const Map& m, const typename Map::key_type& k, Predicate predicate)
+{
+    auto pr = m.equal_range(k);
+    for(auto q = pr.first; q != pr.second; ++q)
+    {
+        if(predicate(q->second))
+        {
+            return q->second;
+        }
+    }
+    return nullptr;
+}
+
+#else
 template <typename K, typename V> void
 remove(multimap<K, V>& m, K k, V v)
 {
@@ -89,6 +125,26 @@ find(const multimap<K,::IceInternal::Handle<V> >& m,
     }
     return IceInternal::Handle<V>();
 }
+#endif
+
+class StartAcceptor : public IceUtil::TimerTask
+{
+public:
+
+    StartAcceptor(const IncomingConnectionFactoryPtr& factory) : _factory(factory)
+    {
+    }
+
+    void
+    runTimerTask()
+    {
+        _factory->startAcceptor();
+    }
+
+private:
+
+    IncomingConnectionFactoryPtr _factory;
+};
 
 }
 
@@ -173,7 +229,8 @@ IceInternal::OutgoingConnectionFactory::waitUntilFinished()
 }
 
 void
-IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpts, bool hasMore,
+IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpts,
+                                               bool hasMore,
                                                Ice::EndpointSelectionType selType,
                                                const CreateConnectionCallbackPtr& callback)
 {
@@ -203,7 +260,11 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpt
         return;
     }
 
+#ifdef ICE_CPP11_MAPPING
+    auto cb = make_shared<ConnectCallback>(_instance, this, endpoints, hasMore, callback, selType);
+#else
     ConnectCallbackPtr cb = new ConnectCallback(_instance, this, endpoints, hasMore, callback, selType);
+#endif
     cb->getConnectors();
 }
 
@@ -281,7 +342,8 @@ IceInternal::OutgoingConnectionFactory::removeAdapter(const ObjectAdapterPtr& ad
 }
 
 void
-IceInternal::OutgoingConnectionFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync)
+IceInternal::OutgoingConnectionFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync,
+                                                                Ice::CompressBatch compress)
 {
     list<ConnectionIPtr> c;
 
@@ -301,7 +363,7 @@ IceInternal::OutgoingConnectionFactory::flushAsyncBatchRequests(const Communicat
     {
         try
         {
-            outAsync->flushConnection(*p);
+            outAsync->flushConnection(*p, compress);
         }
         catch(const LocalException&)
         {
@@ -550,8 +612,8 @@ IceInternal::OutgoingConnectionFactory::createConnection(const TransceiverPtr& t
             throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
         }
 
-        connection = new ConnectionI(_communicator, _instance, _monitor, transceiver, ci.connector,
-                                     ci.endpoint->compress(false), 0);
+        connection = ConnectionI::create(_communicator, _instance, _monitor, transceiver, ci.connector,
+                                         ci.endpoint->compress(false), ICE_NULLPTR);
     }
     catch(const Ice::LocalException&)
     {
@@ -752,9 +814,9 @@ void
 IceInternal::OutgoingConnectionFactory::handleException(const LocalException& ex, bool hasMore)
 {
     TraceLevelsPtr traceLevels = _instance->traceLevels();
-    if(traceLevels->retry >= 2)
+    if(traceLevels->network >= 2)
     {
-        Trace out(_instance->initializationData().logger, traceLevels->retryCat);
+        Trace out(_instance->initializationData().logger, traceLevels->networkCat);
 
         out << "couldn't resolve endpoint host";
         if(dynamic_cast<const CommunicatorDestroyedException*>(&ex))
@@ -780,9 +842,9 @@ void
 IceInternal::OutgoingConnectionFactory::handleConnectionException(const LocalException& ex, bool hasMore)
 {
     TraceLevelsPtr traceLevels = _instance->traceLevels();
-    if(traceLevels->retry >= 2)
+    if(traceLevels->network >= 2)
     {
-        Trace out(_instance->initializationData().logger, traceLevels->retryCat);
+        Trace out(_instance->initializationData().logger, traceLevels->networkCat);
 
         out << "connection to endpoint failed";
         if(dynamic_cast<const CommunicatorDestroyedException*>(&ex))
@@ -832,7 +894,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartComplete
     }
 
     connection->activate();
-    _factory->finishGetConnection(_connectors, *_iter, connection, this);
+    _factory->finishGetConnection(_connectors, *_iter, connection, ICE_SHARED_FROM_THIS);
 }
 
 void
@@ -925,7 +987,8 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextEndpoint()
     try
     {
         assert(_endpointsIter != _endpoints.end());
-        (*_endpointsIter)->connectors_async(_selType, this);
+        (*_endpointsIter)->connectors_async(_selType, ICE_SHARED_FROM_THIS);
+
     }
     catch(const Ice::LocalException& ex)
     {
@@ -943,7 +1006,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::getConnection()
         // connection.
         //
         bool compress;
-        Ice::ConnectionIPtr connection = _factory->getConnection(_connectors, this, compress);
+        Ice::ConnectionIPtr connection = _factory->getConnection(_connectors, ICE_SHARED_FROM_THIS, compress);
         if(!connection)
         {
             //
@@ -991,7 +1054,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextConnector()
                     << _iter->connector->toString();
             }
             Ice::ConnectionIPtr connection = _factory->createConnection(_iter->connector->connect(), *_iter);
-            connection->start(this);
+            connection->start(ICE_SHARED_FROM_THIS);
         }
         catch(const Ice::LocalException& ex)
         {
@@ -1057,7 +1120,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::removeConnectors(const
 void
 IceInternal::OutgoingConnectionFactory::ConnectCallback::removeFromPending()
 {
-    _factory->removeFromPending(this, _connectors);
+    _factory->removeFromPending(ICE_SHARED_FROM_THIS, _connectors);
 }
 
 bool
@@ -1071,14 +1134,14 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailedIm
 {
     if(_observer)
     {
-        _observer->failed(ex.ice_name());
+        _observer->failed(ex.ice_id());
         _observer->detach();
     }
 
     _factory->handleConnectionException(ex, _hasMore || _iter != _connectors.end() - 1);
     if(dynamic_cast<const Ice::CommunicatorDestroyedException*>(&ex)) // No need to continue.
     {
-        _factory->finishGetConnection(_connectors, ex, this);
+        _factory->finishGetConnection(_connectors, ex, ICE_SHARED_FROM_THIS);
     }
     else if(++_iter != _connectors.end()) // Try the next connector.
     {
@@ -1086,7 +1149,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailedIm
     }
     else
     {
-        _factory->finishGetConnection(_connectors, ex, this);
+        _factory->finishGetConnection(_connectors, ex, ICE_SHARED_FROM_THIS);
     }
     return false;
 }
@@ -1202,10 +1265,25 @@ IceInternal::IncomingConnectionFactory::waitUntilFinished()
     _monitor->destroy();
 }
 
+bool
+IceInternal::IncomingConnectionFactory::isLocal(const EndpointIPtr& endpoint) const
+{
+    if(_publishedEndpoint && endpoint->equivalent(_publishedEndpoint))
+    {
+        return true;
+    }
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    return endpoint->equivalent(_endpoint);
+}
+
 EndpointIPtr
 IceInternal::IncomingConnectionFactory::endpoint() const
 {
-    // No mutex protection necessary, _endpoint is immutable.
+    if(_publishedEndpoint)
+    {
+        return _publishedEndpoint;
+    }
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
     return _endpoint;
 }
 
@@ -1226,7 +1304,8 @@ IceInternal::IncomingConnectionFactory::connections() const
 }
 
 void
-IceInternal::IncomingConnectionFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync)
+IceInternal::IncomingConnectionFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync,
+                                                                Ice::CompressBatch compress)
 {
     list<ConnectionIPtr> c = connections(); // connections() is synchronized, so no need to synchronize here.
 
@@ -1234,7 +1313,7 @@ IceInternal::IncomingConnectionFactory::flushAsyncBatchRequests(const Communicat
     {
         try
         {
-            outAsync->flushConnection(*p);
+            outAsync->flushConnection(*p, compress);
         }
         catch(const LocalException&)
         {
@@ -1243,7 +1322,7 @@ IceInternal::IncomingConnectionFactory::flushAsyncBatchRequests(const Communicat
     }
 }
 
-#if defined(ICE_USE_IOCP) || defined(ICE_OS_WINRT)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 bool
 IceInternal::IncomingConnectionFactory::startAsync(SocketOperation)
 {
@@ -1259,11 +1338,8 @@ IceInternal::IncomingConnectionFactory::startAsync(SocketOperation)
     }
     catch(const Ice::LocalException& ex)
     {
-        {
-            Error out(_instance->initializationData().logger);
-            out << "can't accept connections:\n" << ex << '\n' << _acceptor->toString();
-        }
-        abort();
+        ICE_SET_EXCEPTION_FROM_CLONE(_acceptorException, ex.ice_clone());
+        _acceptor->getNativeInfo()->completed(SocketOperationRead);
     }
     return true;
 }
@@ -1274,13 +1350,22 @@ IceInternal::IncomingConnectionFactory::finishAsync(SocketOperation)
     assert(_acceptor);
     try
     {
+        if(_acceptorException)
+        {
+            _acceptorException->ice_throw();
+        }
         _acceptor->finishAccept();
     }
     catch(const LocalException& ex)
     {
+        _acceptorException.reset(ICE_NULLPTR);
+
         Error out(_instance->initializationData().logger);
         out << "couldn't accept connection:\n" << ex << '\n' << _acceptor->toString();
-        return false;
+        if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
+        {
+            closeAcceptor();
+        }
     }
     return _state < StateClosed;
 }
@@ -1322,7 +1407,7 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
             _connections.erase(*p);
         }
 
-        if(!_acceptor)
+        if(!_acceptorStarted)
         {
             return;
         }
@@ -1345,11 +1430,13 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
         {
             if(noMoreFds(ex.error))
             {
+                Error out(_instance->initializationData().logger);
+                out << "can't accept more connections:\n" << ex << '\n' << _acceptor->toString();
+
+                if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
                 {
-                    Error out(_instance->initializationData().logger);
-                    out << "fatal error: can't accept more connections:\n" << ex << '\n' << _acceptor->toString();
+                    closeAcceptor();
                 }
-                abort();
             }
 
             // Ignore socket exceptions.
@@ -1370,8 +1457,8 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
 
         try
         {
-            connection = new ConnectionI(_adapter->getCommunicator(), _instance, _monitor, transceiver, 0, _endpoint,
-                                         _adapter);
+            connection = ConnectionI::create(_adapter->getCommunicator(), _instance, _monitor, transceiver, 0,
+                                             _endpoint, _adapter);
         }
         catch(const LocalException& ex)
         {
@@ -1396,41 +1483,34 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
     }
 
     assert(connection);
-    connection->start(this);
+
+    connection->start(ICE_SHARED_FROM_THIS);
 }
 
 void
 IceInternal::IncomingConnectionFactory::finished(ThreadPoolCurrent&, bool close)
 {
     IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-
-#if TARGET_OS_IPHONE != 0
     if(_state < StateClosed)
     {
-        //
-        // Finished has been called by stopAcceptor if the state isn't
-        // closed.
-        //
         if(_acceptorStarted && close)
         {
-            _acceptorStarted = false;
             closeAcceptor();
         }
         return;
     }
-#endif
 
     assert(_state == StateClosed);
     setState(StateFinished);
 
-    if(close)
+    if(_acceptorStarted && close)
     {
         closeAcceptor();
     }
 
 #if TARGET_OS_IPHONE != 0
     sync.release();
-    unregisterForBackgroundNotification(this);
+    unregisterForBackgroundNotification(ICE_SHARED_FROM_THIS);
 #endif
 }
 
@@ -1438,7 +1518,6 @@ string
 IceInternal::IncomingConnectionFactory::toString() const
 {
     IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-
     if(_transceiver)
     {
         return _transceiver->toString();
@@ -1507,17 +1586,20 @@ IceInternal::IncomingConnectionFactory::connectionStartFailed(const Ice::Connect
 //
 IceInternal::IncomingConnectionFactory::IncomingConnectionFactory(const InstancePtr& instance,
                                                                   const EndpointIPtr& endpoint,
+                                                                  const EndpointIPtr& publishedEndpoint,
                                                                   const ObjectAdapterIPtr& adapter) :
     _instance(instance),
     _monitor(new FactoryACMMonitor(instance, dynamic_cast<ObjectAdapterI*>(adapter.get())->getACM())),
     _endpoint(endpoint),
+    _publishedEndpoint(publishedEndpoint),
+    _acceptorStarted(false),
+    _acceptorStopped(false),
     _adapter(adapter),
     _warn(_instance->initializationData().properties->getPropertyAsInt("Ice.Warn.Connections") > 0),
     _state(StateHolding)
 {
 }
 
-#if TARGET_OS_IPHONE != 0
 void
 IceInternal::IncomingConnectionFactory::startAcceptor()
 {
@@ -1527,18 +1609,17 @@ IceInternal::IncomingConnectionFactory::startAcceptor()
         return;
     }
 
+    _acceptorStopped = false;
+
     try
     {
         createAcceptor();
-        _acceptorStarted = true;
     }
     catch(const Ice::Exception& ex)
     {
-        if(_warn)
-        {
-            Warning out(_instance->initializationData().logger);
-            out << "unable to create acceptor:\n" << ex;
-        }
+        Error out(_instance->initializationData().logger);
+        out << "acceptor creation failed:\n" << ex << '\n' << _acceptor->toString();
+        _instance->timer()->schedule(ICE_MAKE_SHARED(StartAcceptor, ICE_SHARED_FROM_THIS), IceUtil::Time::seconds(1));
     }
 }
 
@@ -1551,13 +1632,13 @@ IceInternal::IncomingConnectionFactory::stopAcceptor()
         return;
     }
 
-    if(_adapter->getThreadPool()->finish(this, true))
+    _acceptorStopped = true;
+
+    if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
     {
-        _acceptorStarted = false;
         closeAcceptor();
     }
 }
-#endif
 
 void
 IceInternal::IncomingConnectionFactory::initialize()
@@ -1571,7 +1652,6 @@ IceInternal::IncomingConnectionFactory::initialize()
     {
         _endpoint = _endpoint->compress(_instance->defaultsAndOverrides()->overrideCompressValue);
     }
-
     try
     {
         const_cast<TransceiverPtr&>(_transceiver) = _endpoint->transceiver();
@@ -1583,9 +1663,8 @@ IceInternal::IncomingConnectionFactory::initialize()
                 out << "attempting to bind to " << _endpoint->protocol() << " socket\n" << _transceiver->toString();
             }
             const_cast<EndpointIPtr&>(_endpoint) = _transceiver->bind();
-
-            ConnectionIPtr connection = new ConnectionI(_adapter->getCommunicator(), _instance, 0, _transceiver, 0,
-                                                        _endpoint, _adapter);
+            ConnectionIPtr connection(ConnectionI::create(_adapter->getCommunicator(), _instance, 0, _transceiver, 0,
+                                                          _endpoint, _adapter));
             connection->start(0);
             _connections.insert(connection);
         }
@@ -1596,8 +1675,7 @@ IceInternal::IncomingConnectionFactory::initialize()
             // The notification center will call back on the factory to
             // start the acceptor if necessary.
             //
-            _acceptorStarted = false;
-            registerForBackgroundNotification(this);
+            registerForBackgroundNotification(ICE_SHARED_FROM_THIS);
 #else
             createAcceptor();
 #endif
@@ -1653,7 +1731,7 @@ IceInternal::IncomingConnectionFactory::setState(State state)
                     Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                     out << "accepting " << _endpoint->protocol() << " connections at " << _acceptor->toString();
                 }
-                _adapter->getThreadPool()->_register(this, SocketOperationRead);
+                _adapter->getThreadPool()->_register(ICE_SHARED_FROM_THIS, SocketOperationRead);
             }
             for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::activate));
             break;
@@ -1672,7 +1750,7 @@ IceInternal::IncomingConnectionFactory::setState(State state)
                     Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                     out << "holding " << _endpoint->protocol() << " connections at " << _acceptor->toString();
                 }
-                _adapter->getThreadPool()->unregister(this, SocketOperationRead);
+                _adapter->getThreadPool()->unregister(ICE_SHARED_FROM_THIS, SocketOperationRead);
             }
             for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::hold));
             break;
@@ -1680,7 +1758,7 @@ IceInternal::IncomingConnectionFactory::setState(State state)
 
         case StateClosed:
         {
-            if(_acceptor)
+            if(_acceptorStarted)
             {
                 //
                 // If possible, close the acceptor now to prevent new connections from
@@ -1689,7 +1767,7 @@ IceInternal::IncomingConnectionFactory::setState(State state)
                 // the finish() call. Not all selector implementations do support this
                 // however.
                 //
-                if(_adapter->getThreadPool()->finish(this, true))
+                if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
                 {
                     closeAcceptor();
                 }
@@ -1720,9 +1798,9 @@ IceInternal::IncomingConnectionFactory::createAcceptor()
 {
     try
     {
+        assert(!_acceptorStarted);
         _acceptor = _endpoint->acceptor(_adapter->getName());
         assert(_acceptor);
-
         if(_instance->traceLevels()->network >= 2)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
@@ -1730,26 +1808,25 @@ IceInternal::IncomingConnectionFactory::createAcceptor()
         }
 
         _endpoint = _acceptor->listen();
-
         if(_instance->traceLevels()->network >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
             out << "listening for " << _endpoint->protocol() << " connections\n" << _acceptor->toDetailedString();
         }
 
-        _adapter->getThreadPool()->initialize(this);
-
+        _adapter->getThreadPool()->initialize(ICE_SHARED_FROM_THIS);
         if(_state == StateActive)
         {
-            _adapter->getThreadPool()->_register(this, SocketOperationRead);
+            _adapter->getThreadPool()->_register(ICE_SHARED_FROM_THIS, SocketOperationRead);
         }
+
+        _acceptorStarted = true;
     }
     catch(const Ice::Exception&)
     {
         if(_acceptor)
         {
             _acceptor->close();
-            _acceptor = 0;
         }
         throw;
     }
@@ -1766,14 +1843,15 @@ IceInternal::IncomingConnectionFactory::closeAcceptor()
         out << "stopping to accept " << _endpoint->protocol() << " connections at " << _acceptor->toString();
     }
 
+    _acceptorStarted = false;
     _acceptor->close();
 
-#if TARGET_OS_IPHONE != 0
     //
-    // Only clear the acceptor on iOS where it can be destroyed/re-created during the lifetime of the incoming
-    // connection factory. On other platforms, we keep it set. This is in particular import for IOCP/WinRT where
-    // finishAsync can be called after the acceptor is closed.
+    // If the acceptor hasn't been explicitly stopped (which is the case if the acceptor got closed
+    // because of an unexpected error), try to restart the acceptor in 1 second.
     //
-    _acceptor = 0;
-#endif
+    if(!_acceptorStopped && (_state == StateHolding || _state == StateActive))
+    {
+        _instance->timer()->schedule(ICE_MAKE_SHARED(StartAcceptor, ICE_SHARED_FROM_THIS), IceUtil::Time::seconds(1));
+    }
 }