laag-libzmq 4.2.3.0

data/vendor/github.com/zeromq/libzmq/src/socket_base.hpp

@@ -0,0 +1,307 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __ZMQ_SOCKET_BASE_HPP_INCLUDED__
+#define __ZMQ_SOCKET_BASE_HPP_INCLUDED__
+
+#include <string>
+#include <map>
+#include <stdarg.h>
+
+#include "own.hpp"
+#include "array.hpp"
+#include "blob.hpp"
+#include "stdint.hpp"
+#include "poller.hpp"
+#include "atomic_counter.hpp"
+#include "i_poll_events.hpp"
+#include "i_mailbox.hpp"
+#include "stdint.hpp"
+#include "clock.hpp"
+#include "pipe.hpp"
+
+extern "C"
+{
+    void zmq_free_event (void *data, void *hint);
+}
+
+namespace zmq
+{
+
+    class ctx_t;
+    class msg_t;
+    class pipe_t;
+
+    class socket_base_t :
+        public own_t,
+        public array_item_t <>,
+        public i_poll_events,
+        public i_pipe_events
+    {
+        friend class reaper_t;
+
+    public:
+
+        //  Returns false if object is not a socket.
+        bool check_tag ();
+
+        //  Create a socket of a specified type.
+        static socket_base_t *create (int type_, zmq::ctx_t *parent_,
+            uint32_t tid_, int sid_);
+
+        //  Returns the mailbox associated with this socket.
+        i_mailbox *get_mailbox ();
+
+        //  Interrupt blocking call if the socket is stuck in one.
+        //  This function can be called from a different thread!
+        void stop ();
+
+        //  Interface for communication with the API layer.
+        int setsockopt (int option_, const void *optval_, size_t optvallen_);
+        int getsockopt (int option_, void *optval_, size_t *optvallen_);
+        int bind (const char *addr_);
+        int connect (const char *addr_);
+        int term_endpoint (const char *addr_);
+        int send (zmq::msg_t *msg_, int flags_);
+        int recv (zmq::msg_t *msg_, int flags_);
+        int add_signaler (signaler_t *s);
+        int remove_signaler (signaler_t *s);
+        int close ();
+
+        //  These functions are used by the polling mechanism to determine
+        //  which events are to be reported from this socket.
+        bool has_in ();
+        bool has_out ();
+
+        //  Joining and leaving groups
+        int join (const char *group);
+        int leave (const char *group);
+
+        //  Using this function reaper thread ask the socket to register with
+        //  its poller.
+        void start_reaping (poller_t *poller_);
+
+        //  i_poll_events implementation. This interface is used when socket
+        //  is handled by the poller in the reaper thread.
+        void in_event ();
+        void out_event ();
+        void timer_event (int id_);
+
+        //  i_pipe_events interface implementation.
+        void read_activated (pipe_t *pipe_);
+        void write_activated (pipe_t *pipe_);
+        void hiccuped (pipe_t *pipe_);
+        void pipe_terminated (pipe_t *pipe_);
+        void lock();
+        void unlock();
+
+        int monitor (const char *endpoint_, int events_);
+
+        void event_connected (const std::string &addr_, zmq::fd_t fd_);
+        void event_connect_delayed (const std::string &addr_, int err_);
+        void event_connect_retried (const std::string &addr_, int interval_);
+        void event_listening (const std::string &addr_, zmq::fd_t fd_);
+        void event_bind_failed (const std::string &addr_, int err_);
+        void event_accepted (const std::string &addr_, zmq::fd_t fd_);
+        void event_accept_failed (const std::string &addr_, int err_);
+        void event_closed (const std::string &addr_, zmq::fd_t fd_);
+        void event_close_failed (const std::string &addr_, int err_);
+        void event_disconnected (const std::string &addr_, zmq::fd_t fd_);
+        void event_handshake_failed_no_detail(const std::string &addr_, int err_);
+        void event_handshake_failed_protocol(const std::string &addr_, int err_);
+        void event_handshake_failed_auth(const std::string &addr_, int err_);
+        void event_handshake_succeeded(const std::string &addr_, int err_);
+
+        //  Query the state of a specific peer. The default implementation
+        //  always returns an ENOTSUP error.
+        virtual int get_peer_state (const void *identity,
+                                    size_t identity_size) const;
+
+    protected:
+
+        socket_base_t (zmq::ctx_t *parent_, uint32_t tid_, int sid_, bool thread_safe_ = false);
+        virtual ~socket_base_t ();
+
+        //  Concrete algorithms for the x- methods are to be defined by
+        //  individual socket types.
+        virtual void xattach_pipe (zmq::pipe_t *pipe_,
+            bool subscribe_to_all_ = false) = 0;
+
+        //  The default implementation assumes there are no specific socket
+        //  options for the particular socket type. If not so, override this
+        //  method.
+        virtual int xsetsockopt (int option_, const void *optval_,
+            size_t optvallen_);
+
+        //  The default implementation assumes that send is not supported.
+        virtual bool xhas_out ();
+        virtual int xsend (zmq::msg_t *msg_);
+
+        //  The default implementation assumes that recv in not supported.
+        virtual bool xhas_in ();
+        virtual int xrecv (zmq::msg_t *msg_);
+
+        //  Returns the credential for the peer from which we have received
+        //  the last message. If no message has been received yet,
+        //  the function returns empty credential.
+        virtual const blob_t &get_credential () const;
+
+        //  i_pipe_events will be forwarded to these functions.
+        virtual void xread_activated (pipe_t *pipe_);
+        virtual void xwrite_activated (pipe_t *pipe_);
+        virtual void xhiccuped (pipe_t *pipe_);
+        virtual void xpipe_terminated (pipe_t *pipe_) = 0;
+
+        //  the default implementation assumes that joub and leave are not supported.
+        virtual int xjoin (const char *group_);
+        virtual int xleave (const char *group_);
+
+        //  Delay actual destruction of the socket.
+        void process_destroy ();
+
+        // Next assigned name on a zmq_connect() call used by ROUTER and STREAM socket types
+        std::string connect_routing_id;
+
+    private:
+        // test if event should be sent and then dispatch it        
+        void event(const std::string &addr_, intptr_t fd_, int type_);
+
+        // Socket event data dispatch
+        void monitor_event (int event_, intptr_t value_, const std::string& addr_);
+
+        // Monitor socket cleanup
+        void stop_monitor (bool send_monitor_stopped_event_ = true);
+
+        //  Creates new endpoint ID and adds the endpoint to the map.
+        void add_endpoint (const char *addr_, own_t *endpoint_, pipe_t *pipe);
+
+        //  Map of open endpoints.
+        typedef std::pair <own_t *, pipe_t*> endpoint_pipe_t;
+        typedef std::multimap <std::string, endpoint_pipe_t> endpoints_t;
+        endpoints_t endpoints;
+
+        //  Map of open inproc endpoints.
+        typedef std::multimap <std::string, pipe_t *> inprocs_t;
+        inprocs_t inprocs;
+
+        //  To be called after processing commands or invoking any command
+        //  handlers explicitly. If required, it will deallocate the socket.
+        void check_destroy ();
+
+        //  Moves the flags from the message to local variables,
+        //  to be later retrieved by getsockopt.
+        void extract_flags (msg_t *msg_);
+
+        //  Used to check whether the object is a socket.
+        uint32_t tag;
+
+        //  If true, associated context was already terminated.
+        bool ctx_terminated;
+
+        //  If true, object should have been already destroyed. However,
+        //  destruction is delayed while we unwind the stack to the point
+        //  where it doesn't intersect the object being destroyed.
+        bool destroyed;
+
+        //  Parse URI string.
+        int parse_uri (const char *uri_, std::string &protocol_,
+            std::string &address_);
+
+        //  Check whether transport protocol, as specified in connect or
+        //  bind, is available and compatible with the socket type.
+        int check_protocol (const std::string &protocol_);
+
+        //  Register the pipe with this socket.
+        void attach_pipe (zmq::pipe_t *pipe_, bool subscribe_to_all_ = false);
+
+        //  Processes commands sent to this socket (if any). If timeout is -1,
+        //  returns only after at least one command was processed.
+        //  If throttle argument is true, commands are processed at most once
+        //  in a predefined time period.
+        int process_commands (int timeout_, bool throttle_);
+
+        //  Handlers for incoming commands.
+        void process_stop ();
+        void process_bind (zmq::pipe_t *pipe_);
+        void process_term (int linger_);
+        void process_term_endpoint (std::string *endpoint_);
+
+        void update_pipe_options(int option_);
+
+        //  Socket's mailbox object.
+        i_mailbox *mailbox;
+
+        //  List of attached pipes.
+        typedef array_t <pipe_t, 3> pipes_t;
+        pipes_t pipes;
+
+        //  Reaper's poller and handle of this socket within it.
+        poller_t *poller;
+        poller_t::handle_t handle;
+
+        //  Timestamp of when commands were processed the last time.
+        uint64_t last_tsc;
+
+        //  Number of messages received since last command processing.
+        int ticks;
+
+        //  True if the last message received had MORE flag set.
+        bool rcvmore;
+
+        //  Improves efficiency of time measurement.
+        clock_t clock;
+
+        // Monitor socket;
+        void *monitor_socket;
+
+        // Bitmask of events being monitored
+        int monitor_events;
+
+        // Last socket endpoint resolved URI
+        std::string last_endpoint;
+
+        // Indicate if the socket is thread safe
+        bool thread_safe;
+
+        // Signaler to be used in the reaping stage
+        signaler_t* reaper_signaler;
+
+        // Mutex for synchronize access to the socket in thread safe mode
+        mutex_t sync;
+
+        // Mutex to synchronize access to the monitor Pair socket
+        mutex_t monitor_sync;
+
+        socket_base_t (const socket_base_t&);
+        const socket_base_t &operator = (const socket_base_t&);
+    };
+
+}
+
+#endif

data/vendor/github.com/zeromq/libzmq/src/socket_poller.cpp

@@ -0,0 +1,697 @@
+/*
+    Copyright (c) 2007-2016 Contributors as noted in the AUTHORS file
+
+    This file is part of libzmq, the ZeroMQ core engine in C++.
+
+    libzmq is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License (LGPL) as published
+    by the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    As a special exception, the Contributors give you permission to link
+    this library with independent modules to produce an executable,
+    regardless of the license terms of these independent modules, and to
+    copy and distribute the resulting executable under terms of your choice,
+    provided that you also meet, for each linked independent module, the
+    terms and conditions of the license of that module. An independent
+    module is a module which is not derived from or based on this library.
+    If you modify this library, you must extend this exception to your
+    version of the library.
+
+    libzmq is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+    License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "precompiled.hpp"
+#include "socket_poller.hpp"
+#include "err.hpp"
+
+zmq::socket_poller_t::socket_poller_t () :
+    tag (0xCAFEBABE),
+    signaler (NULL),
+    need_rebuild (true),
+    use_signaler (false),
+    poll_size(0)
+#if defined ZMQ_POLL_BASED_ON_POLL
+    ,
+    pollfds (NULL)
+#elif defined ZMQ_POLL_BASED_ON_SELECT
+    ,
+    maxfd(0)
+#endif
+{
+#if defined ZMQ_POLL_BASED_ON_SELECT
+#if defined ZMQ_HAVE_WINDOWS
+    // On Windows fd_set contains array of SOCKETs, each 4 bytes.
+    // For large fd_sets memset() could be expensive and it is unnecessary.
+    // It is enough to set fd_count to 0, exactly what FD_ZERO() macro does.
+    FD_ZERO (&pollset_in);
+    FD_ZERO (&pollset_out);
+    FD_ZERO (&pollset_err);
+#else
+    memset(&pollset_in, 0, sizeof(pollset_in));
+    memset(&pollset_out, 0, sizeof(pollset_out));
+    memset(&pollset_err, 0, sizeof(pollset_err));
+#endif
+#endif
+}
+
+zmq::socket_poller_t::~socket_poller_t ()
+{
+    //  Mark the socket_poller as dead
+    tag = 0xdeadbeef;
+
+    for (items_t::iterator it = items.begin(); it != items.end(); ++it) {
+        if (it->socket && it->socket->check_tag()) {
+            int thread_safe;
+            size_t thread_safe_size = sizeof(int);
+
+            if (it->socket->getsockopt (ZMQ_THREAD_SAFE, &thread_safe, &thread_safe_size) == 0 && thread_safe)
+                it->socket->remove_signaler (signaler);
+        }
+    }
+
+    if (signaler != NULL) {
+        delete signaler;
+        signaler = NULL;
+    }
+
+#if defined ZMQ_POLL_BASED_ON_POLL
+    if (pollfds) {
+        free (pollfds);
+        pollfds = NULL;
+    }
+#endif
+}
+
+bool zmq::socket_poller_t::check_tag ()
+{
+    return tag == 0xCAFEBABE;
+}
+
+int zmq::socket_poller_t::add (socket_base_t *socket_, void* user_data_, short events_)
+{
+    for (items_t::iterator it = items.begin (); it != items.end (); ++it) {
+        if (it->socket == socket_) {
+            errno = EINVAL;
+            return -1;
+        }
+    }
+
+    int thread_safe;
+    size_t thread_safe_size = sizeof(int);
+
+    int rc =
+      socket_->getsockopt (ZMQ_THREAD_SAFE, &thread_safe, &thread_safe_size);
+    zmq_assert (rc == 0);
+
+    if (thread_safe) {
+        if (signaler == NULL)
+            signaler = new signaler_t ();
+
+        rc = socket_->add_signaler (signaler);
+        zmq_assert (rc == 0);
+    }
+
+    item_t item = {socket_, 0, user_data_, events_
+#if defined ZMQ_POLL_BASED_ON_POLL
+                   ,-1
+#endif
+    };
+    items.push_back (item);
+    need_rebuild = true;
+
+    return 0;
+}
+
+int zmq::socket_poller_t::add_fd (fd_t fd_, void *user_data_, short events_)
+{
+   for (items_t::iterator it = items.begin (); it != items.end (); ++it) {
+        if (!it->socket && it->fd == fd_) {
+            errno = EINVAL;
+            return -1;
+        }
+    }
+
+    item_t item = {NULL, fd_, user_data_, events_
+#if defined ZMQ_POLL_BASED_ON_POLL
+                   ,-1
+#endif
+                   };
+    items.push_back (item);
+    need_rebuild = true;
+
+    return 0;
+}
+
+int zmq::socket_poller_t::modify (socket_base_t  *socket_, short events_)
+{
+    items_t::iterator it;
+
+    for (it = items.begin (); it != items.end (); ++it) {
+        if (it->socket == socket_)
+            break;
+    }
+
+    if (it == items.end()) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    it->events = events_;
+    need_rebuild = true;
+
+    return 0;
+}
+
+
+int zmq::socket_poller_t::modify_fd (fd_t fd_, short events_)
+{
+    items_t::iterator it;
+
+    for (it = items.begin (); it != items.end (); ++it) {
+        if (!it->socket && it->fd == fd_)
+            break;
+    }
+
+    if (it == items.end()) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    it->events = events_;
+    need_rebuild = true;
+
+    return 0;
+}
+
+
+int zmq::socket_poller_t::remove (socket_base_t *socket_)
+{
+    items_t::iterator it;
+
+    for (it = items.begin (); it != items.end (); ++it) {
+        if (it->socket == socket_)
+            break;
+    }
+
+    if (it == items.end()) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    items.erase(it);
+    need_rebuild = true;
+
+    int thread_safe;
+    size_t thread_safe_size = sizeof(int);
+
+    if (socket_->getsockopt (ZMQ_THREAD_SAFE, &thread_safe, &thread_safe_size) == 0 && thread_safe)
+        socket_->remove_signaler (signaler);
+
+    return 0;
+}
+
+int zmq::socket_poller_t::remove_fd (fd_t fd_)
+{
+    items_t::iterator it;
+
+    for (it = items.begin (); it != items.end (); ++it) {
+        if (!it->socket && it->fd == fd_)
+            break;
+    }
+
+    if (it == items.end()) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    items.erase (it);
+    need_rebuild = true;
+
+    return 0;
+}
+
+void zmq::socket_poller_t::rebuild ()
+{
+#if defined ZMQ_POLL_BASED_ON_POLL
+
+    if (pollfds) {
+        free (pollfds);
+        pollfds = NULL;
+    }
+
+    use_signaler = false;
+
+    poll_size = 0;
+
+    for (items_t::iterator it = items.begin (); it != items.end (); ++it) {
+        if (it->events) {
+            if (it->socket) {
+                int thread_safe;
+                size_t thread_safe_size = sizeof(int);
+
+                int rc = it->socket->getsockopt (ZMQ_THREAD_SAFE, &thread_safe,
+                                                 &thread_safe_size);
+                zmq_assert (rc == 0);
+
+                if (thread_safe) {
+                    if (!use_signaler) {
+                        use_signaler = true;
+                        poll_size++;
+                    }
+                }
+                else
+                    poll_size++;
+            }
+            else
+                poll_size++;
+        }
+    }
+
+    if (poll_size == 0)
+        return;
+
+    pollfds = (pollfd*) malloc (poll_size * sizeof (pollfd));
+    alloc_assert (pollfds);
+
+    int item_nbr = 0;
+
+    if (use_signaler) {
+        item_nbr = 1;
+        pollfds[0].fd = signaler->get_fd();
+        pollfds[0].events = POLLIN;
+    }
+
+    for (items_t::iterator it = items.begin (); it != items.end (); ++it) {
+        if (it->events) {
+            if (it->socket) {
+                int thread_safe;
+                size_t thread_safe_size = sizeof(int);
+
+                int rc = it->socket->getsockopt (ZMQ_THREAD_SAFE, &thread_safe,
+                                                 &thread_safe_size);
+                zmq_assert (rc == 0);
+
+                if (!thread_safe) {
+                    size_t fd_size = sizeof (zmq::fd_t);
+                    rc = it->socket->getsockopt (ZMQ_FD, &pollfds [item_nbr].fd, &fd_size);
+                    zmq_assert (rc == 0);
+
+                    pollfds [item_nbr].events = POLLIN;
+                    item_nbr++;
+                }
+            }
+            else {
+                pollfds [item_nbr].fd = it->fd;
+                pollfds [item_nbr].events =
+                    (it->events & ZMQ_POLLIN ? POLLIN : 0) |
+                    (it->events & ZMQ_POLLOUT ? POLLOUT : 0) |
+                    (it->events & ZMQ_POLLPRI ? POLLPRI : 0);
+                it->pollfd_index = item_nbr;
+                item_nbr++;
+            }
+        }
+    }
+
+ #elif defined ZMQ_POLL_BASED_ON_SELECT
+
+    FD_ZERO (&pollset_in);
+    FD_ZERO (&pollset_out);
+    FD_ZERO (&pollset_err);
+
+    //  Ensure we do not attempt to select () on more than FD_SETSIZE
+    //  file descriptors.
+    zmq_assert (items.size () <= FD_SETSIZE);
+
+    poll_size = 0;
+
+    use_signaler = false;
+
+    for (items_t::iterator it = items.begin (); it != items.end (); ++it) {
+        if (it->socket) {
+            int thread_safe;
+            size_t thread_safe_size = sizeof(int);
+
+            int rc = it->socket->getsockopt (ZMQ_THREAD_SAFE, &thread_safe,
+                                             &thread_safe_size);
+            zmq_assert (rc == 0);
+
+            if (thread_safe && it->events) {
+                use_signaler = true;
+                FD_SET (signaler->get_fd (), &pollset_in);
+                poll_size = 1;
+                break;
+            }
+        }
+    }
+
+    maxfd = 0;
+
+    //  Build the fd_sets for passing to select ().
+    for (items_t::iterator it = items.begin (); it != items.end (); ++it) {
+        if (it->events) {
+            //  If the poll item is a 0MQ socket we are interested in input on the
+            //  notification file descriptor retrieved by the ZMQ_FD socket option.
+            if (it->socket) {
+                int thread_safe;
+                size_t thread_safe_size = sizeof(int);
+
+                int rc = it->socket->getsockopt (ZMQ_THREAD_SAFE, &thread_safe,
+                                                 &thread_safe_size);
+                zmq_assert (rc == 0);
+
+                if (!thread_safe) {
+                    zmq::fd_t notify_fd;
+                    size_t fd_size = sizeof (zmq::fd_t);
+                    rc = it->socket->getsockopt (ZMQ_FD, &notify_fd, &fd_size);
+                    zmq_assert (rc == 0);
+
+                    FD_SET (notify_fd, &pollset_in);
+                    if (maxfd < notify_fd)
+                        maxfd = notify_fd;
+
+                    poll_size++;
+                }
+            }
+            //  Else, the poll item is a raw file descriptor. Convert the poll item
+            //  events to the appropriate fd_sets.
+            else {
+                if (it->events & ZMQ_POLLIN)
+                    FD_SET (it->fd, &pollset_in);
+                if (it->events & ZMQ_POLLOUT)
+                    FD_SET (it->fd, &pollset_out);
+                if (it->events & ZMQ_POLLERR)
+                    FD_SET (it->fd, &pollset_err);
+                if (maxfd < it->fd)
+                    maxfd = it->fd;
+
+                poll_size++;
+            }
+        }
+    }
+
+#endif
+
+    need_rebuild = false;
+}
+
+void zmq::socket_poller_t::zero_trail_events (
+                                         zmq::socket_poller_t::event_t *events_,
+                                         int n_events_,
+                                         int found)
+{
+    for (int i = found; i < n_events_; ++i) {
+        events_[i].socket = NULL;
+        events_[i].fd = 0;
+        events_[i].user_data = NULL;
+        events_[i].events = 0;
+    }
+}
+
+#if defined ZMQ_POLL_BASED_ON_POLL
+int zmq::socket_poller_t::check_events (zmq::socket_poller_t::event_t *events_,
+                                                              int n_events_)
+#elif defined ZMQ_POLL_BASED_ON_SELECT
+int zmq::socket_poller_t::check_events (zmq::socket_poller_t::event_t *events_,
+                                                              int n_events_,
+                                                              fd_set& inset,
+                                                              fd_set& outset,
+                                                              fd_set& errset)
+#endif
+{
+    int found = 0;
+    for (items_t::iterator it = items.begin (); it != items.end () &&
+                                                  found < n_events_; ++it) {
+
+        //  The poll item is a 0MQ socket. Retrieve pending events
+        //  using the ZMQ_EVENTS socket option.
+        if (it->socket) {
+            size_t events_size = sizeof (uint32_t);
+            uint32_t events;
+            if (it->socket->getsockopt (ZMQ_EVENTS, &events, &events_size)
+                                                                        == -1) {
+                return -1;
+            }
+
+            if (it->events & events) {
+                events_[found].socket = it->socket;
+                events_[found].user_data = it->user_data;
+                events_[found].events = it->events & events;
+                ++found;
+            }
+        }
+        //  Else, the poll item is a raw file descriptor, simply convert
+        //  the events to zmq_pollitem_t-style format.
+        else {
+
+#if defined ZMQ_POLL_BASED_ON_POLL
+
+            short revents = pollfds [it->pollfd_index].revents;
+            short events = 0;
+
+            if (revents & POLLIN)
+                events |= ZMQ_POLLIN;
+            if (revents & POLLOUT)
+                events |= ZMQ_POLLOUT;
+            if (revents & POLLPRI)
+                events |= ZMQ_POLLPRI;
+            if (revents & ~(POLLIN | POLLOUT | POLLPRI))
+                events |= ZMQ_POLLERR;
+
+#elif defined ZMQ_POLL_BASED_ON_SELECT
+
+            short events = 0;
+
+            if (FD_ISSET (it->fd, &inset))
+                events |= ZMQ_POLLIN;
+            if (FD_ISSET (it->fd, &outset))
+                events |= ZMQ_POLLOUT;
+            if (FD_ISSET (it->fd, &errset))
+                events |= ZMQ_POLLERR;
+#endif //POLL_SELECT
+
+            if (events) {
+                events_[found].socket = NULL;
+                events_[found].user_data = it->user_data;
+                events_[found].fd = it->fd;
+                events_[found].events = events;
+                ++found;
+            }
+        }
+    }
+
+    return found;
+}
+
+//Return 0 if timeout is expired otherwise 1
+int zmq::socket_poller_t::adjust_timeout (zmq::clock_t& clock, long timeout_,
+                                                              uint64_t& now,
+                                                              uint64_t& end,
+                                                              bool& first_pass)
+{
+
+    //  If socket_poller_t::timeout is zero, exit immediately whether there
+    //  are events or not.
+    if (timeout_ == 0)
+        return 0;
+
+    //  At this point we are meant to wait for events but there are none.
+    //  If timeout is infinite we can just loop until we get some events.
+    if (timeout_ < 0) {
+        if (first_pass)
+            first_pass = false;
+        return 1;
+    }
+
+    //  The timeout is finite and there are no events. In the first pass
+    //  we get a timestamp of when the polling have begun. (We assume that
+    //  first pass have taken negligible time). We also compute the time
+    //  when the polling should time out.
+    now = clock.now_ms ();
+    if (first_pass) {
+        end = now + timeout_;
+        first_pass = false;
+        return 1;
+    }
+
+    //  Find out whether timeout have expired.
+    if (now >= end)
+        return 0;
+
+    return 1;
+}
+
+int zmq::socket_poller_t::wait (zmq::socket_poller_t::event_t *events_,
+                                                         int n_events_,
+                                                         long timeout_)
+{
+    if (items.empty () && timeout_ < 0) {
+        errno = EFAULT;
+        return -1;
+    }
+
+    if (need_rebuild)
+        rebuild ();
+
+    if (unlikely (poll_size == 0)) {
+        // We'll report an error (timed out) as if the list was non-empty and
+        // no event occurred within the specified timeout. Otherwise the caller
+        // needs to check the return value AND the event to avoid using the
+        // nullified event data.
+        errno = EAGAIN;
+        if (timeout_ == 0)
+            return -1;
+#if defined ZMQ_HAVE_WINDOWS
+        Sleep (timeout_ > 0 ? timeout_ : INFINITE);
+        return -1;
+#elif defined ZMQ_HAVE_ANDROID
+        usleep (timeout_ * 1000);
+        return -1;
+#elif defined ZMQ_HAVE_OSX
+        usleep (timeout_ * 1000);
+        errno = EAGAIN;
+        return -1;
+#else
+        usleep (timeout_ * 1000);
+        return -1;
+#endif
+    }
+
+#if defined ZMQ_POLL_BASED_ON_POLL
+    zmq::clock_t clock;
+    uint64_t now = 0;
+    uint64_t end = 0;
+
+    bool first_pass = true;
+
+    while (true) {
+        //  Compute the timeout for the subsequent poll.
+        int timeout;
+        if (first_pass)
+            timeout = 0;
+        else
+        if (timeout_ < 0)
+            timeout = -1;
+        else
+            timeout = end - now;
+
+        //  Wait for events.
+        while (true) {
+            int rc = poll (pollfds, poll_size, timeout);
+            if (rc == -1 && errno == EINTR) {
+                return -1;
+            }
+            errno_assert (rc >= 0);
+            break;
+        }
+
+        //  Receive the signal from pollfd
+        if (use_signaler && pollfds[0].revents & POLLIN)
+            signaler->recv ();
+
+        //  Check for the events.
+        int found = check_events (events_, n_events_);
+        if (found) {
+            if (found > 0)
+                zero_trail_events (events_, n_events_, found);
+            return found;
+        }
+
+        //  Adjust timeout or break
+        if (adjust_timeout (clock, timeout_, now, end, first_pass) == 0)
+            break;
+    }
+    errno = EAGAIN;
+    return -1;
+
+#elif defined ZMQ_POLL_BASED_ON_SELECT
+
+    zmq::clock_t clock;
+    uint64_t now = 0;
+    uint64_t end = 0;
+
+    bool first_pass = true;
+
+    fd_set inset, outset, errset;
+
+    while (true) {
+
+        //  Compute the timeout for the subsequent poll.
+        timeval timeout;
+        timeval *ptimeout;
+        if (first_pass) {
+            timeout.tv_sec = 0;
+            timeout.tv_usec = 0;
+            ptimeout = &timeout;
+        }
+        else
+        if (timeout_ < 0)
+            ptimeout = NULL;
+        else {
+            timeout.tv_sec = (long) ((end - now) / 1000);
+            timeout.tv_usec = (long) ((end - now) % 1000 * 1000);
+            ptimeout = &timeout;
+        }
+
+        //  Wait for events. Ignore interrupts if there's infinite timeout.
+        while (true) {
+#if defined ZMQ_HAVE_WINDOWS
+            // On Windows we don't need to copy the whole fd_set.
+            // SOCKETS are continuous from the beginning of fd_array in fd_set.
+            // We just need to copy fd_count elements of fd_array.
+            // We gain huge memcpy() improvement if number of used SOCKETs is much lower than FD_SETSIZE.
+            memcpy (&inset,  &pollset_in,  (char *) (pollset_in.fd_array  + pollset_in.fd_count ) - (char *) &pollset_in );
+            memcpy (&outset, &pollset_out, (char *) (pollset_out.fd_array + pollset_out.fd_count) - (char *) &pollset_out);
+            memcpy (&errset, &pollset_err, (char *) (pollset_err.fd_array + pollset_err.fd_count) - (char *) &pollset_err);
+            int rc = select (0, &inset, &outset, &errset, ptimeout);
+            if (unlikely (rc == SOCKET_ERROR)) {
+                errno = zmq::wsa_error_to_errno (WSAGetLastError ());
+                wsa_assert (errno == ENOTSOCK);
+                return -1;
+            }
+#else
+            memcpy (&inset, &pollset_in, sizeof (fd_set));
+            memcpy (&outset, &pollset_out, sizeof (fd_set));
+            memcpy (&errset, &pollset_err, sizeof (fd_set));
+            int rc = select (maxfd + 1, &inset, &outset, &errset, ptimeout);
+            if (unlikely (rc == -1)) {
+                errno_assert (errno == EINTR || errno == EBADF);
+                return -1;
+            }
+#endif
+            break;
+        }
+
+        if (use_signaler && FD_ISSET (signaler->get_fd (), &inset))
+            signaler->recv ();
+
+        //  Check for the events.
+        int found = check_events(events_, n_events_, inset, outset, errset);
+        if (found) {
+            if (found > 0)
+                zero_trail_events (events_, n_events_, found);
+            return found;
+        }
+
+        //  Adjust timeout or break
+        if (adjust_timeout (clock, timeout_, now, end, first_pass) == 0)
+            break;
+    }
+
+    errno = EAGAIN;
+    return -1;
+
+#else
+
+    //  Exotic platforms that support neither poll() nor select().
+    errno = ENOTSUP;
+    return -1;
+
+#endif
+}