rbczmq 1.7.1 → 1.7.2

data/ext/zeromq/src/msg.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2007-2012 iMatix Corporation
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    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.
 
@@ -31,7 +29,7 @@
 #include "err.hpp"
 
 //  Check whether the sizes of public representation of the message (zmq_msg_t)
-//  and private represenation of the message (zmq::msg_t) match.
+//  and private representation of the message (zmq::msg_t) match.
 typedef char zmq_msg_size_check
     [2 * ((sizeof (zmq::msg_t) == sizeof (zmq_msg_t)) != 0) - 1];
 
@@ -60,7 +58,7 @@ int zmq::msg_t::init_size (size_t size_)
         u.lmsg.flags = 0;
         u.lmsg.content =
             (content_t*) malloc (sizeof (content_t) + size_);
-        if (!u.lmsg.content) {
+        if (unlikely (!u.lmsg.content)) {
             errno = ENOMEM;
             return -1;
         }
@@ -77,19 +75,32 @@ int zmq::msg_t::init_size (size_t size_)
 int zmq::msg_t::init_data (void *data_, size_t size_, msg_free_fn *ffn_,
     void *hint_)
 {
-    u.lmsg.type = type_lmsg;
-    u.lmsg.flags = 0;
-    u.lmsg.content = (content_t*) malloc (sizeof (content_t));
-    if (!u.lmsg.content) {
-        errno = ENOMEM;
-        return -1;
+    //  If data is NULL and size is not 0, a segfault
+    //  would occur once the data is accessed
+    assert (data_ != NULL || size_ == 0);
+    
+    //  Initialize constant message if there's no need to deallocate
+    if(ffn_ == NULL) {
+        u.cmsg.type = type_cmsg;
+        u.cmsg.flags = 0;
+        u.cmsg.data = data_;
+        u.cmsg.size = size_;
     }
+    else {
+        u.lmsg.type = type_lmsg;
+        u.lmsg.flags = 0;
+        u.lmsg.content = (content_t*) malloc (sizeof (content_t));
+        if (!u.lmsg.content) {
+            errno = ENOMEM;
+            return -1;
+        }
 
-    u.lmsg.content->data = data_;
-    u.lmsg.content->size = size_;
-    u.lmsg.content->ffn = ffn_;
-    u.lmsg.content->hint = hint_;
-    new (&u.lmsg.content->refcnt) zmq::atomic_counter_t ();
+        u.lmsg.content->data = data_;
+        u.lmsg.content->size = size_;
+        u.lmsg.content->ffn = ffn_;
+        u.lmsg.content->hint = hint_;
+        new (&u.lmsg.content->refcnt) zmq::atomic_counter_t ();
+    }
     return 0;
 
 }
@@ -195,6 +206,8 @@ void *zmq::msg_t::data ()
         return u.vsm.data;
     case type_lmsg:
         return u.lmsg.content->data;
+    case type_cmsg:
+        return u.cmsg.data;
     default:
         zmq_assert (false);
         return NULL;
@@ -211,6 +224,8 @@ size_t zmq::msg_t::size ()
         return u.vsm.size;
     case type_lmsg:
         return u.lmsg.content->size;
+    case type_cmsg:
+        return u.cmsg.size;
     default:
         zmq_assert (false);
         return 0;
@@ -247,6 +262,11 @@ bool zmq::msg_t::is_vsm ()
     return u.base.type == type_vsm;
 }
 
+bool zmq::msg_t::is_cmsg ()
+{
+    return u.base.type == type_cmsg;
+}
+
 void zmq::msg_t::add_refs (int refs_)
 {
     zmq_assert (refs_ >= 0);
@@ -255,8 +275,8 @@ void zmq::msg_t::add_refs (int refs_)
     if (!refs_)
         return;
 
-    //  VSMs and delimiters can be copied straight away. The only message type
-    //  that needs special care are long messages.
+    //  VSMs, CMSGS and delimiters can be copied straight away. The only
+    //  message type that needs special care are long messages.
     if (u.base.type == type_lmsg) {
         if (u.lmsg.flags & msg_t::shared)
             u.lmsg.content->refcnt.add (refs_);

data/ext/zeromq/src/msg.hpp

@@ -1,8 +1,5 @@
 /*
-    Copyright (c) 2009-2011 250bpm s.r.o.
-    Copyright (c) 2007-2009 iMatix Corporation
-    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.
 
@@ -47,10 +44,11 @@ namespace zmq
     {
     public:
 
-        //  Mesage flags.
+        //  Message flags.
         enum
         {
-            more = 1,
+            more = 1,           //  Followed by more parts
+            command = 2,        //  Command frame (see ZMTP spec)
             identity = 64,
             shared = 128
         };
@@ -72,6 +70,7 @@ namespace zmq
         bool is_identity () const;
         bool is_delimiter ();
         bool is_vsm ();
+        bool is_cmsg ();
 
         //  After calling this function you can copy the message in POD-style
         //  refs_ times. No need to call copy.
@@ -107,10 +106,15 @@ namespace zmq
         enum type_t
         {
             type_min = 101,
+            //  VSM messages store the content in the message itself
             type_vsm = 101,
+            //  LMSG messages store the content in malloc-ed memory
             type_lmsg = 102,
+            //  Delimiter messages are used in envelopes
             type_delimiter = 103,
-            type_max = 103
+            //  CMSG messages point to constant data
+            type_cmsg = 104,
+            type_max = 104
         };
 
         //  Note that fields shared between different message types are not
@@ -135,6 +139,14 @@ namespace zmq
                 unsigned char type;
                 unsigned char flags;
             } lmsg;
+            struct {
+                void* data;
+                size_t size;
+                unsigned char unused
+                    [max_vsm_size + 1 - sizeof (void*) - sizeof (size_t)];
+                unsigned char type;
+                unsigned char flags;
+            } cmsg;
             struct {
                 unsigned char unused [max_vsm_size + 1];
                 unsigned char type;

data/ext/zeromq/src/mtrie.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2011 250bpm s.r.o.
-    Copyright (c) 2011-2012 Spotify AB
-    Copyright (c) 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.
 
@@ -53,10 +51,10 @@ zmq::mtrie_t::~mtrie_t ()
         delete next.node;
         next.node = 0;
     }
-    else if (count > 1) {
+    else 
+    if (count > 1) {
         for (unsigned short i = 0; i != count; ++i)
-            if (next.table [i])
-                delete next.table [i];
+            delete next.table [i];
         free (next.table);
     }
 }
@@ -90,7 +88,8 @@ bool zmq::mtrie_t::add_helper (unsigned char *prefix_, size_t size_,
             count = 1;
             next.node = NULL;
         }
-        else if (count == 1) {
+        else 
+        if (count == 1) {
             unsigned char oldc = min;
             mtrie_t *oldp = next.node;
             count = (min < c ? c - min : min - c) + 1;
@@ -102,8 +101,8 @@ bool zmq::mtrie_t::add_helper (unsigned char *prefix_, size_t size_,
             min = std::min (min, c);
             next.table [oldc - min] = oldp;
         }
-        else if (min < c) {
-
+        else 
+        if (min < c) {
             //  The new character is above the current character range.
             unsigned short old_count = count;
             count = c - min + 1;
@@ -114,7 +113,6 @@ bool zmq::mtrie_t::add_helper (unsigned char *prefix_, size_t size_,
                 next.table [i] = NULL;
         }
         else {
-
             //  The new character is below the current character range.
             unsigned short old_count = count;
             count = (min + old_count) - c;
@@ -244,7 +242,8 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
         count = 0;
     }
     //  Compact the node table if possible
-    else if (live_nodes == 1) {
+    else 
+    if (live_nodes == 1) {
         //  If there's only one live node in the table we can
         //  switch to using the more compact single-node
         //  representation
@@ -257,7 +256,8 @@ void zmq::mtrie_t::rm_helper (pipe_t *pipe_, unsigned char **buff_,
         count = 1;
         min = new_min;
     }
-    else if (new_min > min || new_max < min + count - 1) {
+    else
+    if (new_min > min || new_max < min + count - 1) {
         zmq_assert (new_max - new_min + 1 > 1);
 
         mtrie_t **old_table = next.table;
@@ -342,7 +342,8 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
                 free (next.table);
                 next.node = oldp;
             }
-            else if (c == min) {
+            else
+            if (c == min) {
                 //  We can compact the table "from the left"
                 unsigned short i;
                 for (i = 1; i < count; ++i)
@@ -358,7 +359,8 @@ bool zmq::mtrie_t::rm_helper (unsigned char *prefix_, size_t size_,
                 memmove (next.table, old_table + i, sizeof (mtrie_t*) * count);
                 free (old_table);
             }
-            else if (c == min + count - 1) {
+            else
+            if (c == min + count - 1) {
                 //  We can compact the table "from the right"
                 unsigned short i;
                 for (i = 1; i < count; ++i)

data/ext/zeromq/src/mtrie.hpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2011 250bpm s.r.o.
-    Copyright (c) 2011-2012 Spotify AB
-    Copyright (c) 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/mutex.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.
 
@@ -52,6 +50,11 @@ namespace zmq
             EnterCriticalSection (&cs);
         }
 
+        inline bool try_lock ()
+        {
+            return (TryEnterCriticalSection (&cs)) ? true : false;
+        }
+
         inline void unlock ()
         {
             LeaveCriticalSection (&cs);
@@ -96,6 +99,16 @@ namespace zmq
             posix_assert (rc);
         }
 
+        inline bool try_lock ()
+        {
+            int rc = pthread_mutex_trylock (&mutex);
+            if (rc == EBUSY)
+                return false;
+
+            posix_assert (rc);
+            return true;
+        }
+
         inline void unlock ()
         {
             int rc = pthread_mutex_unlock (&mutex);
@@ -115,4 +128,30 @@ namespace zmq
 
 #endif
 
+
+namespace zmq
+{
+    struct scoped_lock_t
+    {
+        scoped_lock_t (mutex_t& mutex_)
+            : mutex (mutex_)
+        {
+            mutex.lock ();
+        }
+
+        ~scoped_lock_t ()
+        {
+            mutex.unlock ();
+        }
+
+    private:
+
+        mutex_t& mutex;
+
+        // Disable copy construction and assignment.
+        scoped_lock_t (const scoped_lock_t&);
+        const scoped_lock_t &operator = (const scoped_lock_t&);
+    };
+}
+
 #endif

data/ext/zeromq/src/null_mechanism.cpp

@@ -0,0 +1,282 @@
+/*
+    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 "platform.hpp"
+#ifdef ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#endif
+
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "err.hpp"
+#include "msg.hpp"
+#include "session_base.hpp"
+#include "wire.hpp"
+#include "null_mechanism.hpp"
+
+zmq::null_mechanism_t::null_mechanism_t (session_base_t *session_,
+                                         const std::string &peer_address_,
+                                         const options_t &options_) :
+    mechanism_t (options_),
+    session (session_),
+    peer_address (peer_address_),
+    ready_command_sent (false),
+    ready_command_received (false),
+    zap_connected (false),
+    zap_request_sent (false),
+    zap_reply_received (false)
+{
+    //  NULL mechanism only uses ZAP if there's a domain defined
+    //  This prevents ZAP requests on naive sockets
+    if (options.zap_domain.size () > 0
+    &&  session->zap_connect () == 0)
+        zap_connected = true;
+}
+
+zmq::null_mechanism_t::~null_mechanism_t ()
+{
+}
+
+int zmq::null_mechanism_t::next_handshake_command (msg_t *msg_)
+{
+    if (ready_command_sent) {
+        errno = EAGAIN;
+        return -1;
+    }
+    if (zap_connected && !zap_reply_received) {
+        if (zap_request_sent) {
+            errno = EAGAIN;
+            return -1;
+        }
+        send_zap_request ();
+        zap_request_sent = true;
+        const int rc = receive_and_process_zap_reply ();
+        if (rc != 0)
+            return -1;
+        zap_reply_received = true;
+    }
+
+    unsigned char * const command_buffer = (unsigned char *) malloc (512);
+    alloc_assert (command_buffer);
+
+    unsigned char *ptr = command_buffer;
+
+    //  Add mechanism string
+    memcpy (ptr, "\5READY", 6);
+    ptr += 6;
+
+    //  Add socket type property
+    const char *socket_type = socket_type_string (options.type);
+    ptr += add_property (ptr, "Socket-Type", socket_type, strlen (socket_type));
+
+    //  Add identity property
+    if (options.type == ZMQ_REQ
+    ||  options.type == ZMQ_DEALER
+    ||  options.type == ZMQ_ROUTER) {
+        ptr += add_property (ptr, "Identity",
+            options.identity, options.identity_size);
+    }
+
+    const size_t command_size = ptr - command_buffer;
+    const int rc = msg_->init_size (command_size);
+    errno_assert (rc == 0);
+    memcpy (msg_->data (), command_buffer, command_size);
+    free (command_buffer);
+
+    ready_command_sent = true;
+
+    return 0;
+}
+
+int zmq::null_mechanism_t::process_handshake_command (msg_t *msg_)
+{
+    if (ready_command_received) {
+        errno = EPROTO;
+        return -1;
+    }
+
+    const unsigned char *ptr =
+        static_cast <unsigned char *> (msg_->data ());
+    size_t bytes_left = msg_->size ();
+
+    if (bytes_left < 6 || memcmp (ptr, "\5READY", 6)) {
+        errno = EPROTO;
+        return -1;
+    }
+
+    ptr += 6;
+    bytes_left -= 6;
+
+    int rc = parse_metadata (ptr, bytes_left);
+    if (rc == 0) {
+        int rc = msg_->close ();
+        errno_assert (rc == 0);
+        rc = msg_->init ();
+        errno_assert (rc == 0);
+    }
+
+    ready_command_received = true;
+
+    return rc;
+}
+
+int zmq::null_mechanism_t::zap_msg_available ()
+{
+    if (zap_reply_received) {
+        errno = EFSM;
+        return -1;
+    }
+    const int rc = receive_and_process_zap_reply ();
+    if (rc == 0)
+        zap_reply_received = true;
+    return rc;
+}
+
+bool zmq::null_mechanism_t::is_handshake_complete () const
+{
+    return ready_command_received && ready_command_sent;
+}
+
+void zmq::null_mechanism_t::send_zap_request ()
+{
+    int rc;
+    msg_t msg;
+
+    //  Address delimiter frame
+    rc = msg.init ();
+    errno_assert (rc == 0);
+    msg.set_flags (msg_t::more);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+
+    //  Version frame
+    rc = msg.init_size (3);
+    errno_assert (rc == 0);
+    memcpy (msg.data (), "1.0", 3);
+    msg.set_flags (msg_t::more);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+
+    //  Request id frame
+    rc = msg.init_size (1);
+    errno_assert (rc == 0);
+    memcpy (msg.data (), "1", 1);
+    msg.set_flags (msg_t::more);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+
+    //  Domain frame
+    rc = msg.init_size (options.zap_domain.length ());
+    errno_assert (rc == 0);
+    memcpy (msg.data (), options.zap_domain.c_str (), options.zap_domain.length ());
+    msg.set_flags (msg_t::more);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+
+    //  Address frame
+    rc = msg.init_size (peer_address.length ());
+    errno_assert (rc == 0);
+    memcpy (msg.data (), peer_address.c_str (), peer_address.length ());
+    msg.set_flags (msg_t::more);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+
+    //  Identity frame
+    rc = msg.init_size (options.identity_size);
+    errno_assert (rc == 0);
+    memcpy (msg.data (), options.identity, options.identity_size);
+    msg.set_flags (msg_t::more);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+
+    //  Mechanism frame
+    rc = msg.init_size (4);
+    errno_assert (rc == 0);
+    memcpy (msg.data (), "NULL", 4);
+    rc = session->write_zap_msg (&msg);
+    errno_assert (rc == 0);
+}
+
+int zmq::null_mechanism_t::receive_and_process_zap_reply ()
+{
+    int rc = 0;
+    msg_t msg [7];  //  ZAP reply consists of 7 frames
+
+    //  Initialize all reply frames
+    for (int i = 0; i < 7; i++) {
+        rc = msg [i].init ();
+        errno_assert (rc == 0);
+    }
+
+    for (int i = 0; i < 7; i++) {
+        rc = session->read_zap_msg (&msg [i]);
+        if (rc == -1)
+            break;
+        if ((msg [i].flags () & msg_t::more) == (i < 6? 0: msg_t::more)) {
+            errno = EPROTO;
+            rc = -1;
+            break;
+        }
+    }
+
+    if (rc != 0)
+        goto error;
+
+    //  Address delimiter frame
+    if (msg [0].size () > 0) {
+        rc = -1;
+        errno = EPROTO;
+        goto error;
+    }
+
+    //  Version frame
+    if (msg [1].size () != 3 || memcmp (msg [1].data (), "1.0", 3)) {
+        rc = -1;
+        errno = EPROTO;
+        goto error;
+    }
+
+    //  Request id frame
+    if (msg [2].size () != 1 || memcmp (msg [2].data (), "1", 1)) {
+        rc = -1;
+        errno = EPROTO;
+        goto error;
+    }
+
+    //  Status code frame
+    if (msg [3].size () != 3 || memcmp (msg [3].data (), "200", 3)) {
+        rc = -1;
+        errno = EACCES;
+        goto error;
+    }
+
+    //  Process metadata frame
+    rc = parse_metadata (static_cast <const unsigned char*> (msg [6].data ()),
+                         msg [6].size ());
+
+error:
+    for (int i = 0; i < 7; i++) {
+        const int rc2 = msg [i].close ();
+        errno_assert (rc2 == 0);
+    }
+
+    return rc;
+}