libzmq 0.0.1 → 0.2.0

data/libzmq/zeromq-2.1.9/src/signaler.hpp

@@ -0,0 +1,63 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other 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/>.
+*/
+
+#ifndef __ZMQ_SIGNALER_HPP_INCLUDED__
+#define __ZMQ_SIGNALER_HPP_INCLUDED__
+
+#include "fd.hpp"
+
+namespace zmq
+{
+
+    //  This is a cross-platform equivalent to signal_fd. However, as opposed
+    //  to signal_fd there can be at most one signal in the signaler at any
+    //  given moment. Attempt to send a signal before receiving the previous
+    //  one will result in undefined behaviour.
+
+    class signaler_t
+    {
+    public:
+
+        signaler_t ();
+        ~signaler_t ();
+
+        fd_t get_fd ();
+        void send ();
+        int wait (int timeout_);
+        void recv ();
+        
+    private:
+
+        //  Creates a pair of filedescriptors that will be used
+        //  to pass the signals.
+        static int make_fdpair (fd_t *r_, fd_t *w_);
+
+        //  Write & read end of the socketpair.
+        fd_t w;
+        fd_t r;
+
+        //  Disable copying of signaler_t object.
+        signaler_t (const signaler_t&);
+        const signaler_t &operator = (const signaler_t&);
+    };
+
+}
+
+#endif

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

@@ -277,7 +277,7 @@ int zmq::socket_base_t::getsockopt (int option_, void *optval_,
             errno = EINVAL;
             return -1;
         }
-        int rc = process_commands (false, false);
+        int rc = process_commands (0, false);
         if (rc != 0 && (errno == EINTR || errno == ETERM))
             return -1;
         errno_assert (rc == 0);
@@ -480,7 +480,7 @@ int zmq::socket_base_t::send (::zmq_msg_t *msg_, int flags_)
     }
 
     //  Process pending commands, if any.
-    int rc = process_commands (false, true);
+    int rc = process_commands (0, true);
     if (unlikely (rc != 0))
         return -1;
 
@@ -492,20 +492,37 @@ int zmq::socket_base_t::send (::zmq_msg_t *msg_, int flags_)
     rc = xsend (msg_, flags_);
     if (rc == 0)
         return 0;
+    if (unlikely (errno != EAGAIN))
+        return -1;
 
     //  In case of non-blocking send we'll simply propagate
     //  the error - including EAGAIN - upwards.
     if (flags_ & ZMQ_NOBLOCK)
         return -1;
 
+    //  Compute the time when the timeout should occur.
+    //  If the timeout is infite, don't care. 
+    clock_t clock ;
+    int timeout = -1;
+    uint64_t end = timeout < 0 ? 0 : (clock.now_ms () + timeout);
+
     //  Oops, we couldn't send the message. Wait for the next
     //  command, process it and try to send the message again.
-    while (rc != 0) {
-        if (errno != EAGAIN)
-            return -1;
-        if (unlikely (process_commands (true, false) != 0))
+    while (true) {
+        if (unlikely (process_commands (timeout, false) != 0))
             return -1;
         rc = xsend (msg_, flags_);
+        if (rc == 0)
+            break;
+        if (unlikely (errno != EAGAIN))
+            return -1;
+        if (timeout > 0) {
+            timeout = (int) (end - clock.now_ms ());
+            if (timeout <= 0) {
+                errno = EAGAIN;
+                return -1;
+            }
+        }
     }
     return 0;
 }
@@ -526,6 +543,8 @@ int zmq::socket_base_t::recv (::zmq_msg_t *msg_, int flags_)
 
     //  Get the message.
     int rc = xrecv (msg_, flags_);
+    if (unlikely (rc != 0 && errno != EAGAIN))
+        return -1;
     int err = errno;
 
     //  Once every inbound_poll_rate messages check for signals and process
@@ -537,7 +556,7 @@ int zmq::socket_base_t::recv (::zmq_msg_t *msg_, int flags_)
     //  described above) from the one used by 'send'. This is because counting
     //  ticks is more efficient than doing RDTSC all the time.
     if (++ticks == inbound_poll_rate) {
-        if (unlikely (process_commands (false, false) != 0))
+        if (unlikely (process_commands (0, false) != 0))
             return -1;
         ticks = 0;
     }
@@ -560,7 +579,7 @@ int zmq::socket_base_t::recv (::zmq_msg_t *msg_, int flags_)
     if (flags_ & ZMQ_NOBLOCK) {
         if (errno != EAGAIN)
             return -1;
-        if (unlikely (process_commands (false, false) != 0))
+        if (unlikely (process_commands (0, false) != 0))
             return -1;
         ticks = 0;
 
@@ -573,17 +592,33 @@ int zmq::socket_base_t::recv (::zmq_msg_t *msg_, int flags_)
         return rc;
     }
 
+    //  Compute the time when the timeout should occur.
+    //  If the timeout is infite, don't care. 
+    clock_t clock ;
+    int timeout = -1;
+    uint64_t end = timeout < 0 ? 0 : (clock.now_ms () + timeout);
+
     //  In blocking scenario, commands are processed over and over again until
     //  we are able to fetch a message.
     bool block = (ticks != 0);
-    while (rc != 0) {
-        if (errno != EAGAIN)
-            return -1;
-        if (unlikely (process_commands (block, false) != 0))
+    while (true) {
+        if (unlikely (process_commands (block ? timeout : 0, false) != 0))
             return -1;
         rc = xrecv (msg_, flags_);
-        ticks = 0;
+        if (rc == 0) {
+            ticks = 0;
+            break;
+        }
+        if (unlikely (errno != EAGAIN))
+            return -1;
         block = true;
+        if (timeout > 0) {
+            timeout = (int) (end - clock.now_ms ());
+            if (timeout <= 0) {
+                errno = EAGAIN;
+                return -1;
+            }
+        }
     }
 
     rcvmore = msg_->flags & ZMQ_MSG_MORE;
@@ -655,18 +690,20 @@ void zmq::socket_base_t::start_reaping (poller_t *poller_)
     poller->set_pollin (handle);
 }
 
-int zmq::socket_base_t::process_commands (bool block_, bool throttle_)
+int zmq::socket_base_t::process_commands (int timeout_, bool throttle_)
 {
     int rc;
     command_t cmd;
-    if (block_) {
-        rc = mailbox.recv (&cmd, true);
-        if (rc == -1 && errno == EINTR)
-            return -1;
-        errno_assert (rc == 0);
+    if (timeout_ != 0) {
+
+        //  If we are asked to wait, simply ask mailbox to wait.
+        rc = mailbox.recv (&cmd, timeout_);
     }
     else {
 
+        //  If we are asked not to wait, check whether we haven't processed
+        //  commands recently, so that we can throttle the new commands.
+
         //  Get the CPU's tick counter. If 0, the counter is not available.
         uint64_t tsc = zmq::clock_t::rdtsc ();
 
@@ -687,7 +724,7 @@ int zmq::socket_base_t::process_commands (bool block_, bool throttle_)
         }
 
         //  Check whether there are any commands pending for this thread.
-        rc = mailbox.recv (&cmd, false);
+        rc = mailbox.recv (&cmd, 0);
     }
 
     //  Process all the commands available at the moment.
@@ -698,7 +735,7 @@ int zmq::socket_base_t::process_commands (bool block_, bool throttle_)
             return -1;
         errno_assert (rc == 0);
         cmd.destination->process_command (cmd);
-        rc = mailbox.recv (&cmd, false);
+        rc = mailbox.recv (&cmd, 0);
      }
 
     if (ctx_terminated) {

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

@@ -162,11 +162,11 @@ namespace zmq
         void attach_pipes (class reader_t *inpipe_, class writer_t *outpipe_,
             const blob_t &peer_identity_);
 
-        //  Processes commands sent to this socket (if any). If 'block' is
-        //  set to true, returns only after at least one command was processed.
+        //  Processes commands sent to this socket (if any). If timeout is -1,
+        //  returns only after at least one command was processed.
         //  If throttle argument is true, commands are processed at most once
         //  in a predefined time period.
-        int process_commands (bool block_, bool throttle_);
+        int process_commands (int timeout_, bool throttle_);
 
         //  Handlers for incoming commands.
         void process_stop ();

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

@@ -111,7 +111,7 @@ int zmq::swap_t::init ()
     if (fd == -1)
         return -1;
 
-#ifdef ZMQ_HAVE_LINUX
+#if (defined (ZMQ_HAVE_LINUX) && !defined (ZMQ_HAVE_ANDROID))
     //  Enable more aggresive read-ahead optimization.
     posix_fadvise (fd, 0, filesize, POSIX_FADV_SEQUENTIAL);
 #endif
@@ -135,8 +135,6 @@ bool zmq::swap_t::store (zmq_msg_t *msg_)
     copy_to_file (&msg_flags, sizeof msg_flags);
     copy_to_file (zmq_msg_data (msg_), msg_size);
 
-    zmq_msg_close (msg_);
-
     return true;
 }
 
@@ -214,7 +212,7 @@ void zmq::swap_t::copy_from_file (void *buffer_, size_t count_)
     size_t chunk_size, remainder = count_;
 
     while (remainder > 0) {
-        chunk_size = std::min (remainder, 
+        chunk_size = std::min (remainder,
             std::min ((size_t) (filesize - read_pos),
             (size_t) (block_size - read_pos % block_size)));
 
@@ -238,7 +236,7 @@ void zmq::swap_t::copy_to_file (const void *buffer_, size_t count_)
     size_t chunk_size, remainder = count_;
 
     while (remainder > 0) {
-        chunk_size = std::min (remainder, 
+        chunk_size = std::min (remainder,
             std::min ((size_t) (filesize - write_pos),
             (size_t) (block_size - write_pos % block_size)));
 

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

@@ -297,7 +297,8 @@ zmq::fd_t zmq::tcp_connecter_t::connect ()
         //  Networking problems are OK. No need to assert.
         errno = err;
         errno_assert (errno == ECONNREFUSED || errno == ECONNRESET ||
-            errno == ETIMEDOUT || errno == EHOSTUNREACH);
+            errno == ETIMEDOUT || errno == EHOSTUNREACH ||
+            errno == ENETUNREACH);
 
         return retired_fd;
     }

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

@@ -162,6 +162,11 @@ int zmq::tcp_socket_t::open (fd_t fd_, uint64_t sndbuf_, uint64_t rcvbuf_)
         errno_assert (rc == 0);
     }
 
+#if defined ZMQ_HAVE_OSX || defined ZMQ_HAVE_FREEBSD
+    int set = 1;
+    int rc = setsockopt (s, SOL_SOCKET, SO_NOSIGPIPE, &set, sizeof (int));
+    errno_assert (rc == 0);
+#endif
     return 0;
 }
 

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

@@ -40,7 +40,7 @@ void zmq::thread_t::start (thread_fn *tfn_, void *arg_)
     arg =arg_;
     descriptor = (HANDLE) _beginthreadex (NULL, 0,
         &::thread_routine, this, 0 , NULL);
-    win_assert (descriptor != NULL);    
+    win_assert (descriptor != NULL);
 }
 
 void zmq::thread_t::stop ()
@@ -59,17 +59,19 @@ extern "C"
 {
     static void *thread_routine (void *arg_)
     {
-    #if !defined ZMQ_HAVE_OPENVMS
+#if !defined ZMQ_HAVE_OPENVMS
         //  Following code will guarantee more predictable latecnies as it'll
         //  disallow any signal handling in the I/O thread.
         sigset_t signal_set;
         int rc = sigfillset (&signal_set);
         errno_assert (rc == 0);
+#   if !defined ZMQ_HAVE_ANDROID
         rc = pthread_sigmask (SIG_BLOCK, &signal_set, NULL);
-        errno_assert (rc == 0);
-    #endif
+        posix_assert (rc);
+#   endif
+#endif
 
-        zmq::thread_t *self = (zmq::thread_t*) arg_;   
+        zmq::thread_t *self = (zmq::thread_t*) arg_;
         self->tfn (self->arg);
         return NULL;
     }
@@ -80,13 +82,13 @@ void zmq::thread_t::start (thread_fn *tfn_, void *arg_)
     tfn = tfn_;
     arg =arg_;
     int rc = pthread_create (&descriptor, NULL, thread_routine, this);
-    errno_assert (rc == 0);
+    posix_assert (rc);
 }
 
 void zmq::thread_t::stop ()
 {
     int rc = pthread_join (descriptor, NULL);
-    errno_assert (rc == 0);
+    posix_assert (rc);
 }
 
 #endif

data/libzmq/zeromq-2.1.9/src/windows.hpp

@@ -0,0 +1,177 @@
+/*
+    Copyright (c) 2007-2011 iMatix Corporation
+    Copyright (c) 2007-2011 Other 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/>.
+*/
+
+#ifndef __ZMQ_WINDOWS_HPP_INCLUDED__
+#define __ZMQ_WINDOWS_HPP_INCLUDED__
+
+// The purpose of this header file is to turn on only the items actually needed
+// on the windows platform.
+
+// Disable deprecation warning.
+#define _CRT_SECURE_NO_WARNINGS
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOGDICAPMASKS
+#define NOGDICAPMASKS // CC_*, LC_*, PC_*, CP_*, TC_*, RC_
+#endif
+#ifndef NOVIRTUALKEYCODES
+#define NOVIRTUALKEYCODES // VK_*
+#endif
+#ifndef NOWINMESSAGES
+#define NOWINMESSAGES     // WM_*, EM_*, LB_*, CB_*
+#endif
+#ifndef NOWINSTYLES
+#define NOWINSTYLES       // WS_*, CS_*, ES_*, LBS_*, SBS_*, CBS_*
+#endif
+#ifndef NOSYSMETRICS
+#define NOSYSMETRICS      // SM_*
+#endif
+#ifndef NOMENUS
+#define NOMENUS           // MF_*
+#endif
+#ifndef NOICONS
+#define NOICONS           // IDI_*
+#endif
+#ifndef NOKEYSTATES
+#define NOKEYSTATES       // MK_*
+#endif
+#ifndef NOSYSCOMMANDS
+#define NOSYSCOMMANDS     // SC_*
+#endif
+#ifndef NORASTEROPS
+#define NORASTEROPS       // Binary and Tertiary raster ops
+#endif
+#ifndef NOSHOWWINDOW
+#define NOSHOWWINDOW      // SW_*
+#endif
+#ifndef OEMRESOURCE
+#define OEMRESOURCE       // OEM Resource values
+#endif
+#ifndef NOATOM
+#define NOATOM            // Atom Manager routines
+#endif
+#ifndef NOCLIPBOARD
+#define NOCLIPBOARD       // Clipboard routines
+#endif
+#ifndef NOCOLOR
+#define NOCOLOR           // Screen colors
+#endif
+#ifndef NOCTLMGR
+#define NOCTLMGR          // Control and Dialog routines
+#endif
+#ifndef NODRAWTEXT
+#define NODRAWTEXT        // DrawText() and DT_*
+#endif
+#ifndef NOGDI
+#define NOGDI             // All GDI defines and routines
+#endif
+#ifndef NOKERNEL
+#define NOKERNEL          // All KERNEL defines and routines
+#endif
+#ifndef NOUSER
+#define NOUSER            // All USER defines and routines
+#endif
+#ifndef NONLS
+#define NONLS             // All NLS defines and routines
+#endif
+#ifndef NOMB
+#define NOMB              // MB_* and MessageBox()
+#endif
+#ifndef NOMEMMGR
+#define NOMEMMGR          // GMEM_*, LMEM_*, GHND, LHND, associated routines
+#endif
+#ifndef NOMETAFILE
+#define NOMETAFILE        // typedef METAFILEPICT
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX          // Macros min(a,b) and max(a,b)
+#endif
+#ifndef NOMSG
+#define NOMSG             // typedef MSG and associated routines
+#endif
+#ifndef NOOPENFILE
+#define NOOPENFILE        // OpenFile(), OemToAnsi, AnsiToOem, and OF_*
+#endif
+#ifndef NOSCROLL
+#define NOSCROLL          // SB_* and scrolling routines
+#endif
+#ifndef NOSERVICE
+#define NOSERVICE         // All Service Controller routines, SERVICE_ equates, etc.
+#endif
+#ifndef NOSOUND
+#define NOSOUND           // Sound driver routines
+#endif
+#ifndef NOTEXTMETRIC
+#define NOTEXTMETRIC      // typedef TEXTMETRIC and associated routines
+#endif
+#ifndef NOWH
+#define NOWH              // SetWindowsHook and WH_*
+#endif
+#ifndef NOWINOFFSETS
+#define NOWINOFFSETS      // GWL_*, GCL_*, associated routines
+#endif
+#ifndef NOCOMM
+#define NOCOMM            // COMM driver routines
+#endif
+#ifndef NOKANJI
+#define NOKANJI           // Kanji support stuff.
+#endif
+#ifndef NOHELP
+#define NOHELP            // Help engine interface.
+#endif
+#ifndef NOPROFILER
+#define NOPROFILER        // Profiler interface.
+#endif
+#ifndef NODEFERWINDOWPOS
+#define NODEFERWINDOWPOS  // DeferWindowPos routines
+#endif
+#ifndef NOMCX
+#define NOMCX             // Modem Configuration ExtensionsA
+#endif
+
+//  Set target version to Windows Server 2003, Windows XP/SP1 or higher.
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
+#endif
+
+#include <windows.h>
+
+#ifdef __MINGW32__
+//  Require Windows XP or higher with MinGW for getaddrinfo().
+#if(_WIN32_WINNT >= 0x0501)
+#else
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
+#endif /* _WIN32_WINNT >= 0x0501 */
+#endif /* __MINGW32__ */
+
+#include <winsock2.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <ipexport.h>
+#include <process.h>
+
+//  On mingw environment AI_NUMERICSERV is not defined, needed in ip.cpp.
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0x0400
+#endif
+#endif