rbczmq 1.7.4 → 1.7.5

data/ext/zeromq/src/signaler.hpp

@@ -58,7 +58,8 @@ namespace zmq
         //  to pass the signals.
         static int make_fdpair (fd_t *r_, fd_t *w_);
 
-        //  Underlying write & read file descriptor.
+        //  Underlying write & read file descriptor
+        //  Will be -1 if we exceeded number of available handles
         fd_t w;
         fd_t r;
 
@@ -74,7 +75,6 @@ namespace zmq
         void close_internal();
 #endif
     };
-
 }
 
 #endif

data/ext/zeromq/src/socket_base.cpp

@@ -79,47 +79,49 @@ zmq::socket_base_t *zmq::socket_base_t::create (int type_, class ctx_t *parent_,
 {
     socket_base_t *s = NULL;
     switch (type_) {
-
-    case ZMQ_PAIR:
-        s = new (std::nothrow) pair_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_PUB:
-        s = new (std::nothrow) pub_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_SUB:
-        s = new (std::nothrow) sub_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_REQ:
-        s = new (std::nothrow) req_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_REP:
-        s = new (std::nothrow) rep_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_DEALER:
-        s = new (std::nothrow) dealer_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_ROUTER:
-        s = new (std::nothrow) router_t (parent_, tid_, sid_);
-        break;     
-    case ZMQ_PULL:
-        s = new (std::nothrow) pull_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_PUSH:
-        s = new (std::nothrow) push_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_XPUB:
-        s = new (std::nothrow) xpub_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_XSUB:
-        s = new (std::nothrow) xsub_t (parent_, tid_, sid_);
-        break;
-    case ZMQ_STREAM:
-        s = new (std::nothrow) stream_t (parent_, tid_, sid_);
-        break;
-    default:
-        errno = EINVAL;
-        return NULL;
+        case ZMQ_PAIR:
+            s = new (std::nothrow) pair_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_PUB:
+            s = new (std::nothrow) pub_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_SUB:
+            s = new (std::nothrow) sub_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_REQ:
+            s = new (std::nothrow) req_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_REP:
+            s = new (std::nothrow) rep_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_DEALER:
+            s = new (std::nothrow) dealer_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_ROUTER:
+            s = new (std::nothrow) router_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_PULL:
+            s = new (std::nothrow) pull_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_PUSH:
+            s = new (std::nothrow) push_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_XPUB:
+            s = new (std::nothrow) xpub_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_XSUB:
+            s = new (std::nothrow) xsub_t (parent_, tid_, sid_);
+            break;
+        case ZMQ_STREAM:
+            s = new (std::nothrow) stream_t (parent_, tid_, sid_);
+            break;
+        default:
+            errno = EINVAL;
+            return NULL;
     }
+    if (s->mailbox.get_fd () == -1)
+        return NULL;
+
     alloc_assert (s);
     return s;
 }

data/ext/zeromq/src/stream_engine.cpp

@@ -74,8 +74,8 @@ zmq::stream_engine_t::stream_engine_t (fd_t fd_, const options_t &options_,
     io_error (false),
     subscription_required (false),
     mechanism (NULL),
-    input_paused (false),
-    output_paused (false),
+    input_stopped (false),
+    output_stopped (false),
     socket (NULL)
 {
     int rc = tx_msg.init ();
@@ -204,7 +204,7 @@ void zmq::stream_engine_t::in_event ()
     zmq_assert (decoder);
 
     //  If there has been an I/O error, stop polling.
-    if (input_paused) {
+    if (input_stopped) {
         rm_fd (handle);
         io_error = true;
         return;
@@ -217,17 +217,22 @@ void zmq::stream_engine_t::in_event ()
         //  Note that buffer can be arbitrarily large. However, we assume
         //  the underlying TCP layer has fixed buffer size and thus the
         //  number of bytes read will be always limited.
-        decoder->get_buffer (&inpos, &insize);
-        const int bytes_read = read (inpos, insize);
+        size_t bufsize = 0;
+        decoder->get_buffer (&inpos, &bufsize);
 
-        //  Check whether the peer has closed the connection.
-        if (bytes_read == -1) {
+        int const rc = read (inpos, bufsize);
+        if (rc == 0) {
             error ();
             return;
         }
+        if (rc == -1) {
+            if (errno != EAGAIN)
+                error ();
+            return;
+        }
 
         //  Adjust input size
-        insize = static_cast <size_t> (bytes_read);
+        insize = static_cast <size_t> (rc);
     }
 
     int rc = 0;
@@ -252,7 +257,7 @@ void zmq::stream_engine_t::in_event ()
             error ();
             return;
         }
-        input_paused = true;
+        input_stopped = true;
         reset_pollin (handle);
     }
 
@@ -291,7 +296,7 @@ void zmq::stream_engine_t::out_event ()
 
         //  If there is no data to send, stop polling for output.
         if (outsize == 0) {
-            output_paused = true;
+            output_stopped = true;
             reset_pollout (handle);
             return;
         }
@@ -328,14 +333,14 @@ void zmq::stream_engine_t::out_event ()
             terminate ();
 }
 
-void zmq::stream_engine_t::activate_out ()
+void zmq::stream_engine_t::restart_output ()
 {
     if (unlikely (io_error))
         return;
 
-    if (likely (output_paused)) {
+    if (likely (output_stopped)) {
         set_pollout (handle);
-        output_paused = false;
+        output_stopped = false;
     }
 
     //  Speculative write: The assumption is that at the moment new message
@@ -345,9 +350,9 @@ void zmq::stream_engine_t::activate_out ()
     out_event ();
 }
 
-void zmq::stream_engine_t::activate_in ()
+void zmq::stream_engine_t::restart_input ()
 {
-    zmq_assert (input_paused);
+    zmq_assert (input_stopped);
     zmq_assert (session != NULL);
     zmq_assert (decoder != NULL);
 
@@ -379,7 +384,7 @@ void zmq::stream_engine_t::activate_in ()
     if (rc == -1 || io_error)
         error ();
     else {
-        input_paused = false;
+        input_stopped = false;
         set_pollin (handle);
         session->flush ();
 
@@ -396,12 +401,15 @@ bool zmq::stream_engine_t::handshake ()
     while (greeting_bytes_read < greeting_size) {
         const int n = read (greeting_recv + greeting_bytes_read,
                             greeting_size - greeting_bytes_read);
-        if (n == -1) {
+        if (n == 0) {
             error ();
             return false;
         }
-        if (n == 0)
+        if (n == -1) {
+            if (errno != EAGAIN)
+                error ();
             return false;
+        }
 
         greeting_bytes_read += n;
 
@@ -480,6 +488,13 @@ bool zmq::stream_engine_t::handshake ()
         //  header data away.
         const size_t header_size = options.identity_size + 1 >= 255 ? 10 : 2;
         unsigned char tmp [10], *bufferp = tmp;
+
+        //  Prepare the identity message and load it into encoder.
+        //  Then consume bytes we have already sent to the peer.
+        const int rc = tx_msg.init_size (options.identity_size);
+        zmq_assert (rc == 0);
+        memcpy (tx_msg.data (), options.identity, options.identity_size);
+        encoder->load_msg (&tx_msg);
         size_t buffer_size = encoder->encode (&bufferp, header_size);
         zmq_assert (buffer_size == header_size);
 
@@ -614,8 +629,8 @@ int zmq::stream_engine_t::process_handshake_command (msg_t *msg_)
     if (rc == 0) {
         if (mechanism->is_handshake_complete ())
             mechanism_ready ();
-        if (output_paused)
-            activate_out ();
+        if (output_stopped)
+            restart_output ();
     }
 
     return rc;
@@ -630,10 +645,10 @@ void zmq::stream_engine_t::zap_msg_available ()
         error ();
         return;
     }
-    if (input_paused)
-        activate_in ();
-    if (output_paused)
-        activate_out ();
+    if (input_stopped)
+        restart_input ();
+    if (output_stopped)
+        restart_output ();
 }
 
 void zmq::stream_engine_t::mechanism_ready ()
@@ -785,58 +800,45 @@ int zmq::stream_engine_t::read (void *data_, size_t size_)
 {
 #ifdef ZMQ_HAVE_WINDOWS
 
-    int nbytes = recv (s, (char*) data_, (int) size_, 0);
+    const int rc = recv (s, (char*) data_, (int) size_, 0);
 
     //  If not a single byte can be read from the socket in non-blocking mode
     //  we'll get an error (this may happen during the speculative read).
-    if (nbytes == SOCKET_ERROR && WSAGetLastError () == WSAEWOULDBLOCK)
-        return 0;
-
-    //  Connection failure.
-    if (nbytes == SOCKET_ERROR && (
-          WSAGetLastError () == WSAENETDOWN ||
-          WSAGetLastError () == WSAENETRESET ||
-          WSAGetLastError () == WSAECONNABORTED ||
-          WSAGetLastError () == WSAETIMEDOUT ||
-          WSAGetLastError () == WSAECONNRESET ||
-          WSAGetLastError () == WSAECONNREFUSED ||
-          WSAGetLastError () == WSAENOTCONN))
-        return -1;
-
-    wsa_assert (nbytes != SOCKET_ERROR);
-
-    //  Orderly shutdown by the other peer.
-    if (nbytes == 0)
-        return -1; 
+    if (rc == SOCKET_ERROR) {
+        if (WSAGetLastError () == WSAEWOULDBLOCK)
+            errno = EAGAIN;
+        else {
+            wsa_assert (WSAGetLastError () == WSAENETDOWN
+                     || WSAGetLastError () == WSAENETRESET
+                     || WSAGetLastError () == WSAECONNABORTED
+                     || WSAGetLastError () == WSAETIMEDOUT
+                     || WSAGetLastError () == WSAECONNRESET
+                     || WSAGetLastError () == WSAECONNREFUSED
+                     || WSAGetLastError () == WSAENOTCONN);
+            errno = wsa_error_to_errno (WSAGetLastError ());
+        }
+    }
 
-    return nbytes;
+    return rc == SOCKET_ERROR? -1: rc;
 
 #else
 
-    ssize_t nbytes = recv (s, data_, size_, 0);
+    const ssize_t rc = recv (s, data_, size_, 0);
 
     //  Several errors are OK. When speculative read is being done we may not
     //  be able to read a single byte from the socket. Also, SIGSTOP issued
     //  by a debugging tool can result in EINTR error.
-    if (nbytes == -1 && (errno == EAGAIN || errno == EWOULDBLOCK ||
-          errno == EINTR))
-        return 0;
-
-    //  Signalise peer failure.
-    if (nbytes == -1) {
+    if (rc == -1) {
         errno_assert (errno != EBADF
                    && errno != EFAULT
                    && errno != EINVAL
                    && errno != ENOMEM
                    && errno != ENOTSOCK);
-        return -1;
+        if (errno == EWOULDBLOCK || errno == EINTR)
+            errno = EAGAIN;
     }
 
-    //  Orderly shutdown by the peer.
-    if (nbytes == 0)
-        return -1;
-
-    return static_cast <int> (nbytes);
+    return static_cast <int> (rc);
 
 #endif
 }

data/ext/zeromq/src/stream_engine.hpp

@@ -60,8 +60,8 @@ namespace zmq
         void plug (zmq::io_thread_t *io_thread_,
            zmq::session_base_t *session_);
         void terminate ();
-        void activate_in ();
-        void activate_out ();
+        void restart_input ();
+        void restart_output ();
         void zap_msg_available ();
 
         //  i_poll_events interface implementation.
@@ -87,10 +87,9 @@ namespace zmq
         //  of error or orderly shutdown by the other peer -1 is returned.
         int write (const void *data_, size_t size_);
 
-        //  Reads data from the socket (up to 'size' bytes). Returns the number
-        //  of bytes actually read (even zero is to be considered to be
-        //  a success). In case of error or orderly shutdown by the other
-        //  peer -1 is returned.
+        //  Reads data from the socket (up to 'size' bytes).
+        //  Returns the number of bytes actually read or -1 on error.
+        //  Zero indicates the peer has closed the connection.
         int read (void *data_, size_t size_);
 
         int read_identity (msg_t *msg_);
@@ -179,10 +178,10 @@ namespace zmq
         mechanism_t *mechanism;
 
         //  True iff the engine couldn't consume the last decoded message.
-        bool input_paused;
+        bool input_stopped;
 
         //  True iff the engine doesn't have any message to encode.
-        bool output_paused;
+        bool output_stopped;
 
         // Socket
         zmq::socket_base_t *socket;

data/ext/zeromq/src/zmq_utils.cpp

@@ -142,15 +142,15 @@ char *zmq_z85_encode (char *dest, uint8_t *data, size_t size)
 
 uint8_t *zmq_z85_decode (uint8_t *dest, char *string)
 {
-    
     if (strlen (string) % 5 != 0) {
         errno = EINVAL;
         return NULL;
     }
     unsigned int byte_nbr = 0;
     unsigned int char_nbr = 0;
+    unsigned int string_len = strlen (string);
     uint32_t value = 0;
-    while (char_nbr < strlen (string)) {
+    while (char_nbr < string_len) {
         //  Accumulate value in base 85
         value = value * 85 + decoder [(uint8_t) string [char_nbr++] - 32];
         if (char_nbr % 5 == 0) {
@@ -173,7 +173,7 @@ uint8_t *zmq_z85_decode (uint8_t *dest, char *string)
 //  Returns 0 on success, -1 on failure, setting errno.
 //  Sets errno = ENOTSUP in the absence of libsodium.
 
-int zmq_curve_keypair (char* z85_public_key, char *z85_secret_key)
+int zmq_curve_keypair (char *z85_public_key, char *z85_secret_key)
 {
 #ifdef HAVE_LIBSODIUM
 #   if crypto_box_PUBLICKEYBYTES != 32 \
@@ -185,8 +185,9 @@ int zmq_curve_keypair (char* z85_public_key, char *z85_secret_key)
     uint8_t secret_key [32];
 
     int rc = crypto_box_keypair (public_key, secret_key);
-    // is there a sensible errno to set here?
-    if (rc) return rc;
+    //  Is there a sensible errno to set here?
+    if (rc)
+        return rc;
     
     zmq_z85_encode (z85_public_key, public_key, 32);
     zmq_z85_encode (z85_secret_key, secret_key, 32);

data/ext/zeromq/tests/Makefile.am

@@ -17,9 +17,9 @@ noinst_PROGRAMS = test_system \
                   test_immediate \
                   test_last_endpoint \
                   test_term_endpoint \
-                  test_linger \
                   test_monitor \
                   test_router_mandatory \
+                  test_router_raw_empty \
                   test_probe_router \
                   test_stream \
                   test_disconnect_inproc \
@@ -39,7 +39,8 @@ noinst_PROGRAMS = test_system \
                   test_conflate \
                   test_inproc_connect \
                   test_issue_566 \
-                  test_abstract_ipc
+                  test_abstract_ipc \
+                  test_many_sockets
 
 if !ON_MINGW
 noinst_PROGRAMS += test_shutdown_stress \
@@ -58,7 +59,6 @@ test_hwm_SOURCES = test_hwm.cpp
 test_reqrep_device_SOURCES = test_reqrep_device.cpp
 test_sub_forward_SOURCES = test_sub_forward.cpp
 test_invalid_rep_SOURCES = test_invalid_rep.cpp
-test_linger_SOURCES = test_linger.cpp
 test_msg_flags_SOURCES = test_msg_flags.cpp
 test_connect_resolve_SOURCES = test_connect_resolve.cpp
 test_immediate_SOURCES = test_immediate.cpp
@@ -66,6 +66,7 @@ test_last_endpoint_SOURCES = test_last_endpoint.cpp
 test_term_endpoint_SOURCES = test_term_endpoint.cpp
 test_monitor_SOURCES = test_monitor.cpp
 test_router_mandatory_SOURCES = test_router_mandatory.cpp
+test_router_raw_empty_SOURCES = test_router_raw_empty.cpp
 test_probe_router_SOURCES = test_probe_router.cpp
 test_stream_SOURCES = test_stream.cpp
 test_disconnect_inproc_SOURCES = test_disconnect_inproc.cpp
@@ -86,6 +87,7 @@ test_conflate_SOURCES = test_conflate.cpp
 test_inproc_connect_SOURCES = test_inproc_connect.cpp
 test_issue_566_SOURCES = test_issue_566.cpp
 test_abstract_ipc_SOURCES = test_abstract_ipc.cpp
+test_many_sockets_SOURCES = test_many_sockets.cpp
 if !ON_MINGW
 test_shutdown_stress_SOURCES = test_shutdown_stress.cpp
 test_pair_ipc_SOURCES = test_pair_ipc.cpp testutil.hpp
@@ -96,8 +98,7 @@ endif
 
 #  Run the test cases
 TESTS = $(noinst_PROGRAMS)
-XFAIL_TESTS = test_linger
 
 if !ON_LINUX
-XFAIL_TESTS += test_abstract_ipc
+XFAIL_TESTS = test_abstract_ipc
 endif