libzmq 0.0.1

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

@@ -0,0 +1,159 @@
+/*
+    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_CTX_HPP_INCLUDED__
+#define __ZMQ_CTX_HPP_INCLUDED__
+
+#include <map>
+#include <vector>
+#include <string>
+#include <stdarg.h>
+
+#include "../include/zmq.h"
+
+#include "mailbox.hpp"
+#include "semaphore.hpp"
+#include "ypipe.hpp"
+#include "array.hpp"
+#include "config.hpp"
+#include "mutex.hpp"
+#include "stdint.hpp"
+#include "thread.hpp"
+#include "options.hpp"
+
+namespace zmq
+{
+    //  Information associated with inproc endpoint. Note that endpoint options
+    //  are registered as well so that the peer can access them without a need
+    //  for synchronisation, handshaking or similar.
+    struct endpoint_t
+    {
+        class socket_base_t *socket;
+        options_t options;
+    };
+
+    //  Context object encapsulates all the global state associated with
+    //  the library.
+    
+    class ctx_t
+    {
+    public:
+
+        //  Create the context object. The argument specifies the size
+        //  of I/O thread pool to create.
+        ctx_t (uint32_t io_threads_);
+
+        //  Returns false if object is not a context.
+        bool check_tag ();
+
+        //  This function is called when user invokes zmq_term. If there are
+        //  no more sockets open it'll cause all the infrastructure to be shut
+        //  down. If there are open sockets still, the deallocation happens
+        //  after the last one is closed.
+        int terminate ();
+
+        //  Create and destroy a socket.
+        class socket_base_t *create_socket (int type_);
+        void destroy_socket (class socket_base_t *socket_);
+
+        //  Send command to the destination thread.
+        void send_command (uint32_t tid_, const command_t &command_);
+
+        //  Returns the I/O thread that is the least busy at the moment.
+        //  Affinity specifies which I/O threads are eligible (0 = all).
+        //  Returns NULL is no I/O thread is available.
+        class io_thread_t *choose_io_thread (uint64_t affinity_);
+
+        //  Returns reaper thread object.
+        class object_t *get_reaper ();
+
+        //  Management of inproc endpoints.
+        int register_endpoint (const char *addr_, endpoint_t &endpoint_);
+        void unregister_endpoints (class socket_base_t *socket_);
+        endpoint_t find_endpoint (const char *addr_);
+
+        //  Logging.
+        void log (const char *format_, va_list args_);
+
+        enum {
+            term_tid = 0,
+            reaper_tid = 1
+        };
+
+    private:
+
+        ~ctx_t ();
+
+        //  Used to check whether the object is a context.
+        uint32_t tag;
+
+        //  Sockets belonging to this context. We need the list so that
+        //  we can notify the sockets when zmq_term() is called. The sockets
+        //  will return ETERM then.
+        typedef array_t <socket_base_t> sockets_t;
+        sockets_t sockets;
+
+        //  List of unused thread slots.
+        typedef std::vector <uint32_t> emtpy_slots_t;
+        emtpy_slots_t empty_slots;
+
+        //  If true, zmq_term was already called.
+        bool terminating;
+
+        //  Synchronisation of accesses to global slot-related data:
+        //  sockets, empty_slots, terminating. It also synchronises
+        //  access to zombie sockets as such (as oposed to slots) and provides
+        //  a memory barrier to ensure that all CPU cores see the same data.
+        mutex_t slot_sync;
+
+        //  The reaper thread.
+        class reaper_t *reaper;
+
+        //  I/O threads.
+        typedef std::vector <class io_thread_t*> io_threads_t;
+        io_threads_t io_threads;
+
+        //  Array of pointers to mailboxes for both application and I/O threads.
+        uint32_t slot_count;
+        mailbox_t **slots;
+
+        //  Mailbox for zmq_term thread.
+        mailbox_t term_mailbox;
+
+        //  List of inproc endpoints within this context.
+        typedef std::map <std::string, endpoint_t> endpoints_t;
+        endpoints_t endpoints;
+
+        //  Synchronisation of access to the list of inproc endpoints.
+        mutex_t endpoints_sync;
+
+        //  PUB socket for logging. The socket is shared among all the threads,
+        //  thus it is synchronised by a mutex.
+        class socket_base_t *log_socket;
+        mutex_t log_sync;
+
+        ctx_t (const ctx_t&);
+        const ctx_t &operator = (const ctx_t&);
+    };
+    
+}
+
+#endif
+

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

@@ -0,0 +1,129 @@
+/*
+    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 <stdlib.h>
+#include <string.h>
+
+#include "decoder.hpp"
+#include "i_inout.hpp"
+#include "wire.hpp"
+#include "err.hpp"
+
+zmq::decoder_t::decoder_t (size_t bufsize_) :
+    decoder_base_t <decoder_t> (bufsize_),
+    destination (NULL)
+{
+    zmq_msg_init (&in_progress);
+
+    //  At the beginning, read one byte and go to one_byte_size_ready state.
+    next_step (tmpbuf, 1, &decoder_t::one_byte_size_ready);
+}
+
+zmq::decoder_t::~decoder_t ()
+{
+    zmq_msg_close (&in_progress);
+}
+
+void zmq::decoder_t::set_inout (i_inout *destination_)
+{
+    destination = destination_;
+}
+
+bool zmq::decoder_t::one_byte_size_ready ()
+{
+    //  First byte of size is read. If it is 0xff read 8-byte size.
+    //  Otherwise allocate the buffer for message data and read the
+    //  message data into it.
+    if (*tmpbuf == 0xff)
+        next_step (tmpbuf, 8, &decoder_t::eight_byte_size_ready);
+    else {
+
+        //  There has to be at least one byte (the flags) in the message).
+        if (!*tmpbuf) {
+            decoding_error ();
+            return false;
+        }
+
+        //  in_progress is initialised at this point so in theory we should
+        //  close it before calling zmq_msg_init_size, however, it's a 0-byte
+        //  message and thus we can treat it as uninitialised...
+        int rc = zmq_msg_init_size (&in_progress, *tmpbuf - 1);
+        if (rc != 0 && errno == ENOMEM) {
+            rc = zmq_msg_init (&in_progress);
+            errno_assert (rc == 0);
+            decoding_error ();
+            return false;
+        }
+        errno_assert (rc == 0);
+
+        next_step (tmpbuf, 1, &decoder_t::flags_ready);
+    }
+    return true;
+}
+
+bool zmq::decoder_t::eight_byte_size_ready ()
+{
+    //  8-byte size is read. Allocate the buffer for message body and
+    //  read the message data into it.
+    size_t size = (size_t) get_uint64 (tmpbuf);
+
+    //  There has to be at least one byte (the flags) in the message).
+    if (!size) {
+        decoding_error ();
+        return false;
+    }
+
+    //  in_progress is initialised at this point so in theory we should
+    //  close it before calling zmq_msg_init_size, however, it's a 0-byte
+    //  message and thus we can treat it as uninitialised...
+    int rc = zmq_msg_init_size (&in_progress, size - 1);
+    if (rc != 0 && errno == ENOMEM) {
+        rc = zmq_msg_init (&in_progress);
+        errno_assert (rc == 0);
+        decoding_error ();
+        return false;
+    }
+    errno_assert (rc == 0);
+
+    next_step (tmpbuf, 1, &decoder_t::flags_ready);
+    return true;
+}
+
+bool zmq::decoder_t::flags_ready ()
+{
+    //  Store the flags from the wire into the message structure.
+    in_progress.flags = tmpbuf [0] | ~ZMQ_MSG_MASK;
+
+    next_step (zmq_msg_data (&in_progress), zmq_msg_size (&in_progress),
+        &decoder_t::message_ready);
+
+    return true;
+}
+
+bool zmq::decoder_t::message_ready ()
+{
+    //  Message is completely read. Push it further and start reading
+    //  new message. (in_progress is a 0-byte message after this point.)
+    if (!destination || !destination->write (&in_progress))
+        return false;
+
+    next_step (tmpbuf, 1, &decoder_t::one_byte_size_ready);
+    return true;
+}

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

@@ -0,0 +1,207 @@
+/*
+    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_DECODER_HPP_INCLUDED__
+#define __ZMQ_DECODER_HPP_INCLUDED__
+
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+#include <algorithm>
+
+#include "err.hpp"
+
+#include "../include/zmq.h"
+
+namespace zmq
+{
+
+    //  Helper base class for decoders that know the amount of data to read
+    //  in advance at any moment. Knowing the amount in advance is a property
+    //  of the protocol used. 0MQ framing protocol is based size-prefixed
+    //  paradigm, whixh qualifies it to be parsed by this class.
+    //  On the other hand, XML-based transports (like XMPP or SOAP) don't allow
+    //  for knowing the size of data to read in advance and should use different
+    //  decoding algorithms.
+    //
+    //  This class implements the state machine that parses the incoming buffer.
+    //  Derived class should implement individual state machine actions.
+
+    template <typename T> class decoder_base_t
+    {
+    public:
+
+        inline decoder_base_t (size_t bufsize_) :
+            read_pos (NULL),
+            to_read (0),
+            next (NULL),
+            bufsize (bufsize_)
+        {
+            buf = (unsigned char*) malloc (bufsize_);
+            alloc_assert (buf);
+        }
+
+        //  The destructor doesn't have to be virtual. It is mad virtual
+        //  just to keep ICC and code checking tools from complaining.
+        inline virtual ~decoder_base_t ()
+        {
+            free (buf);
+        }
+
+        //  Returns a buffer to be filled with binary data.
+        inline void get_buffer (unsigned char **data_, size_t *size_)
+        {
+            //  If we are expected to read large message, we'll opt for zero-
+            //  copy, i.e. we'll ask caller to fill the data directly to the
+            //  message. Note that subsequent read(s) are non-blocking, thus
+            //  each single read reads at most SO_RCVBUF bytes at once not
+            //  depending on how large is the chunk returned from here.
+            //  As a consequence, large messages being received won't block
+            //  other engines running in the same I/O thread for excessive
+            //  amounts of time.
+            if (to_read >= bufsize) {
+                *data_ = read_pos;
+                *size_ = to_read;
+                return;
+            }
+
+            *data_ = buf;
+            *size_ = bufsize;
+        }
+
+        //  Processes the data in the buffer previously allocated using
+        //  get_buffer function. size_ argument specifies nemuber of bytes
+        //  actually filled into the buffer. Function returns number of
+        //  bytes actually processed.
+        inline size_t process_buffer (unsigned char *data_, size_t size_)
+        {
+            //  Check if we had an error in previous attempt.
+            if (unlikely (!(static_cast <T*> (this)->next)))
+                return (size_t) -1;
+
+            //  In case of zero-copy simply adjust the pointers, no copying
+            //  is required. Also, run the state machine in case all the data
+            //  were processed.
+            if (data_ == read_pos) {
+                read_pos += size_;
+                to_read -= size_;
+
+                while (!to_read) {
+                    if (!(static_cast <T*> (this)->*next) ()) {
+                        if (unlikely (!(static_cast <T*> (this)->next)))
+                            return (size_t) -1;
+                        return size_;
+                    }
+                }
+                return size_;
+            }
+
+            size_t pos = 0;
+            while (true) {
+
+                //  Try to get more space in the message to fill in.
+                //  If none is available, return.
+                while (!to_read) {
+                    if (!(static_cast <T*> (this)->*next) ()) {
+                        if (unlikely (!(static_cast <T*> (this)->next)))
+                            return (size_t) -1;
+                        return pos;
+                    }
+                }
+
+                //  If there are no more data in the buffer, return.
+                if (pos == size_)
+                    return pos;
+
+                //  Copy the data from buffer to the message.
+                size_t to_copy = std::min (to_read, size_ - pos);
+                memcpy (read_pos, data_ + pos, to_copy);
+                read_pos += to_copy;
+                pos += to_copy;
+                to_read -= to_copy;
+            }
+        }
+
+    protected:
+
+        //  Prototype of state machine action. Action should return false if
+        //  it is unable to push the data to the system.
+        typedef bool (T::*step_t) ();
+
+        //  This function should be called from derived class to read data
+        //  from the buffer and schedule next state machine action.
+        inline void next_step (void *read_pos_, size_t to_read_,
+            step_t next_)
+        {
+            read_pos = (unsigned char*) read_pos_;
+            to_read = to_read_;
+            next = next_;
+        }
+
+        //  This function should be called from the derived class to
+        //  abort decoder state machine.
+        inline void decoding_error ()
+        {
+            next = NULL;
+        }
+
+    private:
+
+        unsigned char *read_pos;
+        size_t to_read;
+        step_t next;
+
+        size_t bufsize;
+        unsigned char *buf;
+
+        decoder_base_t (const decoder_base_t&);
+        const decoder_base_t &operator = (const decoder_base_t&);
+    };
+
+    //  Decoder for 0MQ framing protocol. Converts data batches into messages.
+
+    class decoder_t : public decoder_base_t <decoder_t>
+    {
+    public:
+
+        decoder_t (size_t bufsize_);
+        ~decoder_t ();
+
+        void set_inout (struct i_inout *destination_);
+
+    private:
+
+        bool one_byte_size_ready ();
+        bool eight_byte_size_ready ();
+        bool flags_ready ();
+        bool message_ready ();
+
+        struct i_inout *destination;
+        unsigned char tmpbuf [8];
+        ::zmq_msg_t in_progress;
+
+        decoder_t (const decoder_t&);
+        void operator = (const decoder_t&);
+    };
+
+}
+
+#endif
+