libzmq 0.0.1 → 0.2.0

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/pgm_receiver.cpp

@@ -60,8 +60,8 @@ int zmq::pgm_receiver_t::init (bool udp_encapsulation_, const char *network_)
 void zmq::pgm_receiver_t::plug (io_thread_t *io_thread_, i_inout *inout_)
 {
     //  Retrieve PGM fds and start polling.
-    int socket_fd;
-    int waiting_pipe_fd;
+    fd_t socket_fd = retired_fd;
+    fd_t waiting_pipe_fd = retired_fd;
     pgm_socket.get_receiver_fds (&socket_fd, &waiting_pipe_fd);
     socket_handle = add_fd (socket_fd);
     pipe_handle = add_fd (waiting_pipe_fd);

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/pgm_sender.cpp

@@ -64,10 +64,10 @@ int zmq::pgm_sender_t::init (bool udp_encapsulation_, const char *network_)
 void zmq::pgm_sender_t::plug (io_thread_t *io_thread_, i_inout *inout_)
 {
     //  Alocate 2 fds for PGM socket.
-    int downlink_socket_fd = 0;
-    int uplink_socket_fd = 0;
-    int rdata_notify_fd = 0;
-    int pending_notify_fd = 0;
+    fd_t downlink_socket_fd = retired_fd;
+    fd_t uplink_socket_fd = retired_fd;
+    fd_t rdata_notify_fd = retired_fd;
+    fd_t pending_notify_fd = retired_fd;
 
     encoder.set_inout (inout_);
 

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/pgm_socket.cpp

@@ -394,8 +394,8 @@ zmq::pgm_socket_t::~pgm_socket_t ()
 
 //  Get receiver fds. receive_fd_ is signaled for incoming packets,
 //  waiting_pipe_fd_ is signaled for state driven events and data.
-void zmq::pgm_socket_t::get_receiver_fds (int *receive_fd_, 
-    int *waiting_pipe_fd_)
+void zmq::pgm_socket_t::get_receiver_fds (fd_t *receive_fd_, 
+    fd_t *waiting_pipe_fd_)
 {
     socklen_t socklen;
     bool rc;
@@ -421,8 +421,8 @@ void zmq::pgm_socket_t::get_receiver_fds (int *receive_fd_,
 //  receive_fd_ is for incoming back-channel protocol packets.
 //  rdata_notify_fd_ is raised for waiting repair transmissions.
 //  pending_notify_fd_ is for state driven events.
-void zmq::pgm_socket_t::get_sender_fds (int *send_fd_, int *receive_fd_, 
-    int *rdata_notify_fd_, int *pending_notify_fd_)
+void zmq::pgm_socket_t::get_sender_fds (fd_t *send_fd_, fd_t *receive_fd_, 
+    fd_t *rdata_notify_fd_, fd_t *pending_notify_fd_)
 {
     socklen_t socklen;
     bool rc;

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/pgm_socket.hpp

@@ -36,6 +36,7 @@
 #include <pgm/in.h>
 #endif
 
+#include "fd.hpp"
 #include "options.hpp"
 
 namespace zmq
@@ -56,12 +57,12 @@ namespace zmq
         int init (bool udp_encapsulation_, const char *network_);
         
         //   Get receiver fds and store them into user allocated memory.
-        void get_receiver_fds (int *receive_fd_, int *waiting_pipe_fd_);
+        void get_receiver_fds (fd_t *receive_fd_, fd_t *waiting_pipe_fd_);
 
         //   Get sender and receiver fds and store it to user allocated 
         //   memory. Receive fd is used to process NAKs from peers.
-        void get_sender_fds (int *send_fd_, int *receive_fd_,
-            int *rdata_notify_fd_, int *pending_notify_fd_);
+        void get_sender_fds (fd_t *send_fd_, fd_t *receive_fd_,
+            fd_t *rdata_notify_fd_, fd_t *pending_notify_fd_);
 
         //  Send data as one APDU, transmit window owned memory.
         size_t send (unsigned char *data_, size_t data_len_);

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/platform.hpp.in

@@ -160,6 +160,9 @@
 /* Have AIX OS */
 #undef ZMQ_HAVE_AIX
 
+/* Have Android OS */
+#undef ZMQ_HAVE_ANDROID
+
 /* Have Cygwin */
 #undef ZMQ_HAVE_CYGWIN
 

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/reaper.cpp

@@ -61,7 +61,7 @@ void zmq::reaper_t::in_event ()
 
         //  Get the next command. If there is none, exit.
         command_t cmd;
-        int rc = mailbox.recv (&cmd, false);
+        int rc = mailbox.recv (&cmd, 0);
         if (rc != 0 && errno == EINTR)
             continue;
         if (rc != 0 && errno == EAGAIN)

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/rep.cpp

@@ -85,7 +85,7 @@ int zmq::rep_t::xrecv (zmq_msg_t *msg_, int flags_)
 
                 //  Push it to the reply pipe.
                 rc = xrep_t::xsend (msg_, flags_);
-                zmq_assert (rc == 0);
+                errno_assert (rc == 0);
             }
             else {
                 //  If the traceback stack is malformed, discard anything

data/libzmq/{zeromq-2.1.7 → zeromq-2.1.9}/src/select.cpp

@@ -19,20 +19,21 @@
 */
 
 #include "platform.hpp"
+#if defined ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#endif
 
 #include <string.h>
 #include <algorithm>
 
-#ifdef ZMQ_HAVE_WINDOWS
-#include "winsock2.h"
-#elif defined ZMQ_HAVE_HPUX
+#if defined ZMQ_HAVE_HPUX
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #elif defined ZMQ_HAVE_OPENVMS
 #include <sys/types.h>
 #include <sys/time.h>
-#else
+#elif !defined ZMQ_HAVE_WINDOWS
 #include <sys/select.h>
 #endif
 

data/libzmq/{zeromq-2.1.7/src/mailbox.cpp → zeromq-2.1.9/src/signaler.cpp}

@@ -18,8 +18,45 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "mailbox.hpp"
 #include "platform.hpp"
+
+#if defined ZMQ_FORCE_SELECT
+#define ZMQ_SIGNALER_WAIT_BASED_ON_SELECT
+#elif defined ZMQ_FORCE_POLL
+#define ZMQ_SIGNALER_WAIT_BASED_ON_POLL
+#elif defined ZMQ_HAVE_LINUX || defined ZMQ_HAVE_FREEBSD ||\
+    defined ZMQ_HAVE_OPENBSD || defined ZMQ_HAVE_SOLARIS ||\
+    defined ZMQ_HAVE_OSX || defined ZMQ_HAVE_QNXNTO ||\
+    defined ZMQ_HAVE_HPUX || defined ZMQ_HAVE_AIX ||\
+    defined ZMQ_HAVE_NETBSD
+#define ZMQ_SIGNALER_WAIT_BASED_ON_POLL
+#elif defined ZMQ_HAVE_WINDOWS || defined ZMQ_HAVE_OPENVMS
+#define ZMQ_SIGNALER_WAIT_BASED_ON_SELECT
+#endif
+
+//  On AIX, poll.h has to be included before zmq.h to get consistent
+//  definition of pollfd structure (AIX uses 'reqevents' and 'retnevents'
+//  instead of 'events' and 'revents' and defines macros to map from POSIX-y
+//  names to AIX-specific names).
+#if defined ZMQ_SIGNALER_WAIT_BASED_ON_POLL
+#include <poll.h>
+#elif defined ZMQ_SIGNALER_WAIT_BASED_ON_SELECT
+#if defined ZMQ_HAVE_WINDOWS
+#include "windows.hpp"
+#elif defined ZMQ_HAVE_HPUX
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#elif defined ZMQ_HAVE_OPENVMS
+#include <sys/types.h>
+#include <sys/time.h>
+#else
+#include <sys/select.h>
+#endif
+#endif
+
+#include "signaler.hpp"
+#include "likely.hpp"
 #include "err.hpp"
 #include "fd.hpp"
 #include "ip.hpp"
@@ -36,111 +73,24 @@
 #include <sys/socket.h>
 #endif
 
-zmq::fd_t zmq::mailbox_t::get_fd ()
+zmq::signaler_t::signaler_t ()
 {
-    return r;
-}
-
-#if defined ZMQ_HAVE_WINDOWS
-
-zmq::mailbox_t::mailbox_t ()
-{
-    //  Create the socketpair for signalling.
-    int rc = make_socketpair (&r, &w);
+    //  Create the socketpair for signaling.
+    int rc = make_fdpair (&r, &w);
     errno_assert (rc == 0);
 
-    //  Set the writer to non-blocking mode.
+    //  Set both fds to non-blocking mode.
+#if defined ZMQ_HAVE_WINDOWS
     unsigned long argp = 1;
     rc = ioctlsocket (w, FIONBIO, &argp);
     wsa_assert (rc != SOCKET_ERROR);
-
-    //  Set the reader to non-blocking mode.
-    argp = 1;
     rc = ioctlsocket (r, FIONBIO, &argp);
     wsa_assert (rc != SOCKET_ERROR);
-}
-
-zmq::mailbox_t::~mailbox_t ()
-{
-    int rc = closesocket (w);
-    wsa_assert (rc != SOCKET_ERROR);
-
-    rc = closesocket (r);
-    wsa_assert (rc != SOCKET_ERROR);
-}
-
-void zmq::mailbox_t::send (const command_t &cmd_)
-{
-    //  TODO: Implement SNDBUF auto-resizing as for POSIX platforms.
-    //  In the mean time, the following code with assert if the send()
-    //  call would block.
-    int nbytes = ::send (w, (char *)&cmd_, sizeof (command_t), 0);
-    wsa_assert (nbytes != SOCKET_ERROR);
-    zmq_assert (nbytes == sizeof (command_t));
-}
-
-int zmq::mailbox_t::recv (command_t *cmd_, bool block_)
-{
-    //  If required, set the reader to blocking mode.
-    if (block_) {
-        unsigned long argp = 0;
-        int rc = ioctlsocket (r, FIONBIO, &argp);
-        wsa_assert (rc != SOCKET_ERROR);
-    }
-
-    //  Attempt to read an entire command. Returns EAGAIN if non-blocking
-    //  and a command is not available. Save value of errno if we wish to pass
-    //  it to caller.
-    int err = 0;
-    int nbytes = ::recv (r, (char *)cmd_, sizeof (command_t), 0);
-    if (nbytes == -1 && WSAGetLastError () == WSAEWOULDBLOCK)
-        err = EAGAIN;
-
-    //  Re-set the reader to non-blocking mode.
-    if (block_) {
-        unsigned long argp = 1;
-        int rc = ioctlsocket (r, FIONBIO, &argp);
-        wsa_assert (rc != SOCKET_ERROR);
-    }
-
-    //  If the recv failed, return with the saved errno.
-    if (err != 0) {
-        errno = err;
-        return -1;
-    }
-
-    //  Sanity check for success.
-    wsa_assert (nbytes != SOCKET_ERROR);
-
-    //  Check whether we haven't got half of command.
-    zmq_assert (nbytes == sizeof (command_t));
-
-    return 0;
-}
-
 #else
-
-zmq::mailbox_t::mailbox_t ()
-{
-#ifdef PIPE_BUF
-    //  Make sure that command can be written to the socket in atomic fashion.
-    //  If this wasn't guaranteed, commands from different threads would be
-    //  interleaved.
-    zmq_assert (sizeof (command_t) <= PIPE_BUF);
-#endif
-
-    //  Create the socketpair for signaling.
-    int rc = make_socketpair (&r, &w);
-    errno_assert (rc == 0);
-
-    //  Set the writer to non-blocking mode.
     int flags = fcntl (w, F_GETFL, 0);
     errno_assert (flags >= 0);
     rc = fcntl (w, F_SETFL, flags | O_NONBLOCK);
     errno_assert (rc == 0);
-
-#ifndef MSG_DONTWAIT
-    //  Set the reader to non-blocking mode.
     flags = fcntl (r, F_GETFL, 0);
     errno_assert (flags >= 0);
     rc = fcntl (r, F_SETFL, flags | O_NONBLOCK);
@@ -148,108 +98,113 @@ zmq::mailbox_t::mailbox_t ()
 #endif
 }
 
-zmq::mailbox_t::~mailbox_t ()
+zmq::signaler_t::~signaler_t ()
 {
+#if defined ZMQ_HAVE_WINDOWS
+    int rc = closesocket (w);
+    wsa_assert (rc != SOCKET_ERROR);
+    rc = closesocket (r);
+    wsa_assert (rc != SOCKET_ERROR);
+#else
     close (w);
     close (r);
+#endif
 }
 
-void zmq::mailbox_t::send (const command_t &cmd_)
+zmq::fd_t zmq::signaler_t::get_fd ()
 {
-    //  Attempt to write an entire command without blocking.
-    ssize_t nbytes;
-    do {
-        nbytes = ::send (w, &cmd_, sizeof (command_t), 0);
-    } while (nbytes == -1 && errno == EINTR);
-
-    //  Attempt to increase mailbox SNDBUF if the send failed.
-    if (nbytes == -1 && errno == EAGAIN) {
-        int old_sndbuf, new_sndbuf;
-        socklen_t sndbuf_size = sizeof old_sndbuf;
-
-        //  Retrieve current send buffer size.
-        int rc = getsockopt (w, SOL_SOCKET, SO_SNDBUF, &old_sndbuf,
-            &sndbuf_size);
-        errno_assert (rc == 0);
-        new_sndbuf = old_sndbuf * 2;
-
-        //  Double the new send buffer size.
-        rc = setsockopt (w, SOL_SOCKET, SO_SNDBUF, &new_sndbuf, sndbuf_size);
-        errno_assert (rc == 0);
-
-        //  Verify that the OS actually honored the request.
-        rc = getsockopt (w, SOL_SOCKET, SO_SNDBUF, &new_sndbuf, &sndbuf_size);
-        errno_assert (rc == 0);
-        zmq_assert (new_sndbuf > old_sndbuf);
-
-        //  Retry the sending operation; at this point it must succeed.
-        do {
-            nbytes = ::send (w, &cmd_, sizeof (command_t), 0);
-        } while (nbytes == -1 && errno == EINTR);
-    }
-    errno_assert (nbytes != -1);
-
-    //  This should never happen as we've already checked that command size is
-    //  less than PIPE_BUF.
-    zmq_assert (nbytes == sizeof (command_t));
+    return r;
 }
 
-int zmq::mailbox_t::recv (command_t *cmd_, bool block_)
+void zmq::signaler_t::send ()
 {
-#ifdef MSG_DONTWAIT
-
-    //  Attempt to read an entire command. Returns EAGAIN if non-blocking
-    //  mode is requested and a command is not available.
-    ssize_t nbytes = ::recv (r, cmd_, sizeof (command_t),
-        block_ ? 0 : MSG_DONTWAIT);
-    if (nbytes == -1 && (errno == EAGAIN || errno == EINTR))
-        return -1;
+#if defined ZMQ_HAVE_WINDOWS
+    unsigned char dummy = 0;
+    int nbytes = ::send (w, (char*) &dummy, sizeof (dummy), 0);
+    wsa_assert (nbytes != SOCKET_ERROR);
+    zmq_assert (nbytes == sizeof (dummy));
 #else
-
-    //  If required, set the reader to blocking mode.
-    if (block_) {
-        int flags = fcntl (r, F_GETFL, 0);
-        errno_assert (flags >= 0);
-        int rc = fcntl (r, F_SETFL, flags & ~O_NONBLOCK);
-        errno_assert (rc == 0);
+    unsigned char dummy = 0;
+    while (true) {
+        ssize_t nbytes = ::send (w, &dummy, sizeof (dummy), 0);
+        if (unlikely (nbytes == -1 && errno == EINTR))
+            continue;
+        zmq_assert (nbytes == sizeof (dummy));
+        break;
     }
+#endif
+}
 
-    //  Attempt to read an entire command. Returns EAGAIN if non-blocking
-    //  and a command is not available. Save value of errno if we wish to pass
-    //  it to caller.
-    int err = 0;
-    ssize_t nbytes = ::recv (r, cmd_, sizeof (command_t), 0);
-    if (nbytes == -1 && (errno == EAGAIN || errno == EINTR))  
-        err = errno;
-
-    //  Re-set the reader to non-blocking mode.
-    if (block_) {
-        int flags = fcntl (r, F_GETFL, 0);
-        errno_assert (flags >= 0);
-        int rc = fcntl (r, F_SETFL, flags | O_NONBLOCK);
-        errno_assert (rc == 0);
+int zmq::signaler_t::wait (int timeout_)
+{
+#ifdef ZMQ_SIGNALER_WAIT_BASED_ON_POLL
+
+    struct pollfd pfd;
+    pfd.fd = r;
+    pfd.events = POLLIN;
+    int rc = poll (&pfd, 1, timeout_);
+    if (unlikely (rc < 0)) {
+        zmq_assert (errno == EINTR);
+        return -1;
     }
-
-    //  If the recv failed, return with the saved errno if set.
-    if (err != 0) {
-        errno = err;
+    else if (unlikely (rc == 0)) {
+        errno = EAGAIN;
         return -1;
     }
+    zmq_assert (rc == 1);
+    zmq_assert (pfd.revents & POLLIN);
+    return 0;
 
-#endif
-
-    //  Sanity check for success.
-    errno_assert (nbytes != -1);
-
-    //  Check whether we haven't got half of command.
-    zmq_assert (nbytes == sizeof (command_t));
+#elif defined ZMQ_SIGNALER_WAIT_BASED_ON_SELECT
 
+    fd_set fds;
+    FD_ZERO (&fds);
+    FD_SET (r, &fds);
+    struct timeval timeout;
+    if (timeout_ >= 0) {
+        timeout.tv_sec = timeout_ / 1000;
+        timeout.tv_usec = timeout_ % 1000 * 1000;
+    }
+#ifdef ZMQ_HAVE_WINDOWS
+    int rc = select (0, &fds, NULL, NULL,
+        timeout_ >= 0 ? &timeout : NULL);
+    wsa_assert (rc != SOCKET_ERROR);
+#else
+    int rc = select (r + 1, &fds, NULL, NULL,
+        timeout_ >= 0 ? &timeout : NULL);
+    if (unlikely (rc < 0)) {
+        zmq_assert (errno == EINTR);
+        return -1;
+    }
+#endif
+    if (unlikely (rc == 0)) {
+        errno = EAGAIN;
+        return -1;
+    }
+    zmq_assert (rc == 1);
     return 0;
+
+#else
+#error
+#endif
 }
 
+void zmq::signaler_t::recv ()
+{
+    //  Attempt to read a signal.
+    unsigned char dummy;
+#ifdef ZMQ_HAVE_WINDOWS
+    int nbytes = ::recv (r, (char*) &dummy, sizeof (dummy), 0);
+    wsa_assert (nbytes != SOCKET_ERROR);
+#else
+    ssize_t nbytes = ::recv (r, &dummy, sizeof (dummy), 0);
+    errno_assert (nbytes >= 0);
 #endif
+    zmq_assert (nbytes == sizeof (dummy));
+    zmq_assert (dummy == 0);
+}
 
-int zmq::mailbox_t::make_socketpair (fd_t *r_, fd_t *w_)
+int zmq::signaler_t::make_fdpair (fd_t *r_, fd_t *w_)
 {
 #if defined ZMQ_HAVE_WINDOWS
 
@@ -380,3 +335,10 @@ int zmq::mailbox_t::make_socketpair (fd_t *r_, fd_t *w_)
 #endif
 }
 
+#if defined ZMQ_SIGNALER_WAIT_BASED_ON_SELECT
+#undef ZMQ_SIGNALER_WAIT_BASED_ON_SELECT
+#endif
+#if defined ZMQ_SIGNALER_WAIT_BASED_ON_POLL
+#undef ZMQ_SIGNALER_WAIT_BASED_ON_POLL
+#endif
+