rbczmq 1.7.1 → 1.7.2

data/ext/czmq/src/zlist.c

@@ -29,6 +29,8 @@
     can use this to construct multi-dimensional lists, and other structures
     together with other generic containers like zhash.
 @discuss
+    To iterate through a list, use zlist_first to get the first item, then
+    loop while not null, and do zlist_next at the end of each iteration.
 @end
 */
 
@@ -292,14 +294,6 @@ zlist_dup (zlist_t *self)
     return copy;
 }
 
-//  Deprecated interface
-
-zlist_t *
-zlist_copy (zlist_t *self)
-{
-    return zlist_dup (self);
-}
-
 
 //  --------------------------------------------------------------------------
 //  Return the number of items in the list

data/ext/czmq/src/zloop.c

@@ -55,16 +55,16 @@ struct _zloop_t {
 struct _s_poller_t {
     zmq_pollitem_t item;
     zloop_fn *handler;
-    void *arg;
-    bool ignore_errors;
+    void *arg;                  //  Application argument to poll item
     int errors;                 //  If too many errors, kill poller
+    bool tolerant;              //  Unless configured as tolerant
 };
 
 struct _s_timer_t {
     size_t delay;
     size_t times;
     zloop_fn *handler;
-    void *arg;
+    void *arg;                  //  Application argument to timer
     int64_t when;               //  Clock time when alarm goes off
 };
 
@@ -73,10 +73,10 @@ s_poller_new (zmq_pollitem_t *item, zloop_fn handler, void *arg)
 {
     s_poller_t *poller = (s_poller_t *) zmalloc (sizeof (s_poller_t));
     if (poller) {
-        poller->ignore_errors = (item->events & ZMQ_IGNERR) != 0;
         poller->item = *item;
         poller->handler = handler;
         poller->arg = arg;
+        poller->tolerant = false;   //  By default, errors are bad
     }
     return poller;
 }
@@ -273,6 +273,28 @@ zloop_poller_end (zloop_t *self, zmq_pollitem_t *item)
 }
 
 
+//  --------------------------------------------------------------------------
+//  Configure a registered pollitem to ignore errors. If you do not set this, 
+//  then pollitems that have errors are removed from the reactor silently.
+
+void
+zloop_set_tolerant (zloop_t *self, zmq_pollitem_t *item)
+{
+    assert (self);
+    assert (item->socket || item->fd);
+
+    //  Find matching poller(s) and mark as tolerant
+    s_poller_t *poller = (s_poller_t *) zlist_first (self->pollers);
+    while (poller) {
+        if ((item->socket && item->socket == poller->item.socket)
+        ||  (item->fd     && item->fd     == poller->item.fd))
+            poller->tolerant = true;
+            
+        poller = (s_poller_t *) zlist_next (self->pollers);
+    }
+}
+
+
 //  --------------------------------------------------------------------------
 //  Register a timer that expires after some delay and repeats some number of
 //  times. At each expiry, will call the handler, passing the arg. To
@@ -318,6 +340,7 @@ zloop_timer_end (zloop_t *self, void *arg)
 
 //  --------------------------------------------------------------------------
 //  Set verbose tracing of reactor on/off
+
 void
 zloop_set_verbose (zloop_t *self, bool verbose)
 {
@@ -329,8 +352,8 @@ zloop_set_verbose (zloop_t *self, bool verbose)
 //  Start the reactor. Takes control of the thread and returns when the 0MQ
 //  context is terminated or the process is interrupted, or any event handler
 //  returns -1. Event handlers may register new sockets and timers, and
-//  cancel sockets. Returns 0 if interrupted, -1 if canceled by a
-//  handler, positive on internal error
+//  cancel sockets. Returns 0 if interrupted, -1 if canceled by a handler,
+//  positive on internal error
 
 int
 zloop_start (zloop_t *self)
@@ -357,7 +380,8 @@ zloop_start (zloop_t *self)
                        s_tickless_timer (self) * ZMQ_POLL_MSEC);
         if (rc == -1 || zctx_interrupted) {
             if (self->verbose)
-                zclock_log ("I: zloop: interrupted (%d) - %s", rc, strerror (errno));
+                zclock_log ("I: zloop: interrupted (%d) - %s", rc, 
+                            zmq_strerror (zmq_errno ()));
             rc = 0;
             break;              //  Context has been shut down
         }
@@ -386,13 +410,13 @@ zloop_start (zloop_t *self)
             assert (self->pollset [item_nbr].socket == poller->item.socket);
             
             if ((self->pollset [item_nbr].revents & ZMQ_POLLERR)
-            && !poller->ignore_errors) {
+            && !poller->tolerant) {
                 if (self->verbose)
-                    zclock_log ("I: zloop: can't poll %s socket (%p, %d): %s",
+                    zclock_log ("W: zloop: can't poll %s socket (%p, %d): %s",
                         poller->item.socket?
                             zsocket_type_str (poller->item.socket): "FD",
                         poller->item.socket, poller->item.fd,
-                        strerror (errno));
+                        zmq_strerror (zmq_errno ()));
                 //  Give handler one chance to handle error, then kill
                 //  poller because it'll disrupt the reactor otherwise.
                 if (poller->errors++) {
@@ -412,8 +436,10 @@ zloop_start (zloop_t *self)
                 rc = poller->handler (self, &self->pollset [item_nbr], poller->arg);
                 if (rc == -1)
                     break;      //  Poller handler signaled break
-                // If the poller handler calls zloop_poller_end on poller other than itself
-                // we need to force rebuild in order to avoid reading from freed memory in the handler
+                    
+                //  If the poller handler calls zloop_poller_end on a poller 
+                //  other than itself, we need to force rebuild in order to 
+                //  avoid reading from freed memory in the handler.
                 if (self->dirty) {
                     if (self->verbose)
                         zclock_log ("I: zloop: pollers canceled, forcing rebuild");
@@ -483,8 +509,9 @@ zloop_test (bool verbose)
     
     //  When we get the ping message, end the reactor
     zmq_pollitem_t poll_input = { input, 0, ZMQ_POLLIN };
-    rc = zloop_poller (loop, &poll_input, s_socket_event, NULL);
+    rc = zloop_poller (loop, &poll_input, s_socket_event, NULL);    
     assert (rc == 0);
+    zloop_set_tolerant (loop, &poll_input);
     zloop_start (loop);
 
     zloop_destroy (&loop);

data/ext/czmq/src/zmsg.c

@@ -97,17 +97,17 @@ zmsg_recv (void *zocket)
     if (!self)
         return NULL;
 
-    while (1) {
+    while (true) {
         zframe_t *frame = zframe_recv (zocket);
         if (!frame) {
             zmsg_destroy (&self);
             break;              //  Interrupted or terminated
         }
-        if (zmsg_add (self, frame)) {
+        if (zmsg_append (self, &frame)) {
             zmsg_destroy (&self);
             break;
         }
-        if (!zframe_more (frame))
+        if (!zsocket_rcvmore (zocket))
             break;              //  Last message frame
     }
     return self;
@@ -127,11 +127,14 @@ zmsg_send (zmsg_t **self_p, void *zocket)
     zmsg_t *self = *self_p;
 
     int rc = 0;
+    if (zlist_size (self->frames) == 0)
+        return -1;
+    else
     if (self) {
         zframe_t *frame = (zframe_t *) zlist_pop (self->frames);
         while (frame) {
             rc = zframe_send (&frame, zocket,
-                              zlist_size (self->frames)? ZFRAME_MORE: 0);
+                zlist_size (self->frames)? ZFRAME_MORE: 0);
             if (rc != 0)
                 break;
             frame = (zframe_t *) zlist_pop (self->frames);
@@ -154,7 +157,7 @@ zmsg_size (zmsg_t *self)
 
 
 //  --------------------------------------------------------------------------
-//  Return size of message, i.e. number of frames (0 or more).
+//  Return total size of all frames in message.
 
 size_t
 zmsg_content_size (zmsg_t *self)
@@ -197,7 +200,24 @@ zmsg_pop (zmsg_t *self)
 //  --------------------------------------------------------------------------
 //  Add frame to the end of the message, i.e. after all other frames.
 //  Message takes ownership of frame, will destroy it when message is sent.
-//  Returns 0 on success
+//  Returns 0 on success. Nullifies caller's reference to frame.
+
+int
+zmsg_append (zmsg_t *self, zframe_t **frame_p)
+{
+    assert (self);
+    assert (frame_p);
+    zframe_t *frame = *frame_p;
+    *frame_p = NULL;            //  We now own frame
+    self->content_size += zframe_size (frame);
+    return zlist_append (self->frames, frame);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Add frame to the end of the message, i.e. after all other frames.
+//  Message takes ownership of frame, will destroy it when message is sent.
+//  Returns 0 on success. Deprecated by zmsg_append ().
 
 int
 zmsg_add (zmsg_t *self, zframe_t *frame)
@@ -228,6 +248,7 @@ zmsg_pushmem (zmsg_t *self, const void *src, size_t size)
 
 //  --------------------------------------------------------------------------
 //  Add block of memory to the end of the message, as a new frame.
+//  Returns 0 on success, -1 on error.
 
 int
 zmsg_addmem (zmsg_t *self, const void *src, size_t size)
@@ -242,32 +263,10 @@ zmsg_addmem (zmsg_t *self, const void *src, size_t size)
         return -1;
 }
 
-//  --------------------------------------------------------------------------
-//  Add block of memory to the end of the message, as a new frame.
-//  The new frame is zero-copy-constructed (see zframe_new_zero_copy(...) 
-//  for detailed description)
-//  NOTE: this method is DEPRECATED and is slated for removal. These are the
-//  problems with the method:
-//  - premature optimization: do we really need this? It makes the API more
-//    complex; high-performance applications would not use zmsg in any case,
-//    they would work directly with zmq_msg objects.
-//  (PH, 2013/05/18)
-
-int
-zmsg_addmem_zero_copy (zmsg_t *self, void *src, size_t size, zframe_free_fn *free_fn, void *arg)
-{
-    assert (self);
-    zframe_t *frame = zframe_new_zero_copy (src, size, free_fn, arg);
-    if (frame) {
-        self->content_size += size;
-        return zlist_append (self->frames, frame);
-    }
-    else
-        return -1;
-}
 
 //  --------------------------------------------------------------------------
-//  Push string as new frame to front of message
+//  Push string as new frame to front of message, returns 0 if OK, -1 on
+//  error. The string is formatted using sprintf. 
 
 int
 zmsg_pushstr (zmsg_t *self, const char *format, ...)
@@ -275,38 +274,14 @@ zmsg_pushstr (zmsg_t *self, const char *format, ...)
     assert (self);
     assert (format);
 
-    //  Format string into buffer
-    int size = 255 + 1;
-    char stackbuffer[255+1];
-    char *string = stackbuffer;
     va_list argptr;
     va_start (argptr, format);
-    int required = vsnprintf (string, size, format, argptr);
+    char *string = zsys_vprintf (format, argptr);
     va_end (argptr);
-#ifdef _MSC_VER
-    if (required < 0 || required >= size) {
-        va_start (argptr, format);
-        required = _vscprintf (format, argptr);
-        va_end (argptr);
-    }
-#endif
-    if (required >= size) {
-        size = required + 1;
-        string = (char *) malloc (size);
-        if (!string) {
-            return -1;
-        }
-        va_start (argptr, format);
-        size = vsnprintf (string, size, format, argptr);
-        va_end (argptr);
-    }
-    else
-        size = required;
-
-    self->content_size += size;
-    zlist_push (self->frames, zframe_new (string, size));
-    if (string!=stackbuffer)
-        free (string);
+    
+    self->content_size += strlen (string);
+    zlist_push (self->frames, zframe_new (string, strlen (string)));
+    free (string);
     return 0;
 }
 
@@ -319,44 +294,21 @@ zmsg_addstr (zmsg_t *self, const char *format, ...)
 {
     assert (self);
     assert (format);
-    //  Format string into buffer
-    int size = 255 + 1;
-    char stackbuffer[255+1];
-    char *string = stackbuffer;
+
     va_list argptr;
     va_start (argptr, format);
-    int required = vsnprintf (string, size, format, argptr);
+    char *string = zsys_vprintf (format, argptr);
     va_end (argptr);
-#ifdef _MSC_VER
-    if (required < 0 || required >= size) {
-        va_start (argptr, format);
-        required = _vscprintf (format, argptr);
-        va_end (argptr);
-    }
-#endif    
-    if (required >= size) {
-        size = required + 1;
-        string = (char *) malloc (size);
-        if (!string) {
-            return -1;
-        }
-        va_start (argptr, format);
-        size = vsnprintf (string, size, format, argptr);
-        va_end (argptr);
-    }
-    else
-        size = required;
-
-    self->content_size += size;
-    zlist_append (self->frames, zframe_new (string, size));
-    if (string!=stackbuffer)
-        free (string);
+    
+    self->content_size += strlen (string);
+    zlist_append (self->frames, zframe_new (string, strlen (string)));
+    free (string);
     return 0;
 }
 
-
 //  --------------------------------------------------------------------------
-//  Pop frame off front of message, return as fresh string
+//  Pop frame off front of message, return as fresh string. If there were
+//  no more frames in the message, returns NULL.
 
 char *
 zmsg_popstr (zmsg_t *self)
@@ -397,7 +349,7 @@ zmsg_unwrap (zmsg_t *self)
     assert (self);
     zframe_t *frame = zmsg_pop (self);
     zframe_t *empty = zmsg_first (self);
-    if (zframe_size (empty) == 0) {
+    if (empty && zframe_size (empty) == 0) {
         empty = zmsg_pop (self);
         zframe_destroy (&empty);
     }
@@ -418,7 +370,8 @@ zmsg_remove (zmsg_t *self, zframe_t *frame)
 
 
 //  --------------------------------------------------------------------------
-//  Set cursor to first frame in message. Returns frame, or NULL.
+//  Set cursor to first frame in message. Returns frame, or NULL, if the 
+//  message is empty. Use this to navigate the frames as a list.
 
 zframe_t *
 zmsg_first (zmsg_t *self)
@@ -452,7 +405,12 @@ zmsg_last (zmsg_t *self)
 
 
 //  --------------------------------------------------------------------------
-//  Save message to an open file, return 0 if OK, else -1.
+//  Save message to an open file, return 0 if OK, else -1. The message is 
+//  saved as a series of frames, each with length and data. Note that the
+//  file is NOT guaranteed to be portable between operating systems, not
+//  versions of CZMQ. The file format is at present undocumented and liable
+//  to arbitrary change.
+
 int
 zmsg_save (zmsg_t *self, FILE *file)
 {
@@ -492,27 +450,33 @@ zmsg_load (zmsg_t *self, FILE *file)
         if (rc == 1) {
             zframe_t *frame = zframe_new (NULL, frame_size);
             rc = fread (zframe_data (frame), frame_size, 1, file);
-            if (frame_size > 0 && rc != 1)
+            if (frame_size > 0 && rc != 1) {
+                zframe_destroy (&frame);
                 break;          //  Unable to read properly, quit
-            zmsg_add (self, frame);
+            }
+            zmsg_append (self, &frame);
         }
         else
             break;              //  Unable to read properly, quit
     }
+    if (!zmsg_size (self)) {
+        zmsg_destroy (&self);
+        self = NULL;
+    }
     return self;
 }
 
 
 //  --------------------------------------------------------------------------
-//  Encode message to a new buffer, return buffer size
+//  Serialize multipart message to a single buffer. Use this method to send
+//  structured messages across transports that do not support multipart data.
+//  Allocates and returns a new buffer containing the serialized message.
+//  To decode a serialized message buffer, use zmsg_decode ().
 
-//  Frame lengths are encoded as 1, 1+2, or 1+4 bytes
-//  0..253 bytes        octet + data
-//  254..64k-1 bytes    0xFE + 2octet + data
-//  64k..4Gb-1 bytes    0xFF + 4octet + data
 
-#define ZMSG_SHORT_LEN      0xFE
-#define ZMSG_LONG_LEN       0xFF
+//  Frame lengths are encoded as 1 or 1+4 bytes
+//  0..254 bytes        octet + data
+//  255..4Gb-1 bytes    0xFF + 4octet + data
 
 size_t
 zmsg_encode (zmsg_t *self, byte **buffer)
@@ -524,13 +488,10 @@ zmsg_encode (zmsg_t *self, byte **buffer)
     zframe_t *frame = zmsg_first (self);
     while (frame) {
         size_t frame_size = zframe_size (frame);
-        if (frame_size < ZMSG_SHORT_LEN)
+        if (frame_size < 255)
             buffer_size += frame_size + 1;
         else
-        if (frame_size < 0x10000)
-            buffer_size += frame_size + 3;
-        else
-            buffer_size += frame_size + 5;
+            buffer_size += frame_size + 1 + 4;
         frame = zmsg_next (self);
     }
     *buffer = (byte *) malloc (buffer_size);
@@ -540,21 +501,13 @@ zmsg_encode (zmsg_t *self, byte **buffer)
     frame = zmsg_first (self);
     while (frame) {
         size_t frame_size = zframe_size (frame);
-        if (frame_size < ZMSG_SHORT_LEN) {
+        if (frame_size < 255) {
             *dest++ = (byte) frame_size;
             memcpy (dest, zframe_data (frame), frame_size);
             dest += frame_size;
         }
-        else
-        if (frame_size < 0x10000) {
-            *dest++ = ZMSG_SHORT_LEN;
-            *dest++ = (frame_size >> 8) & 255;
-            *dest++ =  frame_size       & 255;
-            memcpy (dest, zframe_data (frame), frame_size);
-            dest += frame_size;
-        }
         else {
-            *dest++ = ZMSG_LONG_LEN;
+            *dest++ = 0xFF;
             *dest++ = (frame_size >> 24) & 255;
             *dest++ = (frame_size >> 16) & 255;
             *dest++ = (frame_size >>  8) & 255;
@@ -570,8 +523,9 @@ zmsg_encode (zmsg_t *self, byte **buffer)
 
 
 //  --------------------------------------------------------------------------
-//  Decode a buffer into a new message, returns NULL if buffer is not
-//  properly formatted or there is insufficient free memory.
+//  Decodes a serialized message buffer created by zmsg_encode () and returns
+//  a new zmsg_t object. Returns NULL if the buffer was badly formatted or 
+//  there was insufficient memory to work.
 
 zmsg_t *
 zmsg_decode (byte *buffer, size_t buffer_size)
@@ -584,16 +538,7 @@ zmsg_decode (byte *buffer, size_t buffer_size)
     byte *limit = buffer + buffer_size;
     while (source < limit) {
         size_t frame_size = *source++;
-        if (frame_size == ZMSG_SHORT_LEN) {
-            if (source > limit - 2) {
-                zmsg_destroy (&self);
-                break;
-            }
-            frame_size = (source [0] << 8) + source [1];
-            source += 2;
-        }
-        else
-        if (frame_size == ZMSG_LONG_LEN) {
+        if (frame_size == 255) {
             if (source > limit - 4) {
                 zmsg_destroy (&self);
                 break;
@@ -610,7 +555,7 @@ zmsg_decode (byte *buffer, size_t buffer_size)
         }
         zframe_t *frame = zframe_new (source, frame_size);
         if (frame) {
-            if (zmsg_add (self, frame)) {
+            if (zmsg_append (self, &frame)) {
                 zmsg_destroy (&self);
                 break;
             }
@@ -626,7 +571,8 @@ zmsg_decode (byte *buffer, size_t buffer_size)
 
 
 //  --------------------------------------------------------------------------
-//  Create copy of message, as new message object
+//  Create copy of message, as new message object. Returns a fresh zmsg_t
+//  object, or NULL if there was not enough heap memory.
 
 zmsg_t *
 zmsg_dup (zmsg_t *self)
@@ -652,23 +598,33 @@ zmsg_dup (zmsg_t *self)
 
 
 //  --------------------------------------------------------------------------
-//  Dump message to stderr, for debugging and tracing
-//  Truncates to first 10 frames, for readability; this may be unfortunate
-//  when debugging larger and more complex messages. Perhaps a way to hide
-//  repeated lines instead?
+//  Dump message to stderr, for debugging and tracing.
+//  See zmsg_dump_to_stream() for details
 
 void
 zmsg_dump (zmsg_t *self)
 {
-    fprintf (stderr, "--------------------------------------\n");
+   zmsg_dump_to_stream (self, stderr);
+}
+
+
+//  --------------------------------------------------------------------------
+//  Dump message to FILE stream, for debugging and tracing. 
+//  Truncates to first 10 frames, for readability; this may be unfortunate
+//  when debugging larger and more complex messages.
+
+void
+zmsg_dump_to_stream (zmsg_t *self, FILE *file)
+{
+    fprintf (file, "--------------------------------------\n");
     if (!self) {
-        fprintf (stderr, "NULL");
+        fprintf (file, "NULL");
         return;
     }
     zframe_t *frame = zmsg_first (self);
     int frame_nbr = 0;
     while (frame && frame_nbr++ < 10) {
-        zframe_print (frame, "");
+        zframe_print_to_stream(frame, NULL, file);
         frame = zmsg_next (self);
     }
 }
@@ -752,12 +708,21 @@ zmsg_test (bool verbose)
     assert (msg);
     assert (zmsg_size (msg) == 10);
     assert (zmsg_content_size (msg) == 60);
-    if (verbose)
-        zmsg_dump (msg);
 
-    //  Save to a file, read back
+    // create empty file for null test
     FILE *file = fopen ("zmsg.test", "w");
     assert (file);
+    fclose (file);
+
+    file = fopen ("zmsg.test", "r");
+    zmsg_t *null_msg = zmsg_load (NULL, file);
+    assert (null_msg == NULL);
+    fclose (file);
+    remove ("zmsg.test");
+
+    //  Save to a file, read back
+    file = fopen ("zmsg.test", "w");
+    assert (file);
     rc = zmsg_save (msg, file);
     assert (rc == 0);
     fclose (file);
@@ -841,10 +806,13 @@ zmsg_test (bool verbose)
     msg = zmsg_new ();
     assert (msg);
     assert (zmsg_size (msg) == 0);
+    assert (zmsg_unwrap (msg) == NULL);
     assert (zmsg_first (msg) == NULL);
     assert (zmsg_last (msg) == NULL);
     assert (zmsg_next (msg) == NULL);
     assert (zmsg_pop (msg) == NULL);
+    assert (zmsg_send (&msg, output) == -1);
+    assert (msg != NULL);
     zmsg_destroy (&msg);
 
     zctx_destroy (&ctx);