rbczmq 1.7.1 → 1.7.2

data/ext/zeromq/src/trie.hpp

@@ -1,8 +1,5 @@
 /*
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    Copyright (c) 2007-2009 iMatix Corporation
-    Copyright (c) 2011-2012 Spotify AB
-    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.
 

data/ext/zeromq/src/v1_decoder.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2009-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.
 
@@ -21,30 +19,28 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <limits>
 
 #include "platform.hpp"
-#ifdef ZMQ_HAVE_WINDOWS
+#if defined ZMQ_HAVE_WINDOWS
 #include "windows.hpp"
 #endif
 
-#include "v1_protocol.hpp"
+#include "decoder.hpp"
 #include "v1_decoder.hpp"
 #include "likely.hpp"
 #include "wire.hpp"
 #include "err.hpp"
 
-zmq::v1_decoder_t::v1_decoder_t (size_t bufsize_,
-      int64_t maxmsgsize_, i_msg_sink *msg_sink_) :
+zmq::v1_decoder_t::v1_decoder_t (size_t bufsize_, int64_t maxmsgsize_) :
     decoder_base_t <v1_decoder_t> (bufsize_),
-    msg_sink (msg_sink_),
-    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, &v1_decoder_t::flags_ready);
+    //  At the beginning, read one byte and go to one_byte_size_ready state.
+    next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
 }
 
 zmq::v1_decoder_t::~v1_decoder_t ()
@@ -53,110 +49,100 @@ zmq::v1_decoder_t::~v1_decoder_t ()
     errno_assert (rc == 0);
 }
 
-void zmq::v1_decoder_t::set_msg_sink (i_msg_sink *msg_sink_)
-{
-    msg_sink = msg_sink_;
-}
-
-bool zmq::v1_decoder_t::flags_ready ()
+int zmq::v1_decoder_t::one_byte_size_ready ()
 {
-    msg_flags = 0;
-    if (tmpbuf [0] & v1_protocol_t::more_flag)
-        msg_flags |= msg_t::more;
-
-    //  The payload length is either one or eight bytes,
-    //  depending on whether the 'large' bit is set.
-    if (tmpbuf [0] & v1_protocol_t::large_flag)
+    //  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, &v1_decoder_t::eight_byte_size_ready);
-    else
-        next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
-
-    return true;
+    else {
+
+        //  There has to be at least one byte (the flags) in the message).
+        if (!*tmpbuf) {
+            errno = EPROTO;
+            return -1;
+        }
+
+        if (maxmsgsize >= 0 && (int64_t) (*tmpbuf - 1) > 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 - 1);
+        if (rc != 0) {
+            errno_assert (errno == ENOMEM);
+            rc = in_progress.init ();
+            errno_assert (rc == 0);
+            errno = ENOMEM;
+            return -1;
+        }
+
+        next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
+    }
+    return 0;
 }
 
-bool zmq::v1_decoder_t::one_byte_size_ready ()
+int zmq::v1_decoder_t::eight_byte_size_ready ()
 {
-    int rc = 0;
+    //  8-byte payload length is read. Allocate the buffer
+    //  for message body and read the message data into it.
+    const uint64_t payload_length = get_uint64 (tmpbuf);
+
+    //  There has to be at least one byte (the flags) in the message).
+    if (payload_length == 0) {
+        errno = EPROTO;
+        return -1;
+    }
 
     //  Message size must not exceed the maximum allowed size.
-    if (maxmsgsize >= 0)
-        if (unlikely (tmpbuf [0] > static_cast <uint64_t> (maxmsgsize)))
-            goto error;
+    if (maxmsgsize >= 0 && payload_length - 1 > (uint64_t) maxmsgsize) {
+        errno = EMSGSIZE;
+        return -1;
+    }
+
+    //  Message size must fit within range of size_t data type.
+    if (payload_length - 1 > std::numeric_limits <size_t>::max ()) {
+        errno = EMSGSIZE;
+        return -1;
+    }
+
+    const size_t msg_size = static_cast <size_t> (payload_length - 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
+    //  close it before calling init_size, however, it's a 0-byte
     //  message and thus we can treat it as uninitialised...
-    rc = in_progress.init_size (tmpbuf [0]);
-    if (unlikely (rc)) {
+    int rc = in_progress.init_size (msg_size);
+    if (rc != 0) {
         errno_assert (errno == ENOMEM);
-        int rc = in_progress.init ();
+        rc = in_progress.init ();
         errno_assert (rc == 0);
-        goto error;
+        errno = ENOMEM;
+        return -1;
     }
 
-    in_progress.set_flags (msg_flags);
-    next_step (in_progress.data (), in_progress.size (),
-        &v1_decoder_t::message_ready);
-
-    return true;
-
-error:
-    decoding_error ();
-    return false;
+    next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
+    return 0;
 }
 
-bool zmq::v1_decoder_t::eight_byte_size_ready ()
+int zmq::v1_decoder_t::flags_ready ()
 {
-    int rc = 0;
-
-    //  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)))
-            goto error;
-
-    //  Message size must fit into size_t data type.
-    if (unlikely (msg_size != static_cast <size_t> (msg_size)))
-        goto error;
-
-    //  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.
-    rc = in_progress.init_size (static_cast <size_t> (msg_size));
-    if (unlikely (rc)) {
-        errno_assert (errno == ENOMEM);
-        int rc = in_progress.init ();
-        errno_assert (rc == 0);
-        goto error;
-    }
+    //  Store the flags from the wire into the message structure.
+    in_progress.set_flags (tmpbuf [0] & msg_t::more);
 
-    in_progress.set_flags (msg_flags);
     next_step (in_progress.data (), in_progress.size (),
         &v1_decoder_t::message_ready);
 
-    return true;
-
-error:
-    decoding_error ();
-    return false;
+    return 0;
 }
 
-bool zmq::v1_decoder_t::message_ready ()
+int zmq::v1_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 (unlikely (!msg_sink))
-        return false;
-    int rc = msg_sink->push_msg (&in_progress);
-    if (unlikely (rc != 0)) {
-        if (errno != EAGAIN)
-            decoding_error ();
-        return false;
-    }
-
-    next_step (tmpbuf, 1, &v1_decoder_t::flags_ready);
-    return true;
+    next_step (tmpbuf, 1, &v1_decoder_t::one_byte_size_ready);
+    return 1;
 }

data/ext/zeromq/src/v1_decoder.hpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    Copyright (c) 2007-2012 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.
 
@@ -22,41 +20,32 @@
 #ifndef __ZMQ_V1_DECODER_HPP_INCLUDED__
 #define __ZMQ_V1_DECODER_HPP_INCLUDED__
 
-#include "err.hpp"
-#include "msg.hpp"
 #include "decoder.hpp"
-#include "i_msg_sink.hpp"
-#include "stdint.hpp"
 
 namespace zmq
 {
-
-    //  Decoder for 0MQ v1 framing protocol. Converts data stream into messages.
+    //  Decoder for ZMTP/1.0 protocol. Converts data batches into messages.
 
     class v1_decoder_t : public decoder_base_t <v1_decoder_t>
     {
     public:
 
-        v1_decoder_t (size_t bufsize_,
-            int64_t maxmsgsize_, i_msg_sink *msg_sink_);
-        virtual ~v1_decoder_t ();
+        v1_decoder_t (size_t bufsize_, int64_t maxmsgsize_);
+        ~v1_decoder_t ();
 
-        //  i_decoder interface.
-        virtual void set_msg_sink (i_msg_sink *msg_sink_);
+        virtual msg_t *msg () { return &in_progress; }
 
     private:
 
-        bool flags_ready ();
-        bool one_byte_size_ready ();
-        bool eight_byte_size_ready ();
-        bool message_ready ();
+        int one_byte_size_ready ();
+        int eight_byte_size_ready ();
+        int flags_ready ();
+        int message_ready ();
 
-        i_msg_sink *msg_sink;
         unsigned char tmpbuf [8];
-        unsigned char msg_flags;
         msg_t in_progress;
 
-        const int64_t maxmsgsize;
+        int64_t maxmsgsize;
 
         v1_decoder_t (const v1_decoder_t&);
         void operator = (const v1_decoder_t&);

data/ext/zeromq/src/v1_encoder.cpp

@@ -1,8 +1,5 @@
 /*
-    Copyright (c) 2007-2012 iMatix Corporation
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    Copyright (c) 2011 VMware, Inc.
-    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.
 
@@ -20,84 +17,49 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "v1_protocol.hpp"
+#include "encoder.hpp"
 #include "v1_encoder.hpp"
 #include "likely.hpp"
 #include "wire.hpp"
 
-zmq::v1_encoder_t::v1_encoder_t (size_t bufsize_, i_msg_source *msg_source_) :
-    encoder_base_t <v1_encoder_t> (bufsize_),
-    msg_source (msg_source_)
+zmq::v1_encoder_t::v1_encoder_t (size_t bufsize_) :
+    encoder_base_t <v1_encoder_t> (bufsize_)
 {
-    int rc = in_progress.init ();
-    errno_assert (rc == 0);
-
     //  Write 0 bytes to the batch and go to message_ready state.
     next_step (NULL, 0, &v1_encoder_t::message_ready, true);
 }
 
 zmq::v1_encoder_t::~v1_encoder_t ()
 {
-    int rc = in_progress.close ();
-    errno_assert (rc == 0);
 }
 
-void zmq::v1_encoder_t::set_msg_source (i_msg_source *msg_source_)
+void zmq::v1_encoder_t::size_ready ()
 {
-    msg_source = msg_source_;
+    //  Write message body into the buffer.
+    next_step (in_progress->data (), in_progress->size (),
+        &v1_encoder_t::message_ready, true);
 }
 
-bool zmq::v1_encoder_t::message_ready ()
+void zmq::v1_encoder_t::message_ready ()
 {
-    //  Release the content of the old message.
-    int rc = in_progress.close ();
-    errno_assert (rc == 0);
+    //  Get the message size.
+    size_t size = in_progress->size ();
 
-    //  Read new message. If there is none, return false.
-    //  Note that new state is set only if write is successful. That way
-    //  unsuccessful write will cause retry on the next state machine
-    //  invocation.
-    if (unlikely (!msg_source)) {
-        rc = in_progress.init ();
-        errno_assert (rc == 0);
-        return false;
-    }
+    //  Account for the 'flags' byte.
+    size++;
 
-    rc = msg_source->pull_msg (&in_progress);
-    if (unlikely (rc)) {
-        errno_assert (errno == EAGAIN);
-        rc = in_progress.init ();
-        errno_assert (rc == 0);
-        return false;
-    }
-
-    //  Encode flags.
-    unsigned char &protocol_flags = tmpbuf [0];
-    protocol_flags = 0;
-    if (in_progress.flags () & msg_t::more)
-        protocol_flags |= v1_protocol_t::more_flag;
-    if (in_progress.size () > 255)
-        protocol_flags |= v1_protocol_t::large_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, &v1_encoder_t::size_ready, false);
+    //  For messages less than 255 bytes long, write one byte of message size.
+    //  For longer messages write 0xff escape character followed by 8-byte
+    //  message size. In both cases 'flags' field follows.
+    if (size < 255) {
+        tmpbuf [0] = (unsigned char) size;
+        tmpbuf [1] = (in_progress->flags () & msg_t::more);
+        next_step (tmpbuf, 2, &v1_encoder_t::size_ready, false);
     }
     else {
-        tmpbuf [1] = static_cast <uint8_t> (size);
-        next_step (tmpbuf, 2, &v1_encoder_t::size_ready, false);
+        tmpbuf [0] = 0xff;
+        put_uint64 (tmpbuf + 1, size);
+        tmpbuf [9] = (in_progress->flags () & msg_t::more);
+        next_step (tmpbuf, 10, &v1_encoder_t::size_ready, false);
     }
-    return true;
-}
-
-bool zmq::v1_encoder_t::size_ready ()
-{
-    //  Write message body into the buffer.
-    next_step (in_progress.data (), in_progress.size (),
-        &v1_encoder_t::message_ready, !(in_progress.flags () & msg_t::more));
-    return true;
 }

data/ext/zeromq/src/v1_encoder.hpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    Copyright (c) 2007-2012 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.
 
@@ -22,34 +20,25 @@
 #ifndef __ZMQ_V1_ENCODER_HPP_INCLUDED__
 #define __ZMQ_V1_ENCODER_HPP_INCLUDED__
 
-#include "msg.hpp"
-#include "i_msg_source.hpp"
 #include "encoder.hpp"
 
 namespace zmq
 {
-
-    class i_msg_source;
-
-    //  Encoder for 0MQ framing protocol. Converts messages into data stream.
+    //  Encoder for ZMTP/1.0 protocol. Converts messages into data batches.
 
     class v1_encoder_t : public encoder_base_t <v1_encoder_t>
     {
     public:
 
-        v1_encoder_t (size_t bufsize_, i_msg_source *msg_source_);
-        virtual ~v1_encoder_t ();
-
-        virtual void set_msg_source (i_msg_source *msg_source_);
+        v1_encoder_t (size_t bufsize_);
+        ~v1_encoder_t ();
 
     private:
 
-        bool size_ready ();
-        bool message_ready ();
+        void size_ready ();
+        void message_ready ();
 
-        i_msg_source *msg_source;
-        msg_t in_progress;
-        unsigned char tmpbuf [9];
+        unsigned char tmpbuf [10];
 
         v1_encoder_t (const v1_encoder_t&);
         const v1_encoder_t &operator = (const v1_encoder_t&);