zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/src/Ice/RouterInfoF.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.

data/ext/ice/cpp/src/{IceUtil → Ice}/SHA1.cpp

@@ -1,15 +1,15 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
-#include <IceUtil/SHA1.h>
+#include <Ice/SHA1.h>
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 #   if defined(_WIN32)
 #      include <Wincrypt.h>
 #      include <IceUtil/Exception.h>
@@ -23,29 +23,29 @@
 using namespace std;
 using namespace IceUtil;
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 
-namespace IceUtilInternal
+namespace IceInternal
 {
 
 class SHA1::Hasher
 {
 public:
-    
+
     Hasher();
 #   ifdef _WIN32
     ~Hasher();
 #endif
-    
+
     void update(const unsigned char*, std::size_t);
     void finalize(std::vector<unsigned char>&);
-    
+
 private:
 
     // noncopyable
     Hasher(const Hasher&);
     Hasher operator=(const Hasher&);
-    
+
 #   if defined (_WIN32)
     HCRYPTPROV _ctx;
     HCRYPTHASH _hash;
@@ -65,7 +65,7 @@ namespace
 const int SHA_DIGEST_LENGTH = 20;
 }
 
-IceUtilInternal::SHA1::Hasher::Hasher() :
+IceInternal::SHA1::Hasher::Hasher() :
     _ctx(0),
     _hash(0)
 {
@@ -80,7 +80,7 @@ IceUtilInternal::SHA1::Hasher::Hasher() :
     }
 }
 
-IceUtilInternal::SHA1::Hasher::~Hasher()
+IceInternal::SHA1::Hasher::~Hasher()
 {
     if(_hash)
     {
@@ -93,19 +93,19 @@ IceUtilInternal::SHA1::Hasher::~Hasher()
     }
 }
 #   elif defined(__APPLE__)
-IceUtilInternal::SHA1::Hasher::Hasher()
+IceInternal::SHA1::Hasher::Hasher()
 {
     CC_SHA1_Init(&_ctx);
 }
 #   else
-IceUtilInternal::SHA1::Hasher::Hasher()
+IceInternal::SHA1::Hasher::Hasher()
 {
     SHA1_Init(&_ctx);
 }
 #   endif
 
 void
-IceUtilInternal::SHA1::Hasher::update(const unsigned char* data, size_t length)
+IceInternal::SHA1::Hasher::update(const unsigned char* data, size_t length)
 {
 #   if defined(_WIN32)
     if(!CryptHashData(_hash, data, static_cast<DWORD>(length), 0))
@@ -120,7 +120,7 @@ IceUtilInternal::SHA1::Hasher::update(const unsigned char* data, size_t length)
 }
 
 void
-IceUtilInternal::SHA1::Hasher::finalize(vector<unsigned char>& md)
+IceInternal::SHA1::Hasher::finalize(vector<unsigned char>& md)
 {
 #   if defined(_WIN32)
     md.resize(SHA_DIGEST_LENGTH);
@@ -138,32 +138,32 @@ IceUtilInternal::SHA1::Hasher::finalize(vector<unsigned char>& md)
 #   endif
 }
 
-IceUtilInternal::SHA1::SHA1() :
+IceInternal::SHA1::SHA1() :
     _hasher(new Hasher())
 {
 }
 
-IceUtilInternal::SHA1::~SHA1()
+IceInternal::SHA1::~SHA1()
 {
 }
 
 void
-IceUtilInternal::SHA1::update(const unsigned char* data, std::size_t length)
+IceInternal::SHA1::update(const unsigned char* data, std::size_t length)
 {
     _hasher->update(data, length);
 }
 
 void
-IceUtilInternal::SHA1::finalize(std::vector<unsigned char>& md)
+IceInternal::SHA1::finalize(std::vector<unsigned char>& md)
 {
     _hasher->finalize(md);
 }
 #endif
 
 void
-IceUtilInternal::sha1(const unsigned char* data, size_t length, vector<unsigned char>& md)
+IceInternal::sha1(const unsigned char* data, size_t length, vector<unsigned char>& md)
 {
-#if defined(ICE_OS_WINRT)
+#if defined(ICE_OS_UWP)
     auto dataA =
         ref new Platform::Array<unsigned char>(const_cast<unsigned char*>(data), static_cast<unsigned int>(length));
     auto hasher = Windows::Security::Cryptography::Core::HashAlgorithmProvider::OpenAlgorithm("SHA1");

data/ext/ice/cpp/src/Ice/Selector.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.
@@ -29,98 +29,13 @@ struct timespec zeroTimeout = { 0, 0 };
 }
 #endif
 
-#ifdef ICE_OS_WINRT
-using namespace Windows::Foundation;
+#if defined(ICE_OS_UWP)
 using namespace Windows::Storage::Streams;
 using namespace Windows::Networking;
 using namespace Windows::Networking::Sockets;
+#endif
 
-Selector::Selector(const InstancePtr& instance) : _instance(instance)
-{
-}
-
-void
-Selector::destroy()
-{
-}
-
-void
-Selector::initialize(IceInternal::EventHandler* handler)
-{
-    EventHandlerPtr h = handler;
-    handler->__incRef();
-    handler->getNativeInfo()->setCompletedHandler(
-        ref new SocketOperationCompletedHandler([=](int operation)
-                                                {
-                                                    //
-                                                    // Use the reference counted handler to ensure it's not
-                                                    // destroyed as long as the callback lambda exists.
-                                                    //
-                                                    completed(h, static_cast<SocketOperation>(operation));
-                                                }));
-}
-
-void
-Selector::update(IceInternal::EventHandler* handler, SocketOperation remove, SocketOperation add)
-{
-    handler->_registered = static_cast<SocketOperation>(handler->_registered & ~remove);
-    handler->_registered = static_cast<SocketOperation>(handler->_registered | add);
-    if(add & SocketOperationRead && !(handler->_pending & SocketOperationRead))
-    {
-        handler->_pending = static_cast<SocketOperation>(handler->_pending | SocketOperationRead);
-        completed(handler, SocketOperationRead); // Start an asynchrnous read
-    }
-    else if(add & SocketOperationWrite && !(handler->_pending & SocketOperationWrite))
-    {
-        handler->_pending = static_cast<SocketOperation>(handler->_pending | SocketOperationWrite);
-        completed(handler, SocketOperationWrite); // Start an asynchrnous write
-    }
-}
-
-void
-Selector::finish(IceInternal::EventHandler* handler)
-{
-    handler->_registered = SocketOperationNone;
-    handler->_finish = false; // Ensures that finished() is only called once on the event handler.
-    handler->__decRef();
-}
-
-IceInternal::EventHandlerPtr
-Selector::getNextHandler(SocketOperation& status, int timeout)
-{
-    Lock lock(*this);
-    while(_events.empty())
-    {
-        if(timeout > 0)
-        {
-            timedWait(IceUtil::Time::seconds(timeout));
-            if(_events.empty())
-            {
-                throw SelectorTimeoutException();
-            }
-        }
-        else
-        {
-            wait();
-        }
-    }
-    assert(!_events.empty());
-    IceInternal::EventHandlerPtr handler = _events.front().handler;
-    const SelectEvent& event = _events.front();
-    status = event.status;
-    _events.pop_front();
-    return handler;
-}
-
-void
-Selector::completed(const IceInternal::EventHandlerPtr& handler, SocketOperation op)
-{
-    Lock lock(*this);
-    _events.push_back(SelectEvent(handler, op));
-    notify();
-}
-
-#elif defined(ICE_USE_IOCP)
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
 
 Selector::Selector(const InstancePtr& instance) : _instance(instance)
 {
@@ -130,36 +45,57 @@ Selector::~Selector()
 {
 }
 
+#ifdef ICE_USE_IOCP
 void
 Selector::setup(int sizeIO)
 {
-    _handle = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, sizeIO);
-    if(_handle == NULL)
+    _handle = CreateIoCompletionPort(INVALID_HANDLE_VALUE, ICE_NULLPTR, 0, sizeIO);
+    if(_handle == ICE_NULLPTR)
     {
         Ice::SocketException ex(__FILE__, __LINE__);
         ex.error = GetLastError();
         throw ex;
     }
 }
+#endif
 
 void
 Selector::destroy()
 {
+#ifdef ICE_USE_IOCP
     CloseHandle(_handle);
+#endif
 }
 
 void
 Selector::initialize(EventHandler* handler)
 {
+    if(!handler->getNativeInfo())
+    {
+        return;
+    }
+#ifdef ICE_USE_IOCP
     HANDLE socket = reinterpret_cast<HANDLE>(handler->getNativeInfo()->fd());
-    if(CreateIoCompletionPort(socket, _handle, reinterpret_cast<ULONG_PTR>(handler), 0) == NULL)
+    if(CreateIoCompletionPort(socket, _handle, reinterpret_cast<ULONG_PTR>(handler), 0) == ICE_NULLPTR)
     {
         Ice::SocketException ex(__FILE__, __LINE__);
         ex.error = GetLastError();
         throw ex;
     }
-    handler->__incRef();
     handler->getNativeInfo()->initialize(_handle, reinterpret_cast<ULONG_PTR>(handler));
+#else
+    EventHandlerPtr h = ICE_GET_SHARED_FROM_THIS(handler);
+    handler->getNativeInfo()->setCompletedHandler(
+        ref new SocketOperationCompletedHandler(
+            [=](int operation)
+            {
+                //
+                // Use the reference counted handler to ensure it's not
+                // destroyed as long as the callback lambda exists.
+                //
+                completed(h.get(), static_cast<SocketOperation>(operation));
+            }));
+#endif
 }
 
 void
@@ -167,26 +103,15 @@ Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation
 {
     handler->_registered = static_cast<SocketOperation>(handler->_registered & ~remove);
     handler->_registered = static_cast<SocketOperation>(handler->_registered | add);
-    AsyncInfo* info = 0;
     if(add & SocketOperationRead && !(handler->_pending & SocketOperationRead))
     {
         handler->_pending = static_cast<SocketOperation>(handler->_pending | SocketOperationRead);
-        info = handler->getNativeInfo()->getAsyncInfo(SocketOperationRead);
+        completed(handler, SocketOperationRead); // Start an asynchrnous read
     }
     else if(add & SocketOperationWrite && !(handler->_pending & SocketOperationWrite))
     {
         handler->_pending = static_cast<SocketOperation>(handler->_pending | SocketOperationWrite);
-        info = handler->getNativeInfo()->getAsyncInfo(SocketOperationWrite);
-    }
-
-    if(info)
-    {
-        if(!PostQueuedCompletionStatus(_handle, 0, reinterpret_cast<ULONG_PTR>(handler), info))
-        {
-            Ice::SocketException ex(__FILE__, __LINE__);
-            ex.error = GetLastError();
-            throw ex;
-        }
+        completed(handler, SocketOperationWrite); // Start an asynchrnous write
     }
 }
 
@@ -194,12 +119,35 @@ void
 Selector::finish(IceInternal::EventHandler* handler)
 {
     handler->_registered = SocketOperationNone;
-    handler->__decRef();
+    handler->_finish = false; // Ensures that finished() is only called once on the event handler.
+}
+
+void
+Selector::ready(EventHandler* handler, SocketOperation status, bool value)
+{
+    if(((handler->_ready & status) != 0) == value)
+    {
+        return; // Nothing to do if ready state already correctly set.
+    }
+
+    if(value)
+    {
+        handler->_ready = static_cast<SocketOperation>(handler->_ready | status);
+    }
+    else
+    {
+        handler->_ready = static_cast<SocketOperation>(handler->_ready & ~status);
+    }
 }
 
 EventHandler*
+#ifdef ICE_USE_IOCP
 Selector::getNextHandler(SocketOperation& status, DWORD& count, int& error, int timeout)
+#else
+Selector::getNextHandler(SocketOperation& status, int timeout)
+#endif
 {
+#ifdef ICE_USE_IOCP
     ULONG_PTR key;
     LPOVERLAPPED ol;
     error = 0;
@@ -215,33 +163,93 @@ Selector::getNextHandler(SocketOperation& status, DWORD& count, int& error, int
             }
             else
             {
-                {
-                    Ice::SocketException ex(__FILE__, __LINE__, err);
-                    Ice::Error out(_instance->initializationData().logger);
-                    out << "fatal error: couldn't dequeue packet from completion port:\n" << ex;
-                }
-                abort();
+                Ice::SocketException ex(__FILE__, __LINE__, err);
+                Ice::Error out(_instance->initializationData().logger);
+                out << "couldn't dequeue packet from completion port:\n" << ex;
+                IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(5)); // Sleep 5s to avoid looping
             }
         }
         AsyncInfo* info = static_cast<AsyncInfo*>(ol);
-        status = info->status;
+        if(info)
+        {
+            status = info->status;
+        }
         count = SOCKET_ERROR;
         error = WSAGetLastError();
         return reinterpret_cast<EventHandler*>(key);
     }
 
-    assert(ol);
     AsyncInfo* info = static_cast<AsyncInfo*>(ol);
-    status = info->status;
+    if(info)
+    {
+        status = info->status;
+    }
+    else
+    {
+        status = reinterpret_cast<EventHandler*>(key)->_ready;
+    }
     return reinterpret_cast<EventHandler*>(key);
+#else
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    while(_events.empty())
+    {
+        if(timeout > 0)
+        {
+            _monitor.timedWait(IceUtil::Time::seconds(timeout));
+            if(_events.empty())
+            {
+                throw SelectorTimeoutException();
+            }
+        }
+        else
+        {
+            _monitor.wait();
+        }
+    }
+    assert(!_events.empty());
+    IceInternal::EventHandlerPtr handler = _events.front().handler;
+    const SelectEvent& event = _events.front();
+    status = event.status;
+    _events.pop_front();
+    return handler.get();
+#endif
+}
+
+void
+Selector::completed(EventHandler* handler, SocketOperation op)
+{
+#ifdef ICE_USE_IOCP
+    AsyncInfo* info = 0;
+    NativeInfoPtr nativeInfo = handler->getNativeInfo();
+    if(nativeInfo)
+    {
+        info = nativeInfo->getAsyncInfo(op);
+    }
+    if(!PostQueuedCompletionStatus(_handle, 0, reinterpret_cast<ULONG_PTR>(handler), info))
+    {
+        Ice::SocketException ex(__FILE__, __LINE__);
+        ex.error = GetLastError();
+        throw ex;
+    }
+#else
+    IceUtil::Monitor<IceUtil::Mutex>::Lock lock(_monitor);
+    _events.push_back(SelectEvent(handler->shared_from_this(), op));
+    _monitor.notify();
+#endif
 }
 
-#elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL)
+#elif defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL) || defined(ICE_USE_SELECT) || defined(ICE_USE_POLL)
 
-Selector::Selector(const InstancePtr& instance) : _instance(instance)
+Selector::Selector(const InstancePtr& instance) : _instance(instance), _interrupted(false)
 {
-    _events.resize(256);
+    SOCKET fds[2];
+    createPipe(fds);
+    _fdIntrRead = fds[0];
+    _fdIntrWrite = fds[1];
+    _selecting = false;
+
 #if defined(ICE_USE_EPOLL)
+    _events.resize(256);
     _queueFd = epoll_create(1);
     if(_queueFd < 0)
     {
@@ -249,7 +257,18 @@ Selector::Selector(const InstancePtr& instance) : _instance(instance)
         ex.error = IceInternal::getSocketErrno();
         throw ex;
     }
-#else
+
+    epoll_event event;
+    memset(&event, 0, sizeof(epoll_event));
+    event.data.ptr = 0;
+    event.events = EPOLLIN;
+    if(epoll_ctl(_queueFd, EPOLL_CTL_ADD, _fdIntrRead, &event) != 0)
+    {
+        Ice::Error out(_instance->initializationData().logger);
+        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+    }
+#elif defined(ICE_USE_KQUEUE)
+    _events.resize(256);
     _queueFd = kqueue();
     if(_queueFd < 0)
     {
@@ -257,7 +276,25 @@ Selector::Selector(const InstancePtr& instance) : _instance(instance)
         ex.error = getSocketErrno();
         throw ex;
     }
-    _selecting = false;
+
+    struct kevent ev;
+    EV_SET(&ev, _fdIntrRead, EVFILT_READ, EV_ADD, 0, 0, 0);
+    int rs = kevent(_queueFd, &ev, 1, 0, 0, 0);
+    if(rs < 0)
+    {
+        Ice::Error out(_instance->initializationData().logger);
+        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+    }
+#elif defined(ICE_USE_SELECT)
+    FD_ZERO(&_readFdSet);
+    FD_ZERO(&_writeFdSet);
+    FD_ZERO(&_errorFdSet);
+    FD_SET(_fdIntrRead, &_readFdSet);
+#else
+    struct pollfd pollFd;
+    pollFd.fd = _fdIntrRead;
+    pollFd.events = POLLIN;
+    _pollFdSet.push_back(pollFd);
 #endif
 }
 
@@ -268,6 +305,7 @@ Selector::~Selector()
 void
 Selector::destroy()
 {
+#if defined(ICE_USE_KQUEUE) || defined(ICE_USE_EPOLL)
     try
     {
         closeSocket(_queueFd);
@@ -277,6 +315,27 @@ Selector::destroy()
         Ice::Error out(_instance->initializationData().logger);
         out << "exception in selector while calling closeSocket():\n" << ex;
     }
+#endif
+
+    try
+    {
+        closeSocket(_fdIntrWrite);
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        Ice::Error out(_instance->initializationData().logger);
+        out << "exception in selector while calling closeSocket():\n" << ex;
+    }
+
+    try
+    {
+        closeSocket(_fdIntrRead);
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        Ice::Error out(_instance->initializationData().logger);
+        out << "exception in selector while calling closeSocket():\n" << ex;
+    }
 }
 
 void
@@ -289,109 +348,59 @@ Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation
     {
         return;
     }
+    checkReady(handler);
 
-    SOCKET fd = handler->getNativeInfo()->fd();
-#if defined(ICE_USE_EPOLL)
-    epoll_event event;
-    memset(&event, 0, sizeof(epoll_event));
-    event.data.ptr = handler;
-    SocketOperation status = handler->_registered;
-    if(handler->_disabled)
+    NativeInfoPtr nativeInfo = handler->getNativeInfo();
+    if(nativeInfo && nativeInfo->fd() != INVALID_SOCKET)
     {
-        status = static_cast<SocketOperation>(status & ~handler->_disabled);
-        previous = static_cast<SocketOperation>(previous & ~handler->_disabled);
-    }
-    event.events |= status & SocketOperationRead ? EPOLLIN : 0;
-    event.events |= status & SocketOperationWrite ? EPOLLOUT : 0;
-    int op;
-    if(!previous && status)
-    {
-        op = EPOLL_CTL_ADD;
-    }
-    else if(previous && !status)
-    {
-        op = EPOLL_CTL_DEL;
+        updateSelectorForEventHandler(handler, remove, add);
     }
-    else if(previous == status)
+}
+
+void
+Selector::enable(EventHandler* handler, SocketOperation status)
+{
+    if(!(handler->_disabled & status))
     {
         return;
     }
-    else
-    {
-        op = EPOLL_CTL_MOD;
-    }
-    if(epoll_ctl(_queueFd, op, fd, &event) != 0)
+    handler->_disabled = static_cast<SocketOperation>(handler->_disabled & ~status);
+    checkReady(handler);
+
+    NativeInfoPtr nativeInfo = handler->getNativeInfo();
+    if(!nativeInfo || nativeInfo->fd() == INVALID_SOCKET)
     {
-        Ice::Error out(_instance->initializationData().logger);
-        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+        return;
     }
-#else // ICE_USE_KQUEUE
-    if(remove & SocketOperationRead)
+
+    if(handler->_registered & status)
     {
+#if defined(ICE_USE_EPOLL)
+        SOCKET fd = nativeInfo->fd();
+        SocketOperation previous = static_cast<SocketOperation>(handler->_registered & ~(handler->_disabled | status));
+        SocketOperation newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
+        epoll_event event;
+        memset(&event, 0, sizeof(epoll_event));
+        event.data.ptr = handler;
+        event.events |= newStatus & SocketOperationRead ? EPOLLIN : 0;
+        event.events |= newStatus & SocketOperationWrite ? EPOLLOUT : 0;
+        if(epoll_ctl(_queueFd, previous ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, fd, &event) != 0)
+        {
+            Ice::Error out(_instance->initializationData().logger);
+            out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+        }
+#elif defined(ICE_USE_KQUEUE)
         struct kevent ev;
-        EV_SET(&ev, fd, EVFILT_READ, EV_DELETE, 0, 0, handler);
-        _changes.push_back(ev);
-    }
-    if(remove & SocketOperationWrite)
-    {
-        struct kevent ev;
-        EV_SET(&ev, fd, EVFILT_WRITE, EV_DELETE, 0, 0, handler);
-        _changes.push_back(ev);
-    }
-    if(add & SocketOperationRead)
-    {
-        struct kevent ev;
-        EV_SET(&ev, fd, EVFILT_READ, EV_ADD | (handler->_disabled & SocketOperationRead ? EV_DISABLE : 0), 0, 0,
-               handler);
-        _changes.push_back(ev);
-    }
-    if(add & SocketOperationWrite)
-    {
-        struct kevent ev;
-        EV_SET(&ev, fd, EVFILT_WRITE, EV_ADD | (handler->_disabled & SocketOperationWrite ? EV_DISABLE : 0), 0, 0,
-               handler);
-        _changes.push_back(ev);
-    }
-    if(_selecting)
-    {
-        updateSelector();
-    }
-#endif
-}
-
-void
-Selector::enable(EventHandler* handler, SocketOperation status)
-{
-    if(!(handler->_disabled & status))
-    {
-        return;
-    }
-    handler->_disabled = static_cast<SocketOperation>(handler->_disabled & ~status);
-
-    if(handler->_registered & status)
-    {
         SOCKET fd = handler->getNativeInfo()->fd();
-#if defined(ICE_USE_EPOLL)
-        SocketOperation previous = static_cast<SocketOperation>(handler->_registered & ~(handler->_disabled | status));
-        SocketOperation newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
-        epoll_event event;
-        memset(&event, 0, sizeof(epoll_event));
-        event.data.ptr = handler;
-        event.events |= newStatus & SocketOperationRead ? EPOLLIN : 0;
-        event.events |= newStatus & SocketOperationWrite ? EPOLLOUT : 0;
-        if(epoll_ctl(_queueFd, previous ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, fd, &event) != 0)
-        {
-            Ice::Error out(_instance->initializationData().logger);
-            out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
-        }
-#else // ICE_USE_KQUEUE
-        struct kevent ev;
         EV_SET(&ev, fd, status == SocketOperationRead ? EVFILT_READ : EVFILT_WRITE, EV_ENABLE, 0, 0, handler);
         _changes.push_back(ev);
         if(_selecting)
         {
             updateSelector();
         }
+#else
+        _changes.push_back(make_pair(handler, static_cast<SocketOperation>(handler->_registered & ~handler->_disabled)));
+        wakeup();
 #endif
     }
 }
@@ -404,11 +413,18 @@ Selector::disable(EventHandler* handler, SocketOperation status)
         return;
     }
     handler->_disabled = static_cast<SocketOperation>(handler->_disabled | status);
+    checkReady(handler);
+
+    NativeInfoPtr nativeInfo = handler->getNativeInfo();
+    if(!nativeInfo || nativeInfo->fd() == INVALID_SOCKET)
+    {
+        return;
+    }
 
     if(handler->_registered & status)
     {
-        SOCKET fd = handler->getNativeInfo()->fd();
 #if defined(ICE_USE_EPOLL)
+        SOCKET fd = nativeInfo->fd();
         SocketOperation newStatus = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
         epoll_event event;
         memset(&event, 0, sizeof(epoll_event));
@@ -420,7 +436,8 @@ Selector::disable(EventHandler* handler, SocketOperation status)
             Ice::Error out(_instance->initializationData().logger);
             out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
         }
-#else // ICE_USE_KQUEUE
+#elif defined(ICE_USE_KQUEUE)
+        SOCKET fd = nativeInfo->fd();
         struct kevent ev;
         EV_SET(&ev, fd, status == SocketOperationRead ? EVFILT_READ : EVFILT_WRITE, EV_DISABLE, 0, 0, handler);
         _changes.push_back(ev);
@@ -428,6 +445,9 @@ Selector::disable(EventHandler* handler, SocketOperation status)
         {
             updateSelector();
         }
+#else
+        _changes.push_back(make_pair(handler, static_cast<SocketOperation>(handler->_registered & ~handler->_disabled)));
+        wakeup();
 #endif
     }
 }
@@ -438,7 +458,11 @@ Selector::finish(EventHandler* handler, bool closeNow)
     if(handler->_registered)
     {
         update(handler, handler->_registered, SocketOperationNone);
+#if !defined(ICE_USE_EPOLL) && !defined(ICE_USE_KQUEUE)
+        return false; // Don't close now if selecting
+#endif
     }
+
 #if defined(ICE_USE_KQUEUE)
     if(closeNow && !_changes.empty())
     {
@@ -449,98 +473,131 @@ Selector::finish(EventHandler* handler, bool closeNow)
         //
         updateSelector();
     }
+#elif !defined(ICE_USE_EPOLL)
+    if(!_changes.empty())
+    {
+        return false;
+    }
 #endif
+
     return closeNow;
 }
 
-#if defined(ICE_USE_KQUEUE)
 void
-Selector::updateSelector()
+Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 {
-    int rs = kevent(_queueFd, &_changes[0], _changes.size(), &_changes[0], _changes.size(), &zeroTimeout);
-    if(rs < 0)
+    if(((handler->_ready & status) != 0) == value)
     {
-        Ice::Error out(_instance->initializationData().logger);
-        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
+        return; // Nothing to do if ready state already correctly set.
     }
-    else
+
+    if(status & SocketOperationConnect)
     {
-        for(int i = 0; i < rs; ++i)
+        NativeInfoPtr nativeInfo = handler->getNativeInfo();
+        if(nativeInfo && nativeInfo->newFd() && handler->_registered)
         {
-            //
-            // Check for errors, we ignore EINPROGRESS that started showing up with macOS Sierra
-            // and which occurs when another thread removes the FD from the kqueue (see ICE-7419).
-            //
-            if(_changes[i].flags & EV_ERROR && _changes[i].data != EINPROGRESS)
-            {
-                Ice::Error out(_instance->initializationData().logger);
-                out << "error while updating selector:\n" << IceUtilInternal::errorToString(_changes[i].data);
-            }
+            // If new FD is set after connect, register the FD with the selector.
+            updateSelectorForEventHandler(handler, SocketOperationNone, handler->_registered);
         }
     }
-    _changes.clear();
+
+    if(value)
+    {
+        handler->_ready = static_cast<SocketOperation>(handler->_ready | status);
+    }
+    else
+    {
+        handler->_ready = static_cast<SocketOperation>(handler->_ready & ~status);
+    }
+    checkReady(handler);
 }
-#endif
 
 void
-Selector::select(vector<pair<EventHandler*, SocketOperation> >& handlers, int timeout)
+Selector::wakeup()
 {
-    int ret = 0;
-    int spuriousWakeup = 0;
-    while(true)
+    if(_selecting && !_interrupted)
     {
-#if defined(ICE_USE_EPOLL)
-        ret = epoll_wait(_queueFd, &_events[0], _events.size(), timeout > 0 ? timeout * 1000 : -1);
-#else
-        assert(!_events.empty());
-        if(timeout > 0)
-        {
-            struct timespec ts;
-            ts.tv_sec = timeout;
-            ts.tv_nsec = 0;
-            ret = kevent(_queueFd, 0, 0, &_events[0], _events.size(), &ts);
-        }
-        else
-        {
-            ret = kevent(_queueFd, 0, 0, &_events[0], _events.size(), 0);
-        }
-#endif
-        if(ret == SOCKET_ERROR)
+        char c = 0;
+        while(true)
         {
-            if(interrupted())
+            if(::write(_fdIntrWrite, &c, 1) == SOCKET_ERROR)
             {
-                continue;
-            }
+                if(interrupted())
+                {
+                    continue;
+                }
 
-            {
-                Ice::SocketException ex(__FILE__, __LINE__, IceInternal::getSocketErrno());
-                Ice::Error out(_instance->initializationData().logger);
-                out << "fatal error: selector failed:\n" << ex;
+                Ice::SocketException ex(__FILE__, __LINE__);
+                ex.error = IceInternal::getSocketErrno();
+                throw ex;
             }
-            abort();
+            break;
         }
-        else if(ret == 0 && timeout <= 0)
+        _interrupted = true;
+    }
+}
+
+void
+Selector::startSelect()
+{
+    if(_interrupted)
+    {
+        char c;
+        while(true)
         {
-            if(++spuriousWakeup > 100)
+            ssize_t ret = ::read(_fdIntrRead, &c, 1);
+            if(ret == SOCKET_ERROR)
             {
-                spuriousWakeup = 0;
-                _instance->initializationData().logger->warning("spurious selector wakeup");
+                if(interrupted())
+                {
+                    continue;
+                }
+                Ice::SocketException ex(__FILE__, __LINE__);
+                ex.error = IceInternal::getSocketErrno();
+                throw ex;
             }
-            IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1));
-            continue;
+            break;
         }
-        break;
+        _interrupted = false;
     }
 
-    if(ret == 0)
+#if !defined(ICE_USE_EPOLL)
+    if(!_changes.empty())
     {
-        throw SelectorTimeoutException();
+        updateSelector();
+    }
+#endif
+    _selecting = true;
+
+    //
+    // If there are ready handlers, don't block in select, just do a non-blocking
+    // select to retrieve new ready handlers from the Java selector.
+    //
+    _selectNow = !_readyHandlers.empty();
+}
+
+void
+Selector::finishSelect(vector<pair<EventHandler*, SocketOperation> >& handlers)
+{
+    _selecting = false;
+
+    assert(handlers.empty());
+
+#if defined(ICE_USE_POLL) || defined(ICE_USE_SELECT)
+    if(_interrupted) // Interrupted, we have to process the interrupt before returning any handlers
+    {
+        return;
     }
+#endif
 
-    assert(ret > 0);
-    for(int i = 0; i < ret; ++i)
+#if defined(ICE_USE_POLL)
+    for(vector<struct pollfd>::const_iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
+#else
+    for(int i = 0; i < _count; ++i)
+#endif
     {
         pair<EventHandler*, SocketOperation> p;
+
 #if defined(ICE_USE_EPOLL)
         struct epoll_event& ev = _events[i];
         p.first = reinterpret_cast<EventHandler*>(ev.data.ptr);
@@ -548,7 +605,7 @@ Selector::select(vector<pair<EventHandler*, SocketOperation> >& handlers, int ti
                                                  SocketOperationRead : SocketOperationNone) |
                                                 ((ev.events & (EPOLLOUT | EPOLLERR)) ?
                                                  SocketOperationWrite : SocketOperationNone));
-#else
+#elif defined(ICE_USE_KQUEUE)
         struct kevent& ev = _events[i];
         if(ev.flags & EV_ERROR)
         {
@@ -558,887 +615,896 @@ Selector::select(vector<pair<EventHandler*, SocketOperation> >& handlers, int ti
         }
         p.first = reinterpret_cast<EventHandler*>(ev.udata);
         p.second = (ev.filter == EVFILT_READ) ? SocketOperationRead : SocketOperationWrite;
-#endif
-        handlers.push_back(p);
-    }
-}
+#elif defined(ICE_USE_SELECT)
+        //
+        // Round robin for the filedescriptors.
+        //
+        SOCKET fd;
+        p.second = SocketOperationNone;
+        if(i < _selectedReadFdSet.fd_count)
+        {
+            fd = _selectedReadFdSet.fd_array[i];
+            p.second = static_cast<SocketOperation>(p.second | SocketOperationRead);
+        }
+        else if(i < _selectedWriteFdSet.fd_count + _selectedReadFdSet.fd_count)
+        {
+            fd = _selectedWriteFdSet.fd_array[i - _selectedReadFdSet.fd_count];
+            p.second = static_cast<SocketOperation>(p.second | SocketOperationWrite);
+        }
+        else
+        {
+            fd = _selectedErrorFdSet.fd_array[i - _selectedReadFdSet.fd_count - _selectedWriteFdSet.fd_count];
+            p.second = static_cast<SocketOperation>(p.second | SocketOperationConnect);
+        }
 
-#elif defined(ICE_USE_CFSTREAM)
+        assert(fd != _fdIntrRead);
+        p.first = _handlers[fd];
+#else
+        if(r->revents == 0)
+        {
+            continue;
+        }
 
-namespace
-{
+        SOCKET fd = r->fd;
+        assert(_handlers.find(fd) != _handlers.end());
+        p.first = _handlers[fd];
+        p.second = SocketOperationNone;
+        if(r->revents & (POLLIN | POLLERR | POLLHUP))
+        {
+            p.second = static_cast<SocketOperation>(p.second | SocketOperationRead);
+        }
+        if(r->revents & (POLLOUT | POLLERR | POLLHUP))
+        {
+            p.second = static_cast<SocketOperation>(p.second | SocketOperationWrite);
+        }
+        assert(p.second);
+#endif
+        if(!p.first)
+        {
+            continue; // Interrupted
+        }
 
-void selectorInterrupt(void* info)
-{
-    reinterpret_cast<Selector*>(info)->processInterrupt();
-}
+        map<EventHandlerPtr, SocketOperation>::iterator q = _readyHandlers.find(ICE_GET_SHARED_FROM_THIS(p.first));
 
-void eventHandlerSocketCallback(CFSocketRef, CFSocketCallBackType callbackType, CFDataRef, const void* d, void* info)
-{
-    if(callbackType == kCFSocketReadCallBack)
-    {
-        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationRead);
-    }
-    else if(callbackType == kCFSocketWriteCallBack)
-    {
-        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationWrite);
+        if(q != _readyHandlers.end()) // Handler will be added by the loop below
+        {
+            q->second = p.second; // We just remember which operations are ready here.
+        }
+        else
+        {
+            handlers.push_back(p);
+        }
     }
-    else if(callbackType == kCFSocketConnectCallBack)
+
+    for(map<EventHandlerPtr, SocketOperation>::iterator q = _readyHandlers.begin(); q != _readyHandlers.end(); ++q)
     {
-        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationConnect,
-                                                                    d ? *reinterpret_cast<const SInt32*>(d) : 0);
+        pair<EventHandler*, SocketOperation> p;
+        p.first = q->first.get();
+        p.second = static_cast<SocketOperation>(p.first->_ready & ~p.first->_disabled & p.first->_registered);
+        p.second = static_cast<SocketOperation>(p.second | q->second);
+        if(p.second)
+        {
+            handlers.push_back(p);
+        }
+
+        //
+        // Reset the operation, it's only used by this method to temporarly store the socket status
+        // return by the select operation above.
+        //
+        q->second = SocketOperationNone;
     }
 }
 
-class SelectorHelperThread : public IceUtil::Thread
+void
+Selector::select(int timeout)
 {
-public:
-
-    SelectorHelperThread(Selector& selector) : _selector(selector)
+    if(_selectNow)
     {
+        timeout = 0;
     }
-
-    virtual void run()
+    else if(timeout > 0)
     {
-        _selector.run();
+        timeout = timeout * 1000;
+    }
+    else
+    {
+        timeout = -1;
     }
 
-private:
-
-    Selector& _selector;
-};
-
-CFOptionFlags
-toCFCallbacks(SocketOperation op)
-{
-    CFOptionFlags cbs = 0;
-    if(op & SocketOperationRead)
-    {
-        cbs |= kCFSocketReadCallBack;
-    }
-    if(op & SocketOperationWrite)
+    int spuriousWakeup = 0;
+    while(true)
     {
-        cbs |= kCFSocketWriteCallBack;
+#if defined(ICE_USE_EPOLL)
+        _count = epoll_wait(_queueFd, &_events[0], _events.size(), timeout);
+#elif defined(ICE_USE_KQUEUE)
+        assert(!_events.empty());
+        if(timeout >= 0)
+        {
+            struct timespec ts;
+            ts.tv_sec = timeout;
+            ts.tv_nsec = 0;
+            _count = kevent(_queueFd, 0, 0, &_events[0], _events.size(), &ts);
+        }
+        else
+        {
+            _count = kevent(_queueFd, 0, 0, &_events[0], _events.size(), 0);
+        }
+#elif defined(ICE_USE_SELECT)
+        fd_set* rFdSet = fdSetCopy(_selectedReadFdSet, _readFdSet);
+        fd_set* wFdSet = fdSetCopy(_selectedWriteFdSet, _writeFdSet);
+        fd_set* eFdSet = fdSetCopy(_selectedErrorFdSet, _errorFdSet);
+        if(timeout >= 0)
+        {
+            struct timeval tv;
+            tv.tv_sec = timeout;
+            tv.tv_usec = 0;
+            _count = ::select(0, rFdSet, wFdSet, eFdSet, &tv); // The first parameter is ignored on Windows
+        }
+        else
+        {
+            _count = ::select(0, rFdSet, wFdSet, eFdSet, 0); // The first parameter is ignored on Windows
+        }
+#else
+        _count = poll(&_pollFdSet[0], _pollFdSet.size(), timeout);
+#endif
+
+        if(_count == SOCKET_ERROR)
+        {
+            if(interrupted())
+            {
+                continue;
+            }
+
+            Ice::SocketException ex(__FILE__, __LINE__, IceInternal::getSocketErrno());
+            Ice::Error out(_instance->initializationData().logger);
+            out << "selector failed:\n" << ex;
+            IceUtil::ThreadControl::sleep(IceUtil::Time::seconds(5)); // Sleep 5s to avoid looping
+        }
+        else if(_count == 0 && timeout < 0 && ++spuriousWakeup < 100)
+        {
+            if(spuriousWakeup == 1)
+            {
+                Ice::Warning out(_instance->initializationData().logger);
+                out << "spurious selector wakeup";
+            }
+            IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1));
+            continue;
+        }
+        break;
     }
-    if(op & SocketOperationConnect)
+
+    if(_count == 0 && !_selectNow)
     {
-        cbs |= kCFSocketConnectCallBack;
+        throw SelectorTimeoutException();
     }
-    return cbs;
 }
 
-}
-
-EventHandlerWrapper::EventHandlerWrapper(const EventHandlerPtr& handler, Selector& selector) :
-    _handler(handler),
-    _nativeInfo(StreamNativeInfoPtr::dynamicCast(handler->getNativeInfo())),
-    _selector(selector),
-    _ready(SocketOperationNone),
-    _finish(false)
+void
+Selector::checkReady(EventHandler* handler)
 {
-    if(!StreamNativeInfoPtr::dynamicCast(handler->getNativeInfo()))
+    if(handler->_ready & ~handler->_disabled & handler->_registered)
     {
-        SOCKET fd = handler->getNativeInfo()->fd();
-        CFSocketContext ctx = { 0, this, 0, 0, 0 };
-        _socket = CFSocketCreateWithNative(kCFAllocatorDefault,
-                                           fd,
-                                           kCFSocketReadCallBack |
-                                           kCFSocketWriteCallBack |
-                                           kCFSocketConnectCallBack,
-                                           eventHandlerSocketCallback,
-                                           &ctx);
-
-        // Disable automatic re-enabling of callbacks and closing of the native socket.
-        CFSocketSetSocketFlags(_socket, 0);
-        CFSocketDisableCallBacks(_socket, kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
-        _source = CFSocketCreateRunLoopSource(kCFAllocatorDefault, _socket, 0);
+        _readyHandlers.insert(make_pair(ICE_GET_SHARED_FROM_THIS(handler), SocketOperationNone));
+        wakeup();
     }
     else
     {
-        _socket = 0;
-        _source = 0;
-        _nativeInfo->initStreams(this);
-    }
-}
-
-EventHandlerWrapper::~EventHandlerWrapper()
-{
-    if(_socket)
-    {
-        CFRelease(_socket);
-        CFRelease(_source);
+        map<EventHandlerPtr, SocketOperation>::iterator p = _readyHandlers.find(ICE_GET_SHARED_FROM_THIS(handler));
+        if(p != _readyHandlers.end())
+        {
+            _readyHandlers.erase(p);
+        }
     }
 }
 
 void
-EventHandlerWrapper::updateRunLoop()
+Selector::updateSelector()
 {
-    SocketOperation op = _handler->_registered;
-    assert(!op || !_finish);
-
-    if(_socket)
+#if defined(ICE_USE_KQUEUE)
+    int rs = kevent(_queueFd, &_changes[0], _changes.size(), &_changes[0], _changes.size(), &zeroTimeout);
+    if(rs < 0)
     {
-        CFSocketDisableCallBacks(_socket, kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
-        if(op)
-        {
-            CFSocketEnableCallBacks(_socket, toCFCallbacks(op));
-        }
-
-        if(op && !CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source, kCFRunLoopDefaultMode))
-        {
-            CFRunLoopAddSource(CFRunLoopGetCurrent(), _source, kCFRunLoopDefaultMode);
-        }
-        else if(!op && CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source, kCFRunLoopDefaultMode))
-        {
-            CFRunLoopRemoveSource(CFRunLoopGetCurrent(), _source, kCFRunLoopDefaultMode);
-        }
-
-        if(_finish)
-        {
-            CFSocketInvalidate(_socket);
-        }
+        Ice::Error out(_instance->initializationData().logger);
+        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
     }
     else
     {
-        SocketOperation readyOp = _nativeInfo->registerWithRunLoop(op);
-        if(!(op & (SocketOperationWrite | SocketOperationConnect)) || _ready & SocketOperationWrite)
+        for(int i = 0; i < rs; ++i)
         {
-            _nativeInfo->unregisterFromRunLoop(SocketOperationWrite, false);
+            //
+            // Check for errors, we ignore EINPROGRESS that started showing up with macOS Sierra
+            // and which occurs when another thread removes the FD from the kqueue (see ICE-7419).
+            //
+            if(_changes[i].flags & EV_ERROR && _changes[i].data != EINPROGRESS)
+            {
+                Ice::Error out(_instance->initializationData().logger);
+                out << "error while updating selector:\n" << IceUtilInternal::errorToString(_changes[i].data);
+            }
         }
+    }
+    _changes.clear();
+#elif !defined(ICE_USE_EPOLL)
+    assert(!_selecting);
 
-        if(!(op & (SocketOperationRead | SocketOperationConnect)) || _ready & SocketOperationRead)
-        {
-            _nativeInfo->unregisterFromRunLoop(SocketOperationRead, false);
-        }
+    for(vector<pair<EventHandler*, SocketOperation> >::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
+    {
+        EventHandler* handler = p->first;
+        SocketOperation status = p->second;
 
-        if(readyOp)
+        SOCKET fd = handler->getNativeInfo()->fd();
+        if(status)
         {
-            ready(readyOp, 0);
+#if defined(ICE_USE_SELECT)
+            if(status & SocketOperationRead)
+            {
+                FD_SET(fd, &_readFdSet);
+            }
+            else
+            {
+                FD_CLR(fd, &_readFdSet);
+            }
+            if(status & SocketOperationWrite)
+            {
+                FD_SET(fd, &_writeFdSet);
+            }
+            else
+            {
+                FD_CLR(fd, &_writeFdSet);
+            }
+            if(status & SocketOperationConnect)
+            {
+                FD_SET(fd, &_writeFdSet);
+                FD_SET(fd, &_errorFdSet);
+            }
+            else
+            {
+                FD_CLR(fd, &_writeFdSet);
+                FD_CLR(fd, &_errorFdSet);
+            }
+            _handlers[fd] = handler;
+#else
+            short events = 0;
+            if(status & SocketOperationRead)
+            {
+                events |= POLLIN;
+            }
+            if(status & SocketOperationWrite)
+            {
+                events |= POLLOUT;
+            }
+            map<SOCKET, EventHandler*>::const_iterator q = _handlers.find(fd);
+            if(q == _handlers.end())
+            {
+                struct pollfd pollFd;
+                pollFd.fd = fd;
+                pollFd.events = events;
+                pollFd.revents = 0;
+                _pollFdSet.push_back(pollFd);
+                _handlers.insert(make_pair(fd, handler));
+            }
+            else
+            {
+                for(vector<struct pollfd>::iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
+                {
+                    if(r->fd == fd)
+                    {
+                        r->events = events;
+                        break;
+                    }
+                }
+            }
+#endif
         }
-
-        if(_finish)
+        else
         {
-            _nativeInfo->closeStreams();
+#if defined(ICE_USE_SELECT)
+            FD_CLR(fd, &_readFdSet);
+            FD_CLR(fd, &_writeFdSet);
+            FD_CLR(fd, &_errorFdSet);
+#else
+            for(vector<struct pollfd>::iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
+            {
+                if(r->fd == fd)
+                {
+                    _pollFdSet.erase(r);
+                    break;
+                }
+            }
+#endif
+            _handlers.erase(fd);
         }
     }
+    _changes.clear();
+#endif
 }
 
 void
-EventHandlerWrapper::readyCallback(SocketOperation op, int error)
-{
-    _selector.ready(this, op, error);
-}
-
-void
-EventHandlerWrapper::ready(SocketOperation op, int error)
+Selector::updateSelectorForEventHandler(EventHandler* handler, SocketOperation remove, SocketOperation add)
 {
-    if(!_socket)
+#if defined(ICE_USE_EPOLL)
+    SocketOperation previous = handler->_registered;
+    previous = static_cast<SocketOperation>(previous & ~add);
+    previous = static_cast<SocketOperation>(previous | remove);
+    SOCKET fd = handler->getNativeInfo()->fd();
+    assert(fd != INVALID_SOCKET);
+    epoll_event event;
+    memset(&event, 0, sizeof(epoll_event));
+    event.data.ptr = handler;
+    SocketOperation status = handler->_registered;
+    if(handler->_disabled)
     {
-        //
-        // Unregister the stream from the runloop as soon as we got the callback. This is
-        // required to allow thread pool thread to perform read/write operations on the
-        // stream (which can't be used from another thread than the run loop thread if
-        // it's registered with a run loop).
-        //
-        op = _nativeInfo->unregisterFromRunLoop(op, error != 0);
+        status = static_cast<SocketOperation>(status & ~handler->_disabled);
+        previous = static_cast<SocketOperation>(previous & ~handler->_disabled);
     }
-
-    op = static_cast<SocketOperation>(_handler->_registered & op);
-    if(!op || _ready & op)
+    event.events |= status & SocketOperationRead ? EPOLLIN : 0;
+    event.events |= status & SocketOperationWrite ? EPOLLOUT : 0;
+    int op;
+    if(!previous && status)
+    {
+        op = EPOLL_CTL_ADD;
+    }
+    else if(previous && !status)
+    {
+        op = EPOLL_CTL_DEL;
+    }
+    else if(previous == status)
     {
         return;
     }
-
-    if(_socket)
+    else
     {
-        if(op & SocketOperationConnect)
-        {
-            _nativeInfo->setConnectError(error);
-        }
+        op = EPOLL_CTL_MOD;
     }
-
-    _ready = static_cast<SocketOperation>(_ready | op);
-    if(!(_handler->_disabled & op))
+    if(epoll_ctl(_queueFd, op, fd, &event) != 0)
     {
-        _selector.addReadyHandler(this);
+        Ice::Error out(_instance->initializationData().logger);
+        out << "error while updating selector:\n" << IceUtilInternal::errorToString(IceInternal::getSocketErrno());
     }
-}
-
-void
-EventHandlerWrapper::checkReady()
-{
-    if(_ready & _handler->_registered)
+#elif defined(ICE_USE_KQUEUE)
+    SOCKET fd = handler->getNativeInfo()->fd();
+    assert(fd != INVALID_SOCKET);
+    if(remove & SocketOperationRead)
     {
-        _selector.addReadyHandler(this);
+        struct kevent ev;
+        EV_SET(&ev, fd, EVFILT_READ, EV_DELETE, 0, 0, handler);
+        _changes.push_back(ev);
+    }
+    if(remove & SocketOperationWrite)
+    {
+        struct kevent ev;
+        EV_SET(&ev, fd, EVFILT_WRITE, EV_DELETE, 0, 0, handler);
+        _changes.push_back(ev);
+    }
+    if(add & SocketOperationRead)
+    {
+        struct kevent ev;
+        EV_SET(&ev, fd, EVFILT_READ, EV_ADD | (handler->_disabled & SocketOperationRead ? EV_DISABLE : 0), 0, 0,
+               handler);
+        _changes.push_back(ev);
+    }
+    if(add & SocketOperationWrite)
+    {
+        struct kevent ev;
+        EV_SET(&ev, fd, EVFILT_WRITE, EV_ADD | (handler->_disabled & SocketOperationWrite ? EV_DISABLE : 0), 0, 0,
+               handler);
+        _changes.push_back(ev);
     }
+    if(_selecting)
+    {
+        updateSelector();
+    }
+#else
+    _changes.push_back(make_pair(handler, static_cast<SocketOperation>(handler->_registered & ~handler->_disabled)));
+    wakeup();
+#endif
+    checkReady(handler);
 }
 
-SocketOperation
-EventHandlerWrapper::readyOp()
-{
-    assert(!(~_handler->_registered & _ready));
-    SocketOperation op = static_cast<SocketOperation>(~_handler->_disabled & _ready);
-    _ready = static_cast<SocketOperation>(~op & _ready);
-    return op;
-}
+#elif defined(ICE_USE_CFSTREAM)
 
-bool
-EventHandlerWrapper::update(SocketOperation remove, SocketOperation add)
+namespace
 {
-    SocketOperation previous = _handler->_registered;
-    _handler->_registered = static_cast<SocketOperation>(_handler->_registered & ~remove);
-    _handler->_registered = static_cast<SocketOperation>(_handler->_registered | add);
-    if(previous == _handler->_registered)
-    {
-        return false;
-    }
 
-    // Clear ready flags which might not be valid anymore.
-    _ready = static_cast<SocketOperation>(_ready & _handler->_registered);
-    return true;
-}
-
-void
-EventHandlerWrapper::finish()
+void selectorInterrupt(void* info)
 {
-    _finish = true;
-    _ready = SocketOperationNone;
-    _handler->_registered = SocketOperationNone;
+    reinterpret_cast<Selector*>(info)->processInterrupt();
 }
 
-Selector::Selector(const InstancePtr& instance) : _instance(instance), _destroyed(false)
+void eventHandlerSocketCallback(CFSocketRef, CFSocketCallBackType callbackType, CFDataRef, const void* d, void* info)
 {
-    CFRunLoopSourceContext ctx;
-    memset(&ctx, 0, sizeof(CFRunLoopSourceContext));
-    ctx.info = this;
-    ctx.perform = selectorInterrupt;
-    _source = CFRunLoopSourceCreate(0, 0, &ctx);
-    _runLoop = 0;
-
-    _thread = new SelectorHelperThread(*this);
-    _thread->start();
-
-    Lock sync(*this);
-    while(!_runLoop)
+    if(callbackType == kCFSocketReadCallBack)
     {
-        wait();
+        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationRead);
+    }
+    else if(callbackType == kCFSocketWriteCallBack)
+    {
+        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationWrite);
+    }
+    else if(callbackType == kCFSocketConnectCallBack)
+    {
+        reinterpret_cast<EventHandlerWrapper*>(info)->readyCallback(SocketOperationConnect,
+                                                                    d ? *reinterpret_cast<const SInt32*>(d) : 0);
     }
 }
 
-Selector::~Selector()
-{
-}
-
-void
-Selector::destroy()
+class SelectorHelperThread : public IceUtil::Thread
 {
-    Lock sync(*this);
+public:
 
-    //
-    // Make sure any pending changes are processed to ensure remaining
-    // streams/sockets are closed.
-    //
-    _destroyed = true;
-    while(!_changes.empty())
+    SelectorHelperThread(Selector& selector) : _selector(selector)
     {
-        CFRunLoopSourceSignal(_source);
-        CFRunLoopWakeUp(_runLoop);
-
-        wait();
     }
 
-    _thread->getThreadControl().join();
-    _thread = 0;
-
-    CFRelease(_source);
+    virtual void run()
+    {
+        _selector.run();
+    }
 
-    assert(_wrappers.empty());
-    _readyHandlers.clear();
-    _selectedHandlers.clear();
-}
+private:
 
-void
-Selector::initialize(EventHandler* handler)
-{
-    Lock sync(*this);
-    _wrappers[handler] = new EventHandlerWrapper(handler, *this);
-}
+    Selector& _selector;
+};
 
-void
-Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation add)
+CFOptionFlags
+toCFCallbacks(SocketOperation op)
 {
-    Lock sync(*this);
-    const EventHandlerWrapperPtr& wrapper = _wrappers[handler];
-    assert(wrapper);
-    if(wrapper->update(remove, add))
+    CFOptionFlags cbs = 0;
+    if(op & SocketOperationRead)
     {
-        _changes.insert(wrapper);
-        notify();
+        cbs |= kCFSocketReadCallBack;
     }
-}
-
-void
-Selector::enable(EventHandler* handler, SocketOperation op)
-{
-    Lock sync(*this);
-    if(!(handler->_disabled & op))
+    if(op & SocketOperationWrite)
     {
-        return;
+        cbs |= kCFSocketWriteCallBack;
     }
-    handler->_disabled = static_cast<SocketOperation>(handler->_disabled & ~op);
-
-    if(handler->_registered & op)
+    if(op & SocketOperationConnect)
     {
-        _wrappers[handler]->checkReady();
+        cbs |= kCFSocketConnectCallBack;
     }
+    return cbs;
 }
 
-void
-Selector::disable(EventHandler* handler, SocketOperation op)
+}
+
+EventHandlerWrapper::EventHandlerWrapper(EventHandler* handler, Selector& selector) :
+    _handler(ICE_GET_SHARED_FROM_THIS(handler)),
+    _streamNativeInfo(StreamNativeInfoPtr::dynamicCast(handler->getNativeInfo())),
+    _selector(selector),
+    _ready(SocketOperationNone),
+    _finish(false)
 {
-    Lock sync(*this);
-    if(handler->_disabled & op)
+    if(_streamNativeInfo)
     {
-        return;
+        _streamNativeInfo->initStreams(this);
+    }
+    else if(handler->getNativeInfo())
+    {
+        SOCKET fd = handler->getNativeInfo()->fd();
+        CFSocketContext ctx = { 0, this, 0, 0, 0 };
+        _socket.reset(CFSocketCreateWithNative(kCFAllocatorDefault,
+                                               fd,
+                                               kCFSocketReadCallBack |
+                                               kCFSocketWriteCallBack |
+                                               kCFSocketConnectCallBack,
+                                               eventHandlerSocketCallback,
+                                               &ctx));
+
+        // Disable automatic re-enabling of callbacks and closing of the native socket.
+        CFSocketSetSocketFlags(_socket.get(), 0);
+        CFSocketDisableCallBacks(_socket.get(), kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
+        _source.reset(CFSocketCreateRunLoopSource(kCFAllocatorDefault, _socket.get(), 0));
     }
-    handler->_disabled = static_cast<SocketOperation>(handler->_disabled | op);
 }
 
-bool
-Selector::finish(EventHandler* handler, bool closeNow)
+EventHandlerWrapper::~EventHandlerWrapper()
 {
-    Lock sync(*this);
-    std::map<EventHandler*, EventHandlerWrapperPtr>::iterator p = _wrappers.find(handler);
-    assert(p != _wrappers.end());
-    EventHandlerWrapperPtr wrapper = p->second;
-    wrapper->finish();
-    _wrappers.erase(p);
-    _changes.insert(wrapper);
-    notify();
-    return closeNow;
 }
 
 void
-Selector::select(std::vector<std::pair<EventHandler*, SocketOperation> >& handlers, int timeout)
+EventHandlerWrapper::updateRunLoop()
 {
-    Lock sync(*this);
+    SocketOperation op = _handler->_registered;
+    assert(!op || !_finish);
 
-    //
-    // Re-enable callbacks for previously selected handlers.
-    //
-    if(!_selectedHandlers.empty())
+    if(_socket)
     {
-        vector<pair<EventHandlerWrapperPtr, SocketOperation> >::const_iterator p;
-        for(p = _selectedHandlers.begin(); p != _selectedHandlers.end(); ++p)
+        CFSocketDisableCallBacks(_socket.get(), kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack);
+        if(op)
         {
-            if(!p->first->_finish)
-            {
-                _changes.insert(p->first);
-            }
+            CFSocketEnableCallBacks(_socket.get(), toCFCallbacks(op));
         }
-        _selectedHandlers.clear();
-    }
 
-    //
-    // Wait for handlers to be ready.
-    //
-    handlers.clear();
-    while(_selectedHandlers.empty())
+        if(op && !CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode))
+        {
+            CFRunLoopAddSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
+        }
+        else if(!op && CFRunLoopContainsSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode))
+        {
+            CFRunLoopRemoveSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
+        }
+
+        if(_finish)
+        {
+            CFSocketInvalidate(_socket.get());
+        }
+    }
+    else
     {
-        while(!_changes.empty())
+        SocketOperation readyOp = _streamNativeInfo->registerWithRunLoop(op);
+        if(!(op & (SocketOperationWrite | SocketOperationConnect)) || _ready & SocketOperationWrite)
         {
-            CFRunLoopSourceSignal(_source);
-            CFRunLoopWakeUp(_runLoop);
-
-            wait();
+            _streamNativeInfo->unregisterFromRunLoop(SocketOperationWrite, false);
         }
 
-        if(_readyHandlers.empty())
+        if(!(op & (SocketOperationRead | SocketOperationConnect)) || _ready & SocketOperationRead)
         {
-            if(timeout > 0)
-            {
-                if(!timedWait(IceUtil::Time::seconds(timeout)))
-                {
-                    break;
-                }
-            }
-            else
-            {
-                wait();
-            }
+            _streamNativeInfo->unregisterFromRunLoop(SocketOperationRead, false);
         }
 
-        if(!_changes.empty())
+        if(readyOp)
         {
-            continue; // Make sure to process the changes first.
+            ready(readyOp, 0);
         }
 
-        for(vector<EventHandlerWrapperPtr>::const_iterator p = _readyHandlers.begin(); p != _readyHandlers.end(); ++p)
+        if(_finish)
         {
-            SocketOperation op = (*p)->readyOp();
-            if(op)
-            {
-                _selectedHandlers.push_back(pair<EventHandlerWrapperPtr, SocketOperation>(*p, op));
-                handlers.push_back(pair<EventHandler*, SocketOperation>((*p)->_handler.get(), op));
-            }
+            _streamNativeInfo->closeStreams();
         }
-        _readyHandlers.clear();
     }
 }
 
 void
-Selector::processInterrupt()
+EventHandlerWrapper::readyCallback(SocketOperation op, int error)
 {
-    Lock sync(*this);
-    if(!_changes.empty())
+    _selector.ready(this, op, error);
+}
+
+void
+EventHandlerWrapper::ready(SocketOperation op, int error)
+{
+    if(!_socket)
     {
-        for(set<EventHandlerWrapperPtr>::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
-        {
-            (*p)->updateRunLoop();
-        }
-        _changes.clear();
-        notify();
+        //
+        // Unregister the stream from the runloop as soon as we got the callback. This is
+        // required to allow thread pool thread to perform read/write operations on the
+        // stream (which can't be used from another thread than the run loop thread if
+        // it's registered with a run loop).
+        //
+        op = _streamNativeInfo->unregisterFromRunLoop(op, error != 0);
     }
-    if(_destroyed)
+
+    op = static_cast<SocketOperation>(_handler->_registered & op);
+    if(!op || _ready & op)
     {
-        CFRunLoopStop(_runLoop);
+        return;
     }
-}
 
-void
-Selector::ready(EventHandlerWrapper* wrapper, SocketOperation op, int error)
-{
-    Lock sync(*this);
-    wrapper->ready(op, error);
+    if(_socket)
+    {
+        if(op & SocketOperationConnect)
+        {
+            _streamNativeInfo->setConnectError(error);
+        }
+    }
+
+    _ready = static_cast<SocketOperation>(_ready | op);
+    checkReady();
 }
 
-void
-Selector::addReadyHandler(EventHandlerWrapper* wrapper)
+bool
+EventHandlerWrapper::checkReady()
 {
-    // Called from ready()
-    _readyHandlers.push_back(wrapper);
-    if(_readyHandlers.size() == 1)
+    if((_ready | _handler->_ready) & ~_handler->_disabled & _handler->_registered)
     {
-        notify();
+        _selector.addReadyHandler(this);
+        return false;
+    }
+    else
+    {
+        return _handler->getNativeInfo() && !_finish;
     }
 }
 
-void
-Selector::run()
+SocketOperation
+EventHandlerWrapper::readyOp()
+{
+    assert(!(~_handler->_registered & _ready));
+    SocketOperation op = static_cast<SocketOperation>(~_handler->_disabled & (_ready | _handler->_ready));
+    _ready = static_cast<SocketOperation>(~op & _ready);
+    return op;
+}
+
+bool
+EventHandlerWrapper::update(SocketOperation remove, SocketOperation add)
 {
+    SocketOperation previous = _handler->_registered;
+    _handler->_registered = static_cast<SocketOperation>(_handler->_registered & ~remove);
+    _handler->_registered = static_cast<SocketOperation>(_handler->_registered | add);
+    if(previous == _handler->_registered)
     {
-        Lock sync(*this);
-        _runLoop = CFRunLoopGetCurrent();
-        notify();
+        return false;
     }
 
-    CFRunLoopAddSource(CFRunLoopGetCurrent(), _source, kCFRunLoopDefaultMode);
-    CFRunLoopRun();
-    CFRunLoopRemoveSource(CFRunLoopGetCurrent(), _source, kCFRunLoopDefaultMode);
+    // Clear ready flags which might not be valid anymore.
+    _ready = static_cast<SocketOperation>(_ready & _handler->_registered);
+    return _handler->getNativeInfo();
 }
 
-#elif defined(ICE_USE_SELECT) || defined(ICE_USE_POLL)
-
-Selector::Selector(const InstancePtr& instance) : _instance(instance), _selecting(false), _interrupted(false)
+bool
+EventHandlerWrapper::finish()
 {
-    SOCKET fds[2];
-    createPipe(fds);
-    _fdIntrRead = fds[0];
-    _fdIntrWrite = fds[1];
-#if defined(ICE_USE_SELECT)
-    FD_ZERO(&_readFdSet);
-    FD_ZERO(&_writeFdSet);
-    FD_ZERO(&_errorFdSet);
-    FD_SET(_fdIntrRead, &_readFdSet);
-#else
-    struct pollfd pollFd;
-    pollFd.fd = _fdIntrRead;
-    pollFd.events = POLLIN;
-    _pollFdSet.push_back(pollFd);
-#endif
+    _finish = true;
+    _ready = SocketOperationNone;
+    _handler->_registered = SocketOperationNone;
+    return _handler->getNativeInfo();
 }
 
-Selector::~Selector()
+Selector::Selector(const InstancePtr& instance) : _instance(instance), _destroyed(false)
 {
-    try
-    {
-        closeSocket(_fdIntrWrite);
-    }
-    catch(const Ice::LocalException& ex)
-    {
-        Ice::Error out(_instance->initializationData().logger);
-        out << "exception in selector while calling closeSocket():\n" << ex;
-    }
+    CFRunLoopSourceContext ctx;
+    memset(&ctx, 0, sizeof(CFRunLoopSourceContext));
+    ctx.info = this;
+    ctx.perform = selectorInterrupt;
+    _source.reset(CFRunLoopSourceCreate(0, 0, &ctx));
+    _runLoop = 0;
 
-    try
-    {
-        closeSocket(_fdIntrRead);
-    }
-    catch(const Ice::LocalException& ex)
+    _thread = new SelectorHelperThread(*this);
+    _thread->start();
+
+    Lock sync(*this);
+    while(!_runLoop)
     {
-        Ice::Error out(_instance->initializationData().logger);
-        out << "exception in selector while calling closeSocket():\n" << ex;
+        wait();
     }
 }
 
-void
-Selector::destroy()
+Selector::~Selector()
 {
-#if !defined(ICE_USE_SELECT) && !defined(ICE_USE_POLL)
-    assert(_events.empty());
-#endif
 }
 
 void
-Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation add)
+Selector::destroy()
 {
-    SocketOperation previous = handler->_registered;
-    handler->_registered = static_cast<SocketOperation>(handler->_registered & ~remove);
-    handler->_registered = static_cast<SocketOperation>(handler->_registered | add);
-    if(previous == handler->_registered)
     {
-        return;
+        Lock sync(*this);
+
+        //
+        // Make sure any pending changes are processed to ensure remaining
+        // streams/sockets are closed.
+        //
+        _destroyed = true;
+        CFRunLoopSourceSignal(_source.get());
+        CFRunLoopWakeUp(_runLoop);
+
+        while(!_changes.empty())
+        {
+            CFRunLoopSourceSignal(_source.get());
+            CFRunLoopWakeUp(_runLoop);
+
+            wait();
+        }
     }
 
-    updateImpl(handler);
+    _thread->getThreadControl().join();
+    _thread = 0;
+
+    Lock sync(*this);
+    _source.reset(0);
+
+    //assert(_wrappers.empty());
+    _readyHandlers.clear();
+    _selectedHandlers.clear();
 }
 
 void
-Selector::enable(EventHandler* handler, SocketOperation status)
+Selector::initialize(EventHandler* handler)
 {
-    if(!(handler->_disabled & status))
-    {
-        return;
-    }
-    handler->_disabled = static_cast<SocketOperation>(handler->_disabled & ~status);
+    Lock sync(*this);
+    _wrappers[handler] = new EventHandlerWrapper(handler, *this);
+}
 
-    if(handler->_registered & status)
+void
+Selector::update(EventHandler* handler, SocketOperation remove, SocketOperation add)
+{
+    Lock sync(*this);
+    const EventHandlerWrapperPtr& wrapper = _wrappers[handler];
+    if(wrapper->update(remove, add))
     {
-        updateImpl(handler);
+        _changes.insert(wrapper);
+        notify();
     }
 }
 
 void
-Selector::disable(EventHandler* handler, SocketOperation status)
+Selector::enable(EventHandler* handler, SocketOperation op)
 {
-    if(handler->_disabled & status)
+    Lock sync(*this);
+    if(!(handler->_disabled & op))
     {
         return;
     }
-    handler->_disabled = static_cast<SocketOperation>(handler->_disabled | status);
-
-    if(handler->_registered & status)
-    {
-        updateImpl(handler);
-    }
-}
+    handler->_disabled = static_cast<SocketOperation>(handler->_disabled & ~op);
 
-bool
-Selector::finish(EventHandler* handler, bool closeNow)
-{
-    if(handler->_registered)
+    if(handler->_registered & op)
     {
-        update(handler, handler->_registered, SocketOperationNone);
-        return false; // Don't close now if selecting.
+        _wrappers[handler]->checkReady();
     }
-    return closeNow;
 }
 
 void
-Selector::startSelect()
+Selector::disable(EventHandler* handler, SocketOperation op)
 {
-    if(_interrupted)
+    Lock sync(*this);
+    if(handler->_disabled & op)
     {
-        char c;
-        while(true)
-        {
-            ssize_t ret;
-#ifdef _WIN32
-            ret = ::recv(_fdIntrRead, &c, 1, 0);
-#else
-            ret = ::read(_fdIntrRead, &c, 1);
-#endif
-            if(ret == SOCKET_ERROR)
-            {
-                if(interrupted())
-                {
-                    continue;
-                }
-
-                Ice::SocketException ex(__FILE__, __LINE__);
-                ex.error = IceInternal::getSocketErrno();
-                throw ex;
-            }
-            break;
-        }
-        _interrupted = false;
-
-        if(!_changes.empty())
-        {
-            updateSelector();
-        }
+        return;
     }
-    _selecting = true;
+    handler->_disabled = static_cast<SocketOperation>(handler->_disabled | op);
 }
 
-void
-Selector::finishSelect()
+bool
+Selector::finish(EventHandler* handler, bool closeNow)
 {
-    _selecting = false;
+    Lock sync(*this);
+    std::map<EventHandler*, EventHandlerWrapperPtr>::iterator p = _wrappers.find(handler);
+    assert(p != _wrappers.end());
+    EventHandlerWrapperPtr wrapper = p->second;
+    if(wrapper->finish())
+    {
+        _changes.insert(wrapper);
+        notify();
+    }
+    _wrappers.erase(p);
+    return closeNow;
 }
 
 void
-Selector::select(vector<pair<EventHandler*, SocketOperation> >& handlers, int timeout)
+Selector::ready(EventHandler* handler, SocketOperation status, bool value)
 {
-    int ret = 0;
-    while(true)
+    if(((handler->_ready & status) != 0) == value)
     {
-#if defined(ICE_USE_SELECT)
-        fd_set* rFdSet = fdSetCopy(_selectedReadFdSet, _readFdSet);
-        fd_set* wFdSet = fdSetCopy(_selectedWriteFdSet, _writeFdSet);
-        fd_set* eFdSet = fdSetCopy(_selectedErrorFdSet, _errorFdSet);
-        if(timeout > 0)
-        {
-            struct timeval tv;
-            tv.tv_sec = timeout;
-            tv.tv_usec = 0;
-            ret = ::select(0, rFdSet, wFdSet, eFdSet, &tv); // The first parameter is ignored on Windows
-        }
-        else
-        {
-            ret = ::select(0, rFdSet, wFdSet, eFdSet, 0); // The first parameter is ignored on Windows
-        }
-#else
-        ret = poll(&_pollFdSet[0], _pollFdSet.size(), timeout > 0 ? timeout * 1000 : -1);
-#endif
-        if(ret == SOCKET_ERROR)
-        {
-            if(interrupted())
-            {
-                continue;
-            }
-
-            {
-                Ice::SocketException ex(__FILE__, __LINE__, IceInternal::getSocketErrno());
-                Ice::Error out(_instance->initializationData().logger);
-                out << "fatal error: selector failed:\n" << ex;
-            }
-            abort();
-        }
-        break;
+        return; // Nothing to do if ready state already correctly set.
     }
 
-    if(ret == 0)
+    if(value)
     {
-        throw SelectorTimeoutException();
+        handler->_ready = static_cast<SocketOperation>(handler->_ready | status);
     }
-
-    assert(ret > 0);
-
-#if defined(ICE_USE_SELECT)
-    if(_selectedReadFdSet.fd_count == 0 && _selectedWriteFdSet.fd_count == 0 && _selectedErrorFdSet.fd_count == 0)
+    else
     {
-        Ice::Error out(_instance->initializationData().logger);
-        out << "select() in selector returned " << ret << " but no filedescriptor is ready";
-        return;
+        handler->_ready = static_cast<SocketOperation>(handler->_ready & ~status);
     }
 
-    for(unsigned int i = 0; i < static_cast<unsigned int>(ret); ++i)
-    {
-        pair<EventHandler*, SocketOperation> p;
+    Lock sync(*this);
+    std::map<EventHandler*, EventHandlerWrapperPtr>::iterator p = _wrappers.find(handler);
+    assert(p != _wrappers.end());
+    p->second->checkReady();
+}
 
-        //
-        // Round robin for the filedescriptors.
-        //
-        SOCKET fd;
-        p.second = SocketOperationNone;
-        if(i < _selectedReadFdSet.fd_count)
-        {
-            fd = _selectedReadFdSet.fd_array[i];
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationRead);
-        }
-        else if(i < _selectedWriteFdSet.fd_count + _selectedReadFdSet.fd_count)
-        {
-            fd = _selectedWriteFdSet.fd_array[i - _selectedReadFdSet.fd_count];
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationWrite);
-        }
-        else
-        {
-            fd = _selectedErrorFdSet.fd_array[i - _selectedReadFdSet.fd_count - _selectedWriteFdSet.fd_count];
-            p.second = static_cast<SocketOperation>(p.second | SocketOperationConnect);
-        }
+void
+Selector::startSelect()
+{
+    Lock sync(*this);
 
-        if(fd == _fdIntrRead) // Interrupted, we have to process the interrupt before returning any handlers
+    //
+    // Re-enable callbacks for previously selected handlers.
+    //
+    vector<pair<EventHandlerWrapperPtr, SocketOperation> >::const_iterator p;
+    for(p = _selectedHandlers.begin(); p != _selectedHandlers.end(); ++p)
+    {
+        if(p->first->checkReady())
         {
-            handlers.clear();
-            return;
+            _changes.insert(p->first);
         }
-
-        assert(_handlers.find(fd) != _handlers.end());
-        p.first = _handlers[fd];
-        handlers.push_back(p);
     }
-#else
-    if(_pollFdSet[0].revents == POLLIN) // Interrupted, we have to process the interrupt before returning any handlers
+    _selectedHandlers.clear();
+}
+
+void
+Selector::finishSelect(std::vector<std::pair<EventHandler*, SocketOperation> >& handlers)
+{
+    Lock sync(*this);
+    handlers.clear();
+    for(set<EventHandlerWrapperPtr>::const_iterator p = _readyHandlers.begin(); p != _readyHandlers.end(); ++p)
     {
-        return;
+        SocketOperation op = (*p)->readyOp();
+        if(op)
+        {
+            _selectedHandlers.push_back(pair<EventHandlerWrapperPtr, SocketOperation>(*p, op));
+            handlers.push_back(pair<EventHandler*, SocketOperation>((*p)->_handler.get(), op));
+        }
     }
+    _readyHandlers.clear();
+}
 
-    for(vector<struct pollfd>::const_iterator q = _pollFdSet.begin(); q != _pollFdSet.end(); ++q)
+void
+Selector::select(int timeout)
+{
+    //
+    // Wait for handlers to be ready.
+    //
+    Lock sync(*this);
+    while(!_destroyed)
     {
-        pair<EventHandler*, SocketOperation> p;
-        if(q->revents != 0)
+        while(!_changes.empty())
+        {
+            CFRunLoopSourceSignal(_source.get());
+            CFRunLoopWakeUp(_runLoop);
+
+            wait();
+        }
+
+        if(_readyHandlers.empty())
         {
-            SOCKET fd = q->fd;
-            assert(fd != _fdIntrRead);
-            assert(_handlers.find(fd) != _handlers.end());
-            p.first = _handlers[fd];
-            p.second = SocketOperationNone;
-            if(q->revents & (POLLIN | POLLERR | POLLHUP))
+            if(timeout > 0)
             {
-                p.second = static_cast<SocketOperation>(p.second | SocketOperationRead);
+                if(!timedWait(IceUtil::Time::seconds(timeout)))
+                {
+                    break;
+                }
             }
-            if(q->revents & POLLOUT)
+            else
             {
-                p.second = static_cast<SocketOperation>(p.second | SocketOperationWrite);
+                wait();
             }
-            assert(p.second);
-            handlers.push_back(p);
+        }
+
+        if(_changes.empty())
+        {
+            break;
         }
     }
-#endif
 }
 
 void
-Selector::updateImpl(EventHandler* handler)
+Selector::processInterrupt()
 {
-    SocketOperation status = static_cast<SocketOperation>(handler->_registered & ~handler->_disabled);
-    _changes.push_back(make_pair(handler, status));
-    if(_selecting)
+    Lock sync(*this);
+    if(!_changes.empty())
     {
-        if(!_interrupted)
+        for(set<EventHandlerWrapperPtr>::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
         {
-            char c = 0;
-            while(true)
-            {
-#ifdef _WIN32
-                if(::send(_fdIntrWrite, &c, 1, 0) == SOCKET_ERROR)
-#else
-                if(::write(_fdIntrWrite, &c, 1) == SOCKET_ERROR)
-#endif
-                {
-                    if(interrupted())
-                    {
-                        continue;
-                    }
-
-                    Ice::SocketException ex(__FILE__, __LINE__);
-                    ex.error = IceInternal::getSocketErrno();
-                    throw ex;
-                }
-                break;
-            }
-            _interrupted = true;
+            (*p)->updateRunLoop();
         }
+        _changes.clear();
+        notify();
     }
-    else
+    if(_destroyed)
     {
-        updateSelector();
+        CFRunLoopStop(_runLoop);
     }
 }
 
 void
-Selector::updateSelector()
+Selector::run()
 {
-    for(vector<pair<EventHandler*, SocketOperation> >::const_iterator p = _changes.begin(); p != _changes.end(); ++p)
     {
-        EventHandler* handler = p->first;
-        SocketOperation status = p->second;
+        Lock sync(*this);
+        _runLoop = CFRunLoopGetCurrent();
+        notify();
+    }
 
-        SOCKET fd = handler->getNativeInfo()->fd();
-        if(status)
-        {
-#if defined(ICE_USE_SELECT)
-            if(status & SocketOperationRead)
-            {
-                FD_SET(fd, &_readFdSet);
-            }
-            else
-            {
-                FD_CLR(fd, &_readFdSet);
-            }
-            if(status & SocketOperationWrite)
-            {
-                FD_SET(fd, &_writeFdSet);
-            }
-            else
-            {
-                FD_CLR(fd, &_writeFdSet);
-            }
-            if(status & SocketOperationConnect)
-            {
-                FD_SET(fd, &_writeFdSet);
-                FD_SET(fd, &_errorFdSet);
-            }
-            else
-            {
-                FD_CLR(fd, &_writeFdSet);
-                FD_CLR(fd, &_errorFdSet);
-            }
-            _handlers[fd] = handler;
-#else
-            short events = 0;
-            if(status & SocketOperationRead)
-            {
-                events |= POLLIN;
-            }
-            if(status & SocketOperationWrite)
-            {
-                events |= POLLOUT;
-            }
-            map<SOCKET, EventHandler*>::const_iterator q = _handlers.find(fd);
-            if(q == _handlers.end())
-            {
-                struct pollfd pollFd;
-                pollFd.fd = fd;
-                pollFd.events = events;
-                pollFd.revents = 0;
-                _pollFdSet.push_back(pollFd);
-                _handlers.insert(make_pair(fd, handler));
-            }
-            else
-            {
-                for(vector<struct pollfd>::iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
-                {
-                    if(r->fd == fd)
-                    {
-                        r->events = events;
-                        break;
-                    }
-                }
-            }
-#endif
-        }
-        else
-        {
-#if defined(ICE_USE_SELECT)
-            FD_CLR(fd, &_readFdSet);
-            FD_CLR(fd, &_writeFdSet);
-            FD_CLR(fd, &_errorFdSet);
-#else
-            for(vector<struct pollfd>::iterator r = _pollFdSet.begin(); r != _pollFdSet.end(); ++r)
-            {
-                if(r->fd == fd)
-                {
-                    _pollFdSet.erase(r);
-                    break;
-                }
-            }
-#endif
-            _handlers.erase(fd);
-        }
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
+    CFRunLoopRun();
+    CFRunLoopRemoveSource(CFRunLoopGetCurrent(), _source.get(), kCFRunLoopDefaultMode);
+}
+
+void
+Selector::ready(EventHandlerWrapper* wrapper, SocketOperation op, int error)
+{
+    Lock sync(*this);
+    wrapper->ready(op, error);
+}
+
+void
+Selector::addReadyHandler(EventHandlerWrapper* wrapper)
+{
+    // Called from ready()
+    _readyHandlers.insert(wrapper);
+    if(_readyHandlers.size() == 1)
+    {
+        notify();
     }
-    _changes.clear();
 }
 
 #endif