libzmq 0.0.1

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

@@ -0,0 +1,87 @@
+/*
+    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_ZMQ_ENGINE_HPP_INCLUDED__
+#define __ZMQ_ZMQ_ENGINE_HPP_INCLUDED__
+
+#include <stddef.h>
+
+#include <string>
+
+#include "i_engine.hpp"
+#include "io_object.hpp"
+#include "tcp_socket.hpp"
+#include "encoder.hpp"
+#include "decoder.hpp"
+#include "options.hpp"
+
+namespace zmq
+{
+
+    class zmq_engine_t : public io_object_t, public i_engine
+    {
+    public:
+
+        zmq_engine_t (fd_t fd_, const options_t &options_);
+        ~zmq_engine_t ();
+
+        //  i_engine interface implementation.
+        void plug (class io_thread_t *io_thread_, struct i_inout *inout_);
+        void unplug ();
+        void terminate ();
+        void activate_in ();
+        void activate_out ();
+
+        //  i_poll_events interface implementation.
+        void in_event ();
+        void out_event ();
+
+    private:
+
+        //  Function to handle network disconnections.
+        void error ();
+
+        tcp_socket_t tcp_socket;
+        handle_t handle;
+
+        unsigned char *inpos;
+        size_t insize;
+        decoder_t decoder;
+
+        unsigned char *outpos;
+        size_t outsize;
+        encoder_t encoder;
+
+        i_inout *inout;
+
+        //  Detached transient inout handler.
+        i_inout *ephemeral_inout;
+
+        options_t options;
+
+        bool plugged;
+
+        zmq_engine_t (const zmq_engine_t&);
+        const zmq_engine_t &operator = (const zmq_engine_t&);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,216 @@
+/*
+    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 <string.h>
+
+#include "zmq_init.hpp"
+#include "transient_session.hpp"
+#include "named_session.hpp"
+#include "socket_base.hpp"
+#include "zmq_engine.hpp"
+#include "io_thread.hpp"
+#include "session.hpp"
+#include "uuid.hpp"
+#include "blob.hpp"
+#include "err.hpp"
+
+zmq::zmq_init_t::zmq_init_t (io_thread_t *io_thread_,
+      socket_base_t *socket_, session_t *session_, fd_t fd_,
+      const options_t &options_) :
+    own_t (io_thread_, options_),
+    ephemeral_engine (NULL),
+    sent (false),
+    received (false),
+    socket (socket_),
+    session (session_),
+    io_thread (io_thread_)
+{
+    //  Create the engine object for this connection.
+    engine = new (std::nothrow) zmq_engine_t (fd_, options);
+    alloc_assert (engine);
+}
+
+zmq::zmq_init_t::~zmq_init_t ()
+{
+    if (engine)
+        engine->terminate ();
+}
+
+bool zmq::zmq_init_t::read (::zmq_msg_t *msg_)
+{
+    //  If the identity was already sent, do nothing.
+    if (sent)
+        return false;
+
+    //  Send the identity.
+    int rc = zmq_msg_init_size (msg_, options.identity.size ());
+    zmq_assert (rc == 0);
+    memcpy (zmq_msg_data (msg_), options.identity.c_str (),
+        options.identity.size ());
+    sent = true;
+
+    //  Try finalize initialization.
+    finalise_initialisation ();
+
+    return true;
+}
+
+bool zmq::zmq_init_t::write (::zmq_msg_t *msg_)
+{
+    //  If identity was already received, we are not interested
+    //  in subsequent messages.
+    if (received)
+        return false;
+
+    //  Retreieve the remote identity. If it's empty, generate a unique name.
+    if (!zmq_msg_size (msg_)) {
+        unsigned char identity [uuid_t::uuid_blob_len + 1];
+        identity [0] = 0;
+        memcpy (identity + 1, uuid_t ().to_blob (), uuid_t::uuid_blob_len);
+        peer_identity.assign (identity, uuid_t::uuid_blob_len + 1);
+    }
+    else {
+        peer_identity.assign ((const unsigned char*) zmq_msg_data (msg_),
+            zmq_msg_size (msg_));
+    }
+    int rc = zmq_msg_close (msg_);
+    zmq_assert (rc == 0);
+
+    received = true;
+
+    //  Try finalize initialization.
+    finalise_initialisation ();
+
+    return true;
+}
+
+void zmq::zmq_init_t::flush ()
+{
+    //  Check if there's anything to flush.
+    if (!received)
+        return;
+
+    //  Initialization is done, dispatch engine.
+    if (ephemeral_engine)
+        dispatch_engine ();
+}
+
+void zmq::zmq_init_t::detach ()
+{
+    //  This function is called by engine when disconnection occurs.
+
+    //  If there is an associated session, send it a null engine to let it know
+    //  that connection process was unsuccesful.
+    if (session)
+        send_attach (session, NULL, blob_t (), true);
+
+    //  The engine will destroy itself, so let's just drop the pointer here and
+    //  start termination of the init object.
+    engine = NULL;
+    terminate ();
+}
+
+void zmq::zmq_init_t::process_plug ()
+{
+    zmq_assert (engine);
+    engine->plug (io_thread, this);
+}
+
+void zmq::zmq_init_t::process_unplug ()
+{
+    if (engine)
+        engine->unplug ();
+}
+
+void zmq::zmq_init_t::finalise_initialisation ()
+{
+     //  Unplug and prepare to dispatch engine.
+     if (sent && received) {
+        ephemeral_engine = engine;
+        engine = NULL;
+        ephemeral_engine->unplug ();
+        return;
+    }
+}
+
+void zmq::zmq_init_t::dispatch_engine ()
+{
+    if (sent && received) {
+
+        //  Engine must be detached.
+        zmq_assert (!engine);
+        zmq_assert (ephemeral_engine);
+
+        //  If we know what session we belong to, it's easy, just send the
+        //  engine to that session and destroy the init object. Note that we
+        //  know about the session only if this object is owned by it. Thus,
+        //  lifetime of this object in contained in the lifetime of the session
+        //  so the pointer cannot become invalid without notice.
+        if (session) {
+            send_attach (session, ephemeral_engine, peer_identity, true);
+            terminate ();
+            return;
+        }
+
+        //  All the cases below are listener-based. Therefore we need the socket
+        //  reference so that new sessions can bind to that socket.
+        zmq_assert (socket);
+
+        //  We have no associated session. If the peer has no identity we'll
+        //  create a transient session for the connection. Note that
+        //  seqnum is incremented to account for attach command before the
+        //  session is launched. That way we are sure it won't terminate before
+        //  being attached.
+        if (peer_identity [0] == 0) {
+            session = new (std::nothrow) transient_session_t (io_thread,
+                socket, options);
+            alloc_assert (session);
+            session->inc_seqnum ();
+            launch_sibling (session);
+            send_attach (session, ephemeral_engine, peer_identity, false);
+            terminate ();
+            return;
+        }
+        
+        //  Try to find the session corresponding to the peer's identity.
+        //  If found, send the engine to that session and destroy this object.
+        //  Note that session's seqnum is incremented by find_session rather
+        //  than by send_attach.
+        session = socket->find_session (peer_identity);
+        if (session) {
+            send_attach (session, ephemeral_engine, peer_identity, false);
+            terminate ();
+            return;
+        }
+
+        //  There's no such named session. We have to create one. Note that
+        //  seqnum is incremented to account for attach command before the
+        //  session is launched. That way we are sure it won't terminate before
+        //  being attached.
+        session = new (std::nothrow) named_session_t (io_thread, socket,
+            options, peer_identity);
+        alloc_assert (session);
+        session->inc_seqnum ();
+        launch_sibling (session);
+        send_attach (session, ephemeral_engine, peer_identity, false);
+        terminate ();
+        return;
+    }
+}

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

@@ -0,0 +1,93 @@
+/*
+    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_ZMQ_INIT_HPP_INCLUDED__
+#define __ZMQ_ZMQ_INIT_HPP_INCLUDED__
+
+#include "i_inout.hpp"
+#include "i_engine.hpp"
+#include "own.hpp"
+#include "fd.hpp"
+#include "stdint.hpp"
+#include "stdint.hpp"
+#include "blob.hpp"
+
+namespace zmq
+{
+
+    //  The class handles initialisation phase of 0MQ wire-level protocol.
+
+    class zmq_init_t : public own_t, public i_inout
+    {
+    public:
+
+        zmq_init_t (class io_thread_t *io_thread_, class socket_base_t *socket_,
+            class session_t *session_, fd_t fd_, const options_t &options_);
+        ~zmq_init_t ();
+
+    private:
+
+        void finalise_initialisation ();
+        void dispatch_engine ();
+
+        //  i_inout interface implementation.
+        bool read (::zmq_msg_t *msg_);
+        bool write (::zmq_msg_t *msg_);
+        void flush ();
+        void detach ();
+
+        //  Handlers for incoming commands.
+        void process_plug ();
+        void process_unplug ();
+
+        //  Associated wire-protocol engine.
+        i_engine *engine;
+
+        //  Detached transient engine.
+        i_engine *ephemeral_engine;
+
+        //  True if our own identity was already sent to the peer.
+        bool sent;
+
+        //  True if peer's identity was already received.
+        bool received;
+
+        //  Socket the object belongs to.
+        class socket_base_t *socket;
+
+        //  Reference to the session the init object belongs to.
+        //  If the associated session is unknown and should be found
+        //  depending on peer identity this value is NULL.
+        class session_t *session;
+
+        //  Identity of the peer socket.
+        blob_t peer_identity;
+
+        //  I/O thread the object is living in. It will be used to plug
+        //  the engine into the same I/O thread.
+        class io_thread_t *io_thread;
+
+        zmq_init_t (const zmq_init_t&);
+        const zmq_init_t &operator = (const zmq_init_t&);
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,78 @@
+/*
+    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 <new>
+
+#include "zmq_listener.hpp"
+#include "zmq_init.hpp"
+#include "io_thread.hpp"
+#include "err.hpp"
+
+zmq::zmq_listener_t::zmq_listener_t (io_thread_t *io_thread_,
+      socket_base_t *socket_, const options_t &options_) :
+    own_t (io_thread_, options_),
+    io_object_t (io_thread_),
+    socket (socket_)
+{
+}
+
+zmq::zmq_listener_t::~zmq_listener_t ()
+{
+}
+
+int zmq::zmq_listener_t::set_address (const char *protocol_, const char *addr_)
+{
+     return tcp_listener.set_address (protocol_, addr_, options.backlog);
+}
+
+void zmq::zmq_listener_t::process_plug ()
+{
+    //  Start polling for incoming connections.
+    handle = add_fd (tcp_listener.get_fd ());
+    set_pollin (handle);
+}
+
+void zmq::zmq_listener_t::process_term (int linger_)
+{
+    rm_fd (handle);
+    own_t::process_term (linger_);
+}
+
+void zmq::zmq_listener_t::in_event ()
+{
+    fd_t fd = tcp_listener.accept ();
+
+    //  If connection was reset by the peer in the meantime, just ignore it.
+    //  TODO: Handle specific errors like ENFILE/EMFILE etc.
+    if (fd == retired_fd)
+        return;
+
+    //  Choose I/O thread to run connecter in. Given that we are already
+    //  running in an I/O thread, there must be at least one available.
+    io_thread_t *io_thread = choose_io_thread (options.affinity);
+    zmq_assert (io_thread);
+
+    //  Create and launch an init object. 
+    zmq_init_t *init = new (std::nothrow) zmq_init_t (io_thread, socket,
+        NULL, fd, options);
+    alloc_assert (init);
+    launch_child (init);
+}
+