libzmq 0.0.1

data/libzmq/zeromq-2.1.7/src/select.hpp

@@ -0,0 +1,116 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ 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_SELECT_HPP_INCLUDED__
+#define __ZMQ_SELECT_HPP_INCLUDED__
+
+#include "platform.hpp"
+
+#include <stddef.h>
+#include <vector>
+
+#ifdef ZMQ_HAVE_WINDOWS
+#include "winsock2.h"
+#elif defined ZMQ_HAVE_OPENVMS
+#include <sys/types.h>
+#include <sys/time.h>
+#else
+#include <sys/select.h>
+#endif
+
+#include "fd.hpp"
+#include "thread.hpp"
+#include "poller_base.hpp"
+
+namespace zmq
+{
+
+    //  Implements socket polling mechanism using POSIX.1-2001 select()
+    //  function.
+
+    class select_t : public poller_base_t
+    {
+    public:
+
+        typedef fd_t handle_t;
+
+        select_t ();
+        ~select_t ();
+
+        //  "poller" concept.
+        handle_t add_fd (fd_t fd_, struct i_poll_events *events_);
+        void rm_fd (handle_t handle_);
+        void set_pollin (handle_t handle_);
+        void reset_pollin (handle_t handle_);
+        void set_pollout (handle_t handle_);
+        void reset_pollout (handle_t handle_);
+        void start ();
+        void stop ();
+
+    private:
+
+        //  Main worker thread routine.
+        static void worker_routine (void *arg_);
+
+        //  Main event loop.
+        void loop ();
+
+        struct fd_entry_t
+        {
+            fd_t fd;
+            struct i_poll_events *events;
+        };
+
+        //  Checks if an fd_entry_t is retired.
+        static bool is_retired_fd (const fd_entry_t &entry);
+
+        //  Set of file descriptors that are used to retreive
+        //  information for fd_set.
+        typedef std::vector <fd_entry_t> fd_set_t;
+        fd_set_t fds;
+
+        fd_set source_set_in;
+        fd_set source_set_out;
+        fd_set source_set_err;
+
+        fd_set readfds;
+        fd_set writefds;
+        fd_set exceptfds;
+
+        //  Maximum file descriptor.
+        fd_t maxfd;
+
+        //  If true, at least one file descriptor has retired.
+        bool retired;
+
+        //  If true, thread is shutting down.
+        bool stopping;
+
+        //  Handle of the physical thread doing the I/O work.
+        thread_t worker;
+
+        select_t (const select_t&);
+        const select_t &operator = (const select_t&);
+    };
+
+}
+
+#endif
+

data/libzmq/zeromq-2.1.7/src/semaphore.hpp

@@ -0,0 +1,189 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ 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_SEMAPHORE_HPP_INCLUDED__
+#define __ZMQ_SEMAPHORE_HPP_INCLUDED__
+
+#include "platform.hpp"
+#include "err.hpp"
+
+#if defined ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#elif defined ZMQ_HAVE_OPENVMS
+#include <pthread.h>
+#else
+#include <semaphore.h>
+#endif
+
+namespace zmq
+{
+    //  Simple semaphore. Only single thread may be waiting at any given time.
+    //  Also, the semaphore may not be posted before the previous post
+    //  was matched by corresponding wait and the waiting thread was
+    //  released.
+
+#if defined ZMQ_HAVE_WINDOWS
+
+    //  On Windows platform simple semaphore is implemeted using event object.
+
+    class semaphore_t
+    { 
+    public:
+
+        //  Initialise the semaphore.
+        inline semaphore_t ()
+        {
+            ev = CreateEvent (NULL, FALSE, FALSE, NULL);
+            win_assert (ev != NULL);
+        }
+
+        //  Destroy the semaphore.
+        inline ~semaphore_t ()
+        {
+            int rc = CloseHandle (ev);
+            win_assert (rc != 0);    
+        }
+
+        //  Wait for the semaphore.
+        inline void wait ()
+        {
+            DWORD rc = WaitForSingleObject (ev, INFINITE);
+            win_assert (rc != WAIT_FAILED);
+        }
+
+        //  Post the semaphore.
+        inline void post ()
+        {
+            int rc = SetEvent (ev);
+            win_assert (rc != 0);
+        }
+
+    private:
+
+        HANDLE ev;
+
+        semaphore_t (const semaphore_t&);
+        const semaphore_t &operator = (const semaphore_t&);
+    };
+
+#elif defined ZMQ_HAVE_LINUX || defined ZMQ_HAVE_OSX || defined ZMQ_HAVE_OPENVMS
+
+    //  On platforms that allow for double locking of a mutex from the same
+    //  thread, simple semaphore is implemented using mutex, as it is more
+    //  efficient than full-blown semaphore.
+
+    //  Note that OS-level semaphore is not implemented on OSX, so the below
+    //  code is not only optimisation, it's necessary to make 0MQ work on OSX.
+
+    class semaphore_t
+    { 
+    public:
+
+        //  Initialise the semaphore.
+        inline semaphore_t ()
+        {
+            int rc = pthread_mutex_init (&mutex, NULL);
+            posix_assert (rc);
+            rc = pthread_mutex_lock (&mutex);
+            posix_assert (rc);
+        }
+
+        //  Destroy the semaphore.
+        inline ~semaphore_t ()
+        {
+            int rc = pthread_mutex_unlock (&mutex);
+            posix_assert (rc);
+            rc = pthread_mutex_destroy (&mutex);
+            posix_assert (rc);
+        }
+
+        //  Wait for the semaphore.
+        inline void wait ()
+        {
+             int rc = pthread_mutex_lock (&mutex);
+             posix_assert (rc);
+        }
+
+        //  Post the semaphore.
+        inline void post ()
+        {
+            int rc = pthread_mutex_unlock (&mutex);
+            posix_assert (rc);
+        }
+
+    private:
+
+        pthread_mutex_t mutex;
+
+        semaphore_t (const semaphore_t&);
+        const semaphore_t &operator = (const semaphore_t&);
+    };
+
+#else
+
+    //  Default implementation maps simple semaphore to POSIX semaphore.
+
+    class semaphore_t
+    { 
+    public:
+
+        //  Initialise the semaphore.
+        inline semaphore_t ()
+        {
+             int rc = sem_init (&sem, 0, 0);
+             errno_assert (rc != -1);
+        }
+
+        //  Destroy the semaphore.
+        inline ~semaphore_t ()
+        {
+             int rc = sem_destroy (&sem);
+             errno_assert (rc != -1);
+        }
+
+        //  Wait for the semaphore.
+        inline void wait ()
+        {
+             int rc = sem_wait (&sem);
+             errno_assert (rc != -1);
+        }
+
+        //  Post the semaphore.
+        inline void post ()
+        {
+            int rc = sem_post (&sem);
+            errno_assert (rc != -1);
+        }
+
+    private:
+
+        //  Underlying system semaphore object.
+        sem_t sem;
+
+        semaphore_t (const semaphore_t&);
+        const semaphore_t &operator = (const semaphore_t&);
+    };
+
+#endif
+
+}
+
+#endif
+

data/libzmq/zeromq-2.1.7/src/session.cpp

@@ -0,0 +1,347 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ 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 "session.hpp"
+#include "socket_base.hpp"
+#include "i_engine.hpp"
+#include "err.hpp"
+#include "pipe.hpp"
+#include "likely.hpp"
+
+zmq::session_t::session_t (class io_thread_t *io_thread_,
+      class socket_base_t *socket_, const options_t &options_) :
+    own_t (io_thread_, options_),
+    io_object_t (io_thread_),
+    in_pipe (NULL),
+    incomplete_in (false),
+    out_pipe (NULL),
+    engine (NULL),
+    socket (socket_),
+    io_thread (io_thread_),
+    pipes_attached (false),
+    delimiter_processed (false),
+    force_terminate (false),
+    has_linger_timer (false),
+    state (active)
+{    
+}
+
+zmq::session_t::~session_t ()
+{
+    zmq_assert (!in_pipe);
+    zmq_assert (!out_pipe);
+
+    if (engine)
+        engine->terminate ();
+}
+
+void zmq::session_t::proceed_with_term ()
+{
+    if (state == terminating)
+        return;
+
+    zmq_assert (state == pending);
+    state = terminating;
+
+    //  If there's still a pending linger timer, remove it.
+    if (has_linger_timer) {
+        cancel_timer (linger_timer_id);
+        has_linger_timer = false;
+    }
+
+    if (in_pipe) {
+        register_term_acks (1);
+        in_pipe->terminate ();
+    }
+    if (out_pipe) {
+        register_term_acks (1);
+        out_pipe->terminate ();
+    }
+
+    //  The session has already waited for the linger period. We don't want
+    //  the child objects to linger any more thus linger is set to zero.
+    own_t::process_term (0);
+}
+
+bool zmq::session_t::read (::zmq_msg_t *msg_)
+{
+    if (!in_pipe)
+        return false;
+
+    if (!in_pipe->read (msg_))
+        return false;
+
+    incomplete_in = msg_->flags & ZMQ_MSG_MORE;
+    return true;
+}
+
+bool zmq::session_t::write (::zmq_msg_t *msg_)
+{
+    if (out_pipe && out_pipe->write (msg_)) {
+        zmq_msg_init (msg_);
+        return true;
+    }
+
+    return false;
+}
+
+void zmq::session_t::flush ()
+{
+    if (out_pipe)
+        out_pipe->flush ();
+}
+
+void zmq::session_t::clean_pipes ()
+{
+    //  Get rid of half-processed messages in the out pipe. Flush any
+    //  unflushed messages upstream.
+    if (out_pipe) {
+        out_pipe->rollback ();
+        out_pipe->flush ();
+    }
+
+    //  Remove any half-read message from the in pipe.
+    if (in_pipe) {
+        while (incomplete_in) {
+            zmq_msg_t msg;
+            zmq_msg_init (&msg);
+            if (!read (&msg)) {
+                zmq_assert (!incomplete_in);
+                break;
+            }
+            zmq_msg_close (&msg);
+        }
+    }
+}
+
+void zmq::session_t::attach_pipes (class reader_t *inpipe_,
+    class writer_t *outpipe_, const blob_t &peer_identity_)
+{
+    zmq_assert (!pipes_attached);
+    pipes_attached = true;
+    
+    if (inpipe_) {
+        zmq_assert (!in_pipe);
+        in_pipe = inpipe_;
+        in_pipe->set_event_sink (this);
+    }
+
+    if (outpipe_) {
+        zmq_assert (!out_pipe);
+        out_pipe = outpipe_;
+        out_pipe->set_event_sink (this);
+    }
+
+    //  If we are already terminating, terminate the pipes straight away.
+    if (state == terminating) {
+        if (in_pipe) {
+            in_pipe->terminate ();
+            register_term_acks (1);
+        }
+        if (out_pipe) {
+            out_pipe->terminate ();
+            register_term_acks (1);
+        }
+    }
+}
+
+void zmq::session_t::delimited (reader_t *pipe_)
+{
+    zmq_assert (in_pipe == pipe_);
+    zmq_assert (!delimiter_processed);
+    delimiter_processed = true;
+
+    //  If we are in process of being closed, but still waiting for all
+    //  pending messeges being sent, we can terminate here.
+    if (state == pending)
+        proceed_with_term ();
+}
+
+void zmq::session_t::terminated (reader_t *pipe_)
+{
+    zmq_assert (in_pipe == pipe_);
+    in_pipe = NULL;
+    if (state == terminating)
+        unregister_term_ack ();
+}
+
+void zmq::session_t::terminated (writer_t *pipe_)
+{
+    zmq_assert (out_pipe == pipe_);
+    out_pipe = NULL;
+    if (state == terminating)
+        unregister_term_ack ();
+}
+
+void zmq::session_t::activated (reader_t *pipe_)
+{
+    zmq_assert (in_pipe == pipe_);
+
+    if (likely (engine != NULL))
+        engine->activate_out ();
+    else
+        in_pipe->check_read ();
+}
+
+void zmq::session_t::activated (writer_t *pipe_)
+{
+    zmq_assert (out_pipe == pipe_);
+    if (engine)
+        engine->activate_in ();
+}
+
+void zmq::session_t::process_plug ()
+{
+}
+
+void zmq::session_t::process_attach (i_engine *engine_,
+    const blob_t &peer_identity_)
+{
+    //  If some other object (e.g. init) notifies us that the connection failed
+    //  we need to start the reconnection process.
+    if (!engine_) {
+        zmq_assert (!engine);
+        detached ();
+        return;
+    }
+
+    //  If we are already terminating, we destroy the engine straight away.
+    //  Note that we don't have to unplug it before deleting as it's not
+    //  yet plugged to the session.
+    if (state == terminating) {
+        delete engine_;
+        return;
+    }
+
+    //  If the session already has an engine attached, destroy new one.
+    //  Note new engine is not plugged in yet, we don't have to unplug it.
+    if (engine) {
+        log ("DPID: duplicate peer identity - disconnecting peer");
+        delete engine_;
+        return;
+    }
+
+    //  Check whether the required pipes already exist. If not so, we'll
+    //  create them and bind them to the socket object.
+    if (!pipes_attached) {
+        zmq_assert (!in_pipe && !out_pipe);
+        pipes_attached = true;
+        reader_t *socket_reader = NULL;
+        writer_t *socket_writer = NULL;
+
+        //  Create the pipes, as required.
+        if (options.requires_in) {
+            create_pipe (socket, this, options.hwm, options.swap, &socket_reader,
+                &out_pipe);
+            out_pipe->set_event_sink (this);
+        }
+        if (options.requires_out) {
+            create_pipe (this, socket, options.hwm, options.swap, &in_pipe,
+                &socket_writer);
+            in_pipe->set_event_sink (this);
+        }
+
+        //  Bind the pipes to the socket object.
+        if (socket_reader || socket_writer)
+            send_bind (socket, socket_reader, socket_writer, peer_identity_);
+    }
+
+    //  Plug in the engine.
+    engine = engine_;
+    engine->plug (io_thread, this);
+
+    //  Trigger the notfication about the attachment.
+    attached (peer_identity_);
+}
+
+void zmq::session_t::detach ()
+{
+    //  Engine is dead. Let's forget about it.
+    engine = NULL;
+
+    //  Remove any half-done messages from the pipes.
+    clean_pipes ();
+
+    //  Send the event to the derived class.
+    detached ();
+
+    //  Just in case, there's only a delimiter in the inbound pipe.
+    if (in_pipe)
+        in_pipe->check_read ();
+}
+
+void zmq::session_t::process_term (int linger_)
+{
+    zmq_assert (state == active);
+    state = pending;
+
+    //  If linger is set to zero, we can terminate the session straight away
+    //  not waiting for the pending messages to be sent.
+    if (linger_ == 0) {
+        proceed_with_term ();
+        return;
+    }
+
+    //  If there's finite linger value, set up a timer.
+    if (linger_ > 0) {
+       zmq_assert (!has_linger_timer);
+       add_timer (linger_, linger_timer_id);
+       has_linger_timer = true;
+    }
+
+    //  If there's no engine and there's only delimiter in the pipe it wouldn't
+    //  be ever read. Thus we check for it explicitly.
+    if (in_pipe)
+        in_pipe->check_read ();
+
+    //  If there's no in pipe there are no pending messages to send.
+    //  We can proceed with the shutdown straight away. Also, if there is
+    //  inbound pipe, but the delimiter was already processed, we can
+    //  terminate immediately. Alternatively, if the derived session type have
+    //  called 'terminate' we'll finish straight away.
+    if (!options.requires_out || delimiter_processed || force_terminate ||
+        (!options.immediate_connect && !in_pipe))
+        proceed_with_term ();
+}
+
+void zmq::session_t::timer_event (int id_)
+{
+    //  Linger period expired. We can proceed with termination even though
+    //  there are still pending messages to be sent.
+    zmq_assert (id_ == linger_timer_id);
+    has_linger_timer = false;
+    proceed_with_term ();
+}
+
+bool zmq::session_t::register_session (const blob_t &name_, session_t *session_)
+{
+    return socket->register_session (name_, session_);
+}
+
+void zmq::session_t::unregister_session (const blob_t &name_)
+{
+    socket->unregister_session (name_);
+}
+
+void zmq::session_t::terminate ()
+{
+    force_terminate = true;
+    own_t::terminate ();
+}