rbczmq 1.7.1 → 1.7.2

data/ext/zeromq/src/v2_decoder.cpp

@@ -0,0 +1,142 @@
+/*
+    Copyright (c) 2007-2013 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 "platform.hpp"
+#ifdef ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#endif
+
+#include "v2_protocol.hpp"
+#include "v2_decoder.hpp"
+#include "likely.hpp"
+#include "wire.hpp"
+#include "err.hpp"
+
+zmq::v2_decoder_t::v2_decoder_t (size_t bufsize_, int64_t maxmsgsize_) :
+    decoder_base_t <v2_decoder_t> (bufsize_),
+    msg_flags (0),
+    maxmsgsize (maxmsgsize_)
+{
+    int rc = in_progress.init ();
+    errno_assert (rc == 0);
+
+    //  At the beginning, read one byte and go to flags_ready state.
+    next_step (tmpbuf, 1, &v2_decoder_t::flags_ready);
+}
+
+zmq::v2_decoder_t::~v2_decoder_t ()
+{
+    int rc = in_progress.close ();
+    errno_assert (rc == 0);
+}
+
+int zmq::v2_decoder_t::flags_ready ()
+{
+    msg_flags = 0;
+    if (tmpbuf [0] & v2_protocol_t::more_flag)
+        msg_flags |= msg_t::more;
+    if (tmpbuf [0] & v2_protocol_t::command_flag)
+        msg_flags |= msg_t::command;
+
+    //  The payload length is either one or eight bytes,
+    //  depending on whether the 'large' bit is set.
+    if (tmpbuf [0] & v2_protocol_t::large_flag)
+        next_step (tmpbuf, 8, &v2_decoder_t::eight_byte_size_ready);
+    else
+        next_step (tmpbuf, 1, &v2_decoder_t::one_byte_size_ready);
+
+    return 0;
+}
+
+int zmq::v2_decoder_t::one_byte_size_ready ()
+{
+    //  Message size must not exceed the maximum allowed size.
+    if (maxmsgsize >= 0)
+        if (unlikely (tmpbuf [0] > static_cast <uint64_t> (maxmsgsize))) {
+            errno = EMSGSIZE;
+            return -1;
+        }
+
+    //  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 = in_progress.init_size (tmpbuf [0]);
+    if (unlikely (rc)) {
+        errno_assert (errno == ENOMEM);
+        rc = in_progress.init ();
+        errno_assert (rc == 0);
+        errno = ENOMEM;
+        return -1;
+    }
+
+    in_progress.set_flags (msg_flags);
+    next_step (in_progress.data (), in_progress.size (),
+        &v2_decoder_t::message_ready);
+
+    return 0;
+}
+
+int zmq::v2_decoder_t::eight_byte_size_ready ()
+{
+    //  The payload size is encoded as 64-bit unsigned integer.
+    //  The most significant byte comes first.
+    const uint64_t msg_size = get_uint64 (tmpbuf);
+
+    //  Message size must not exceed the maximum allowed size.
+    if (maxmsgsize >= 0)
+        if (unlikely (msg_size > static_cast <uint64_t> (maxmsgsize))) {
+            errno = EMSGSIZE;
+            return -1;
+        }
+
+    //  Message size must fit into size_t data type.
+    if (unlikely (msg_size != static_cast <size_t> (msg_size))) {
+        errno = EMSGSIZE;
+        return -1;
+    }
+
+    //  in_progress is initialised at this point so in theory we should
+    //  close it before calling init_size, however, it's a 0-byte
+    //  message and thus we can treat it as uninitialised.
+    int rc = in_progress.init_size (static_cast <size_t> (msg_size));
+    if (unlikely (rc)) {
+        errno_assert (errno == ENOMEM);
+        rc = in_progress.init ();
+        errno_assert (rc == 0);
+        errno = ENOMEM;
+        return -1;
+    }
+
+    in_progress.set_flags (msg_flags);
+    next_step (in_progress.data (), in_progress.size (),
+        &v2_decoder_t::message_ready);
+
+    return 0;
+}
+
+int zmq::v2_decoder_t::message_ready ()
+{
+    //  Message is completely read. Signal this to the caller
+    //  and prepare to decode next message.
+    next_step (tmpbuf, 1, &v2_decoder_t::flags_ready);
+    return 1;
+}

data/ext/zeromq/src/v2_decoder.hpp

@@ -0,0 +1,57 @@
+/*
+    Copyright (c) 2007-2013 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_V2_DECODER_HPP_INCLUDED__
+#define __ZMQ_V2_DECODER_HPP_INCLUDED__
+
+#include "decoder.hpp"
+
+namespace zmq
+{
+    //  Decoder for ZMTP/2.x framing protocol. Converts data stream into messages.
+    class v2_decoder_t : public decoder_base_t <v2_decoder_t>
+    {
+    public:
+
+        v2_decoder_t (size_t bufsize_, int64_t maxmsgsize_);
+        virtual ~v2_decoder_t ();
+
+        //  i_decoder interface.
+        virtual msg_t *msg () { return &in_progress; }
+
+    private:
+
+        int flags_ready ();
+        int one_byte_size_ready ();
+        int eight_byte_size_ready ();
+        int message_ready ();
+
+        unsigned char tmpbuf [8];
+        unsigned char msg_flags;
+        msg_t in_progress;
+
+        const int64_t maxmsgsize;
+
+        v2_decoder_t (const v2_decoder_t&);
+        void operator = (const v2_decoder_t&);
+    };
+
+}
+
+#endif

data/ext/zeromq/src/v2_encoder.cpp

@@ -0,0 +1,67 @@
+/*
+    Copyright (c) 2007-2013 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 "v2_protocol.hpp"
+#include "v2_encoder.hpp"
+#include "likely.hpp"
+#include "wire.hpp"
+
+zmq::v2_encoder_t::v2_encoder_t (size_t bufsize_) :
+    encoder_base_t <v2_encoder_t> (bufsize_)
+{
+    //  Write 0 bytes to the batch and go to message_ready state.
+    next_step (NULL, 0, &v2_encoder_t::message_ready, true);
+}
+
+zmq::v2_encoder_t::~v2_encoder_t ()
+{
+}
+
+void zmq::v2_encoder_t::message_ready ()
+{
+    //  Encode flags.
+    unsigned char &protocol_flags = tmpbuf [0];
+    protocol_flags = 0;
+    if (in_progress->flags () & msg_t::more)
+        protocol_flags |= v2_protocol_t::more_flag;
+    if (in_progress->size () > 255)
+        protocol_flags |= v2_protocol_t::large_flag;
+    if (in_progress->flags () & msg_t::command)
+        protocol_flags |= v2_protocol_t::command_flag;
+
+    //  Encode the message length. For messages less then 256 bytes,
+    //  the length is encoded as 8-bit unsigned integer. For larger
+    //  messages, 64-bit unsigned integer in network byte order is used.
+    const size_t size = in_progress->size ();
+    if (unlikely (size > 255)) {
+        put_uint64 (tmpbuf + 1, size);
+        next_step (tmpbuf, 9, &v2_encoder_t::size_ready, false);
+    }
+    else {
+        tmpbuf [1] = static_cast <uint8_t> (size);
+        next_step (tmpbuf, 2, &v2_encoder_t::size_ready, false);
+    }
+}
+
+void zmq::v2_encoder_t::size_ready ()
+{
+    //  Write message body into the buffer.
+    next_step (in_progress->data (), in_progress->size (),
+        &v2_encoder_t::message_ready, true);
+}

data/ext/zeromq/src/{i_msg_source.hpp → v2_encoder.hpp}

@@ -1,6 +1,5 @@
 /*
-    Copyright (c) 2007-2012 iMatix Corporation
-    Copyright (c) 2007-2012 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -18,27 +17,33 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __ZMQ_I_MSG_SOURCE_HPP_INCLUDED__
-#define __ZMQ_I_MSG_SOURCE_HPP_INCLUDED__
+#ifndef __ZMQ_V2_ENCODER_HPP_INCLUDED__
+#define __ZMQ_V2_ENCODER_HPP_INCLUDED__
+
+#include "encoder.hpp"
 
 namespace zmq
 {
+    //  Encoder for 0MQ framing protocol. Converts messages into data stream.
 
-    //  Forward declaration
-    class msg_t;
+    class v2_encoder_t : public encoder_base_t <v2_encoder_t>
+    {
+    public:
 
-    //  Interface to be implemented by message source.
+        v2_encoder_t (size_t bufsize_);
+        virtual ~v2_encoder_t ();
 
-    struct i_msg_source
-    {
-        virtual ~i_msg_source () {}
+    private:
 
-        //  Fetch a message. Returns 0 if successful; -1 otherwise.
-        //  The caller is responsible for freeing the message when no
-        //  longer used.
-        virtual int pull_msg (msg_t *msg_) = 0;
-    };
+        void size_ready ();
+        void message_ready ();
 
+        unsigned char tmpbuf [9];
+
+        v2_encoder_t (const v2_encoder_t&);
+        const v2_encoder_t &operator = (const v2_encoder_t&);
+    };
 }
 
 #endif
+

data/ext/zeromq/src/{v1_protocol.hpp → v2_protocol.hpp}

@@ -1,6 +1,5 @@
 /*
-    Copyright (c) 2007-2012 iMatix Corporation
-    Copyright (c) 2007-2012 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -18,26 +17,23 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __ZMQ_V1_PROTOCOL_HPP_INCLUDED__
-#define __ZMQ_V1_PROTOCOL_HPP_INCLUDED__
+#ifndef __ZMQ_V2_PROTOCOL_HPP_INCLUDED__
+#define __ZMQ_V2_PROTOCOL_HPP_INCLUDED__
 
 namespace zmq
 {
-
-    //  Definition of constans for v1 transport protocol.
-    class v1_protocol_t
+    //  Definition of constants for ZMTP/2.0 transport protocol.
+    class v2_protocol_t
     {
     public:
         //  Message flags.
         enum
         {
             more_flag = 1,
-            large_flag = 2
+            large_flag = 2,
+            command_flag = 4
         };
-
     };
-
 }
 
 #endif
-

data/ext/zeromq/src/windows.hpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2010-2011 250bpm s.r.o.
-    Copyright (c) 2007-2009 iMatix Corporation
-    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -170,7 +168,7 @@
 
 #include <ws2tcpip.h>
 #include <ipexport.h>
-#if !defined WINCE
+#if !defined _WIN32_WCE
 #include <process.h>
 #endif
 

data/ext/zeromq/src/wire.hpp

@@ -1,6 +1,5 @@
 /*
-    Copyright (c) 2007-2009 iMatix Corporation
-    Copyright (c) 2007-2011 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -34,7 +33,7 @@ namespace zmq
         *buffer_ = value;
     }
 
-    inline uint8_t get_uint8 (unsigned char *buffer_)
+    inline uint8_t get_uint8 (const unsigned char *buffer_)
     {
         return *buffer_;
     }
@@ -45,7 +44,7 @@ namespace zmq
         buffer_ [1] = (unsigned char) (value & 0xff);
     }
 
-    inline uint16_t get_uint16 (unsigned char *buffer_)
+    inline uint16_t get_uint16 (const unsigned char *buffer_)
     {
         return
             (((uint16_t) buffer_ [0]) << 8) |
@@ -60,7 +59,7 @@ namespace zmq
         buffer_ [3] = (unsigned char) (value & 0xff);
     }
 
-    inline uint32_t get_uint32 (unsigned char *buffer_)
+    inline uint32_t get_uint32 (const unsigned char *buffer_)
     {
         return
             (((uint32_t) buffer_ [0]) << 24) |
@@ -81,7 +80,7 @@ namespace zmq
         buffer_ [7] = (unsigned char) (value & 0xff);
     }
 
-    inline uint64_t get_uint64 (unsigned char *buffer_)
+    inline uint64_t get_uint64 (const unsigned char *buffer_)
     {
         return
             (((uint64_t) buffer_ [0]) << 56) |

data/ext/zeromq/src/xpub.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2010-2011 250bpm s.r.o.
-    Copyright (c) 2011 VMware, Inc.
-    Copyright (c) 2010-2011 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -38,14 +36,14 @@ zmq::xpub_t::~xpub_t ()
 {
 }
 
-void zmq::xpub_t::xattach_pipe (pipe_t *pipe_, bool icanhasall_)
+void zmq::xpub_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
 {
     zmq_assert (pipe_);
     dist.attach (pipe_);
 
-    //  If icanhasall_ is specified, the caller would like to subscribe
+    //  If subscribe_to_all_ is specified, the caller would like to subscribe
     //  to all data on this pipe, implicitly.
-    if (icanhasall_)
+    if (subscribe_to_all_)
         subscriptions.add (NULL, 0, pipe_);
 
     //  The pipe is active when attached. Let's read the subscriptions from
@@ -58,9 +56,8 @@ void zmq::xpub_t::xread_activated (pipe_t *pipe_)
     //  There are some subscriptions waiting. Let's process them.
     msg_t sub;
     while (pipe_->read (&sub)) {
-
-        //  Apply the subscription to the trie.
-        unsigned char *const data = (unsigned char*) sub.data ();
+        //  Apply the subscription to the trie
+        unsigned char *const data = (unsigned char *) sub.data ();
         const size_t size = sub.size ();
         if (size > 0 && (*data == 0 || *data == 1)) {
             bool unique;
@@ -71,10 +68,16 @@ void zmq::xpub_t::xread_activated (pipe_t *pipe_)
 
             //  If the subscription is not a duplicate store it so that it can be
             //  passed to used on next recv call. (Unsubscribe is not verbose.)
-            if (options.type == ZMQ_XPUB && (unique || (*data && verbose)))
-                pending.push_back (blob_t (data, size));
+            if (options.type == ZMQ_XPUB && (unique || (*data && verbose))) {
+                pending_data.push_back (blob_t (data, size));
+                pending_flags.push_back (0);
+            }
+        }
+        else {
+            //  Process user message coming upstream from xsub socket
+            pending_data.push_back (blob_t (data, size));
+            pending_flags.push_back (sub.flags ());
         }
-
         sub.close ();
     }
 }
@@ -95,18 +98,18 @@ int zmq::xpub_t::xsetsockopt (int option_, const void *optval_,
         errno = EINVAL;
         return -1;
     }
-    verbose = *static_cast <const int*> (optval_);
+    verbose = (*static_cast <const int*> (optval_) != 0);
     return 0;
 }
 
-void zmq::xpub_t::xterminated (pipe_t *pipe_)
+void zmq::xpub_t::xpipe_terminated (pipe_t *pipe_)
 {
     //  Remove the pipe from the trie. If there are topics that nobody
     //  is interested in anymore, send corresponding unsubscriptions
     //  upstream.
     subscriptions.rm (pipe_, send_unsubscription, this);
 
-    dist.terminated (pipe_);
+    dist.pipe_terminated (pipe_);
 }
 
 void zmq::xpub_t::mark_as_matching (pipe_t *pipe_, void *arg_)
@@ -115,7 +118,7 @@ void zmq::xpub_t::mark_as_matching (pipe_t *pipe_, void *arg_)
     self->dist.match (pipe_);
 }
 
-int zmq::xpub_t::xsend (msg_t *msg_, int flags_)
+int zmq::xpub_t::xsend (msg_t *msg_)
 {
     bool msg_more = msg_->flags () & msg_t::more ? true : false;
 
@@ -126,7 +129,7 @@ int zmq::xpub_t::xsend (msg_t *msg_, int flags_)
 
     //  Send the message to all the pipes that were marked as matching
     //  in the previous step.
-    int rc = dist.send_to_matching (msg_, flags_);
+    int rc = dist.send_to_matching (msg_);
     if (rc != 0)
         return rc;
 
@@ -145,30 +148,30 @@ bool zmq::xpub_t::xhas_out ()
     return dist.has_out ();
 }
 
-int zmq::xpub_t::xrecv (msg_t *msg_, int flags_)
+int zmq::xpub_t::xrecv (msg_t *msg_)
 {
-    // flags_ is unused
-    (void)flags_;
-
     //  If there is at least one 
-    if (pending.empty ()) {
+    if (pending_data.empty ()) {
         errno = EAGAIN;
         return -1;
     }
 
     int rc = msg_->close ();
     errno_assert (rc == 0);
-    rc = msg_->init_size (pending.front ().size ());
+    rc = msg_->init_size (pending_data.front ().size ());
     errno_assert (rc == 0);
-    memcpy (msg_->data (), pending.front ().data (),
-        pending.front ().size ());
-    pending.pop_front ();
+    memcpy (msg_->data (),
+        pending_data.front ().data (),
+        pending_data.front ().size ());
+    msg_->set_flags (pending_flags.front ());
+    pending_data.pop_front ();
+    pending_flags.pop_front ();
     return 0;
 }
 
 bool zmq::xpub_t::xhas_in ()
 {
-    return !pending.empty ();
+    return !pending_data.empty ();
 }
 
 void zmq::xpub_t::send_unsubscription (unsigned char *data_, size_t size_,
@@ -177,24 +180,12 @@ void zmq::xpub_t::send_unsubscription (unsigned char *data_, size_t size_,
     xpub_t *self = (xpub_t*) arg_;
 
     if (self->options.type != ZMQ_PUB) {
-
-		//  Place the unsubscription to the queue of pending (un)sunscriptions
-		//  to be retrived by the user later on.
-		blob_t unsub (size_ + 1, 0);
-		unsub [0] = 0;
-		memcpy (&unsub [1], data_, size_);
-		self->pending.push_back (unsub);
+        //  Place the unsubscription to the queue of pending (un)sunscriptions
+        //  to be retrived by the user later on.
+        blob_t unsub (size_ + 1, 0);
+        unsub [0] = 0;
+        memcpy (&unsub [1], data_, size_);
+        self->pending_data.push_back (unsub);
+        self->pending_flags.push_back (0);
     }
 }
-
-zmq::xpub_session_t::xpub_session_t (io_thread_t *io_thread_, bool connect_,
-      socket_base_t *socket_, const options_t &options_,
-      const address_t *addr_) :
-    session_base_t (io_thread_, connect_, socket_, options_, addr_)
-{
-}
-
-zmq::xpub_session_t::~xpub_session_t ()
-{
-}
-