rpms
/
zeromq
21
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update to latest version of libzmq and cppzmq.

Browse Source
epel9
Elliott Sales de Andrade 6 years ago
parent 6a4c511715
commit 5652a7377f
6 changed files with 959 additions and 678 deletions
Show Stats Download Patch File Download Diff File

1
.gitignore vendored
Unescape View File

@ -7,3 +7,4 @@
/x86_64/
/i?86/
/tarballs/
/libzmq-4.3.1.tar.gz

25
1260.patch
Unescape View File

@ -1,25 +0,0 @@
From 32b2d3034b04a54118bc95c3f83ea5af78f9de41 Mon Sep 17 00:00:00 2001
From: Nikolay Amiantov <ab@fmap.me>
Date: Thu, 20 Nov 2014 05:08:45 +0300
Subject: [PATCH] Fix test_filter_ipc for cleared supplementary groups
This should fix part of [https://github.com/zeromq/libzmq/issues/1129].
---
tests/test_filter_ipc.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/tests/test_filter_ipc.cpp b/tests/test_filter_ipc.cpp
index 00518f710..83035949b 100644
--- a/tests/test_filter_ipc.cpp
+++ b/tests/test_filter_ipc.cpp
@@ -122,8 +122,8 @@ int main (void)
// Get the group and supplimental groups of the process owner
gid_t groups[100];
int ngroups = getgroups(100, groups);
- assert (ngroups != -1 && ngroups != 0);
- gid_t group = getgid(), supgroup = groups[0], notgroup = groups[ngroups - 1] + 1;
+ assert (ngroups != -1);
+ gid_t group = getgid(), supgroup = group, notgroup = group + 1;
for (int i = 0; i < ngroups; i++) {
if (supgroup == group && group != groups[i])
supgroup = groups[i];

27
1574.patch
Unescape View File

@ -1,27 +0,0 @@
From 25a50ca0d5d3ea076c63c23692e4cb9868bfb55d Mon Sep 17 00:00:00 2001
From: KIU Shueng Chuan <nixchuan@gmail.com>
Date: Tue, 8 Sep 2015 17:26:31 +0800
Subject: [PATCH] avoid dereferencing uint32_t on unaligned address
---
src/socket_base.cpp | 21 +++++----------------
1 file changed, 5 insertions(+), 16 deletions(-)
diff --git a/src/socket_base.cpp b/src/socket_base.cpp
index a980015fc..ea178a868 100644
--- a/src/socket_base.cpp
+++ b/src/socket_base.cpp
@@ -1361,8 +1361,11 @@ void zmq::socket_base_t::monitor_event (int event_, int value_, const std::strin
zmq_msg_t msg;
zmq_msg_init_size (&msg, 6);
uint8_t *data = (uint8_t *) zmq_msg_data (&msg);
- *(uint16_t *) (data + 0) = (uint16_t) event_;
- *(uint32_t *) (data + 2) = (uint32_t) value_;
+ // Avoid dereferencing uint32_t on unaligned address
+ uint16_t event = (uint16_t) event_;
+ uint32_t value = (uint32_t) value_;
+ memcpy (data + 0, &event, sizeof(event));
+ memcpy (data + 2, &value, sizeof(value));
zmq_sendmsg (monitor_socket, &msg, ZMQ_SNDMORE);
// Send address in second frame

2
sources
Unescape View File

@ -1 +1 @@
c89db4dbc0b90c34c9f4983cbff6d321 zeromq-4.1.6.tar.gz
SHA512 (libzmq-4.3.1.tar.gz) = 64855a73331a194c43b01aa86a985a149eba4ed32b9f6483d2a7415cfd8bba557aab5b7b33d160cd177141de02360b73c20e4696a19c2cd798eb5f82eeb72840

39
zeromq.spec
Unescape View File

@ -1,26 +1,26 @@
%bcond_without pgm
# TODO: Split into a separate package?
%global cppzmq_version 4.3.0
Name: zeromq
Version: 4.1.6
Release: 11%{?dist}
Version: 4.3.1
Release: 1%{?dist}
Summary: Software library for fast, message-based applications
License: LGPLv3+
URL: http://www.zeromq.org
Source0: https://github.com/zeromq/zeromq4-1/releases/download/v%{version}/zeromq-%{version}.tar.gz
Source1: https://raw.githubusercontent.com/zeromq/cppzmq/master/zmq.hpp
Source2: https://raw.githubusercontent.com/zeromq/cppzmq/master/LICENSE
Patch0001: https://github.com/zeromq/libzmq/pull/1260.patch
Patch0002: https://github.com/zeromq/libzmq/pull/1574.patch
Source0: https://github.com/zeromq/libzmq/archive/v%{version}/libzmq-%{version}.tar.gz
Source1: https://github.com/zeromq/cppzmq/raw/v%{cppzmq_version}/zmq.hpp
Source2: https://github.com/zeromq/cppzmq/raw/v%{cppzmq_version}/LICENSE
BuildRequires: autoconf
BuildRequires: automake
BuildRequires: gcc-c++
BuildRequires: libtool
BuildRequires: libsodium-devel
BuildRequires: gcc-c++
BuildRequires: libunwind-devel
BuildRequires: glib2-devel
BuildRequires: libuuid-devel
%if %{with pgm}
BuildRequires: openpgm-devel
BuildRequires: krb5-devel
@ -49,6 +49,7 @@ developing applications that use %{name}.
%package -n cppzmq-devel
Summary: Development files for cppzmq
Version: %{cppzmq_version}
License: MIT
Requires: %{name}-devel%{?_isa} = %{version}-%{release}
@ -59,12 +60,14 @@ developing applications that use the C++ header files of %{name}.
%prep
%autosetup -p1
%autosetup -p1 -n libzmq-%{version}
cp -a %{SOURCE2} .
# Don't turn warnings into errors
sed -i "s/libzmq_werror=\"yes\"/libzmq_werror=\"no\"/g" \
configure.ac
# Remove bundled code.
rm -rf external/wepoll
# Fix permissions.
chmod -x src/xsub.hpp
%build
@ -74,6 +77,9 @@ autoreconf -fi
--with-pgm \
--with-libgssapi_krb5 \
%endif
--with-libsodium \
--enable-libunwind \
--disable-Werror \
--disable-static
%make_build
@ -95,7 +101,7 @@ make check V=1 || ( cat test-suite.log && exit 1 )
%files
%doc AUTHORS ChangeLog MAINTAINERS NEWS
%doc README.md AUTHORS NEWS
%license COPYING COPYING.LESSER
%{_bindir}/curve_keygen
%{_libdir}/libzmq.so.5*
@ -111,6 +117,9 @@ make check V=1 || ( cat test-suite.log && exit 1 )
%changelog
* Tue Jan 22 2019 Elliott Sales de Andrade <quantum.analyst@gmail.com> - 4.3.1-1
- Update to latest version of libzmq and cppzmq
* Mon Jan 21 2019 Elliott Sales de Andrade <quantum.analyst@gmail.com> - 4.1.6-11
- Backport patches to fix test failures in build
- Cleanup spec a little

633
zmq.hpp
Unescape View File

@ -1,4 +1,5 @@
/*
Copyright (c) 2016-2017 ZeroMQ community
Copyright (c) 2009-2011 250bpm s.r.o.
Copyright (c) 2011 Botond Ballo
Copyright (c) 2007-2009 iMatix Corporation
@ -25,6 +26,14 @@
#ifndef __ZMQ_HPP_INCLUDED__
#define __ZMQ_HPP_INCLUDED__
#if (__cplusplus >= 201402L)
#define ZMQ_DEPRECATED(msg) [[deprecated(msg)]]
#elif defined(_MSC_VER)
#define ZMQ_DEPRECATED(msg) __declspec(deprecated(msg))
#elif defined(__GNUC__)
#define ZMQ_DEPRECATED(msg) __attribute__((deprecated(msg)))
#endif
#if (__cplusplus >= 201103L)
#define ZMQ_CPP11
#define ZMQ_NOTHROW noexcept
@ -41,23 +50,37 @@
#include <zmq.h>
#include <algorithm>
#include <cassert>
#include <cstring>
#include <string>
#include <algorithm>
#include <exception>
#include <vector>
#include <iomanip>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
/* Version macros for compile-time API version detection */
#define CPPZMQ_VERSION_MAJOR 4
#define CPPZMQ_VERSION_MINOR 3
#define CPPZMQ_VERSION_PATCH 0
#define CPPZMQ_VERSION \
ZMQ_MAKE_VERSION(CPPZMQ_VERSION_MAJOR, CPPZMQ_VERSION_MINOR, \
CPPZMQ_VERSION_PATCH)
#ifdef ZMQ_CPP11
#include <chrono>
#include <tuple>
#include <functional>
#include <unordered_map>
#include <memory>
#endif
// Detect whether the compiler supports C++11 rvalue references.
#if (defined(__GNUC__) && (__GNUC__ > 4 || \
(__GNUC__ == 4 && __GNUC_MINOR__ > 2)) && \
defined(__GXX_EXPERIMENTAL_CXX0X__))
#if (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 2)) \
&& defined(__GXX_EXPERIMENTAL_CXX0X__))
#define ZMQ_HAS_RVALUE_REFS
#define ZMQ_DELETED_FUNCTION = delete
#elif defined(__clang__)
@ -87,7 +110,8 @@
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
#define ZMQ_HAS_PROXY_STEERABLE
/* Socket event data */
typedef struct {
typedef struct
{
uint16_t event; // id of the event as bitfield
int32_t value; // value is either error code, fd or reconnect interval
} zmq_event_t;
@ -109,58 +133,44 @@ typedef struct {
namespace zmq
{
typedef zmq_free_fn free_fn;
typedef zmq_pollitem_t pollitem_t;
class error_t : public std::exception
{
public:
error_t() : errnum(zmq_errno()) {}
#ifdef ZMQ_CPP11
virtual const char *what () const noexcept
{
return zmq_strerror (errnum);
}
virtual const char *what() const noexcept { return zmq_strerror(errnum); }
#else
virtual const char *what() const throw ()
{
return zmq_strerror(errnum);
}
virtual const char *what() const throw() { return zmq_strerror(errnum); }
#endif
int num () const
{
return errnum;
}
int num() const { return errnum; }
private:
int errnum;
};
inline int poll(zmq_pollitem_t const *items_, size_t nitems_, long timeout_ = -1)
{
int rc = zmq_poll (const_cast<zmq_pollitem_t*>(items_), static_cast<int>(nitems_), timeout_);
int rc = zmq_poll(const_cast<zmq_pollitem_t *>(items_),
static_cast<int>(nitems_), timeout_);
if (rc < 0)
throw error_t();
return rc;
}
inline int poll(zmq_pollitem_t const* items, size_t nitems)
{
return poll(items, nitems, -1);
}
#ifdef ZMQ_CPP11
inline int poll(zmq_pollitem_t const* items, size_t nitems, std::chrono::milliseconds timeout)
inline int
poll(zmq_pollitem_t const *items, size_t nitems, std::chrono::milliseconds timeout)
{
return poll(items, nitems, timeout.count() );
return poll(items, nitems, static_cast<long>(timeout.count()));
}
inline int poll(std::vector<zmq_pollitem_t> const& items, std::chrono::milliseconds timeout)
inline int poll(std::vector<zmq_pollitem_t> const &items,
std::chrono::milliseconds timeout)
{
return poll(items.data(), items.size(), timeout.count() );
return poll(items.data(), items.size(), static_cast<long>(timeout.count()));
}
inline int poll(std::vector<zmq_pollitem_t> const &items, long timeout_ = -1)
@ -170,7 +180,6 @@ namespace zmq
#endif
inline void proxy(void *frontend, void *backend, void *capture)
{
int rc = zmq_proxy(frontend, backend, capture);
@ -179,7 +188,8 @@ namespace zmq
}
#ifdef ZMQ_HAS_PROXY_STEERABLE
inline void proxy_steerable (void *frontend, void *backend, void *capture, void *control)
inline void
proxy_steerable(void *frontend, void *backend, void *capture, void *control)
{
int rc = zmq_proxy_steerable(frontend, backend, capture, control);
if (rc != 0)
@ -206,7 +216,6 @@ namespace zmq
friend class socket_t;
public:
inline message_t()
{
int rc = zmq_msg_init(&msg);
@ -221,21 +230,20 @@ namespace zmq
throw error_t();
}
template<typename I> message_t(I first, I last):
msg()
template<typename T> message_t(T first, T last) : msg()
{
typedef typename std::iterator_traits<I>::difference_type size_type;
typedef typename std::iterator_traits<I>::value_type value_t;
typedef typename std::iterator_traits<T>::difference_type size_type;
typedef typename std::iterator_traits<T>::value_type value_t;
size_type const size_ = std::distance(first, last) * sizeof(value_t);
int const rc = zmq_msg_init_size(&msg, size_);
if (rc != 0)
throw error_t();
value_t *dest = data<value_t>();
while (first != last)
{
while (first != last) {
*dest = *first;
++dest; ++first;
++dest;
++first;
}
}
@ -247,14 +255,20 @@ namespace zmq
memcpy(data(), data_, size_);
}
inline message_t (void *data_, size_t size_, free_fn *ffn_,
void *hint_ = NULL)
inline message_t(void *data_, size_t size_, free_fn *ffn_, void *hint_ = NULL)
{
int rc = zmq_msg_init_data(&msg, data_, size_, ffn_, hint_);
if (rc != 0)
throw error_t();
}
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11)
template<typename T>
message_t(const T &msg_) : message_t(std::begin(msg_), std::end(msg_))
{
}
#endif
#ifdef ZMQ_HAS_RVALUE_REFS
inline message_t(message_t &&rhs) : msg(rhs.msg)
{
@ -307,8 +321,7 @@ namespace zmq
memcpy(data(), data_, size_);
}
inline void rebuild (void *data_, size_t size_, free_fn *ffn_,
void *hint_ = NULL)
inline void rebuild(void *data_, size_t size_, free_fn *ffn_, void *hint_ = NULL)
{
int rc = zmq_msg_close(&msg);
if (rc != 0)
@ -338,10 +351,7 @@ namespace zmq
return rc != 0;
}
inline void *data () ZMQ_NOTHROW
{
return zmq_msg_data (&msg);
}
inline void *data() ZMQ_NOTHROW { return zmq_msg_data(&msg); }
inline const void *data() const ZMQ_NOTHROW
{
@ -353,23 +363,103 @@ namespace zmq
return zmq_msg_size(const_cast<zmq_msg_t *>(&msg));
}
template<typename T> T* data() ZMQ_NOTHROW
{
return static_cast<T*>( data() );
}
template<typename T> T *data() ZMQ_NOTHROW { return static_cast<T *>(data()); }
template<typename T> T const *data() const ZMQ_NOTHROW
{
return static_cast<T const *>(data());
}
ZMQ_DEPRECATED("from 4.3.0, use operator== instead")
inline bool equal(const message_t *other) const ZMQ_NOTHROW
{
if (size() != other->size())
return false;
std::string a(data<char>(), size());
std::string b(other->data<char>(), other->size());
return a == b;
return *this == *other;
}
inline bool operator==(const message_t &other) const ZMQ_NOTHROW
{
const size_t my_size = size();
return my_size == other.size() && 0 == memcmp(data(), other.data(), my_size);
}
inline bool operator!=(const message_t &other) const ZMQ_NOTHROW
{
return !(*this == other);
}
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 1, 0)
inline const char *gets(const char *property_)
{
const char *value = zmq_msg_gets(&msg, property_);
if (value == NULL)
throw error_t();
return value;
}
#endif
#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
inline uint32_t routing_id() const
{
return zmq_msg_routing_id(const_cast<zmq_msg_t*>(&msg));
}
inline void set_routing_id(uint32_t routing_id)
{
int rc = zmq_msg_set_routing_id(&msg, routing_id);
if (rc != 0)
throw error_t();
}
inline const char* group() const
{
return zmq_msg_group(const_cast<zmq_msg_t*>(&msg));
}
inline void set_group(const char* group)
{
int rc = zmq_msg_set_group(&msg, group);
if (rc != 0)
throw error_t();
}
#endif
/** Dump content to string. Ascii chars are readable, the rest is printed as hex.
* Probably ridiculously slow.
*/
inline std::string str() const
{
// Partly mutuated from the same method in zmq::multipart_t
std::stringstream os;
const unsigned char *msg_data = this->data<unsigned char>();
unsigned char byte;
size_t size = this->size();
int is_ascii[2] = {0, 0};
os << "zmq::message_t [size " << std::dec << std::setw(3)
<< std::setfill('0') << size << "] (";
// Totally arbitrary
if (size >= 1000) {
os << "... too big to print)";
} else {
while (size--) {
byte = *msg_data++;
is_ascii[1] = (byte >= 33 && byte < 127);
if (is_ascii[1] != is_ascii[0])
os << " "; // Separate text/non text
if (is_ascii[1]) {
os << byte;
} else {
os << std::hex << std::uppercase << std::setw(2)
<< std::setfill('0') << static_cast<short>(byte);
}
is_ascii[0] = is_ascii[1];
}
os << ")";
}
return os.str();
}
private:
@ -395,7 +485,8 @@ namespace zmq
}
inline explicit context_t (int io_threads_, int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
inline explicit context_t(int io_threads_,
int max_sockets_ = ZMQ_MAX_SOCKETS_DFLT)
{
ptr = zmq_ctx_new();
if (ptr == NULL)
@ -409,10 +500,7 @@ namespace zmq
}
#ifdef ZMQ_HAS_RVALUE_REFS
inline context_t (context_t &&rhs) ZMQ_NOTHROW : ptr (rhs.ptr)
{
rhs.ptr = NULL;
}
inline context_t(context_t &&rhs) ZMQ_NOTHROW : ptr(rhs.ptr) { rhs.ptr = NULL; }
inline context_t &operator=(context_t &&rhs) ZMQ_NOTHROW
{
std::swap(ptr, rhs.ptr);
@ -420,11 +508,17 @@ namespace zmq
}
#endif
inline ~context_t () ZMQ_NOTHROW
inline int setctxopt(int option_, int optval_)
{
close();
int rc = zmq_ctx_set(ptr, option_, optval_);
ZMQ_ASSERT(rc == 0);
return rc;
}
inline int getctxopt(int option_) { return zmq_ctx_get(ptr, option_); }
inline ~context_t() ZMQ_NOTHROW { close(); }
inline void close() ZMQ_NOTHROW
{
if (ptr == NULL)
@ -438,17 +532,13 @@ namespace zmq
// Be careful with this, it's probably only useful for
// using the C api together with an existing C++ api.
// Normally you should never need to use this.
inline ZMQ_EXPLICIT operator void* () ZMQ_NOTHROW
{
return ptr;
}
inline ZMQ_EXPLICIT operator void *() ZMQ_NOTHROW { return ptr; }
inline ZMQ_EXPLICIT operator void const* () const ZMQ_NOTHROW
{
return ptr;
}
private:
inline ZMQ_EXPLICIT operator void const *() const ZMQ_NOTHROW { return ptr; }
inline operator bool() const ZMQ_NOTHROW { return ptr != NULL; }
private:
void *ptr;
context_t(const context_t &) ZMQ_DELETED_FUNCTION;
@ -468,23 +558,25 @@ namespace zmq
xsub = ZMQ_XSUB,
push = ZMQ_PUSH,
pull = ZMQ_PULL,
#if ZMQ_VERSION_MAJOR < 4
pair = ZMQ_PAIR
#else
pair = ZMQ_PAIR,
stream = ZMQ_STREAM
#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
server = ZMQ_SERVER,
client = ZMQ_CLIENT,
radio = ZMQ_RADIO,
dish = ZMQ_DISH,
#endif
#if ZMQ_VERSION_MAJOR >= 4
stream = ZMQ_STREAM,
#endif
pair = ZMQ_PAIR
};
#endif
class socket_t
{
friend class monitor_t;
public:
inline socket_t(context_t& context_, int type_)
{
init(context_, type_);
}
inline socket_t(context_t &context_, int type_) { init(context_, type_); }
#ifdef ZMQ_CPP11
inline socket_t(context_t &context_, socket_type type_)
@ -494,9 +586,10 @@ namespace zmq
#endif
#ifdef ZMQ_HAS_RVALUE_REFS
inline socket_t(socket_t&& rhs) ZMQ_NOTHROW : ptr(rhs.ptr)
inline socket_t(socket_t &&rhs) ZMQ_NOTHROW : ptr(rhs.ptr), ctxptr(rhs.ctxptr)
{
rhs.ptr = NULL;
rhs.ctxptr = NULL;
}
inline socket_t &operator=(socket_t &&rhs) ZMQ_NOTHROW
{
@ -505,20 +598,11 @@ namespace zmq
}
#endif
inline ~socket_t () ZMQ_NOTHROW
{
close();
}
inline ~socket_t() ZMQ_NOTHROW { close(); }
inline operator void* () ZMQ_NOTHROW
{
return ptr;
}
inline operator void *() ZMQ_NOTHROW { return ptr; }
inline operator void const* () const ZMQ_NOTHROW
{
return ptr;
}
inline operator void const *() const ZMQ_NOTHROW { return ptr; }
inline void close() ZMQ_NOTHROW
{
@ -535,16 +619,14 @@ namespace zmq
setsockopt(option_, &optval, sizeof(T));
}
inline void setsockopt (int option_, const void *optval_,
size_t optvallen_)
inline void setsockopt(int option_, const void *optval_, size_t optvallen_)
{
int rc = zmq_setsockopt(ptr, option_, optval_, optvallen_);
if (rc != 0)
throw error_t();
}
inline void getsockopt (int option_, void *optval_,
size_t *optvallen_) const
inline void getsockopt(int option_, void *optval_, size_t *optvallen_) const
{
int rc = zmq_getsockopt(ptr, option_, optval_, optvallen_);
if (rc != 0)
@ -559,10 +641,7 @@ namespace zmq
return optval;
}
inline void bind(std::string const& addr)
{
bind(addr.c_str());
}
inline void bind(std::string const &addr) { bind(addr.c_str()); }
inline void bind(const char *addr_)
{
@ -571,10 +650,7 @@ namespace zmq
throw error_t();
}
inline void unbind(std::string const& addr)
{
unbind(addr.c_str());
}
inline void unbind(std::string const &addr) { unbind(addr.c_str()); }
inline void unbind(const char *addr_)
{
@ -583,10 +659,7 @@ namespace zmq
throw error_t();
}
inline void connect(std::string const& addr)
{
connect(addr.c_str());
}
inline void connect(std::string const &addr) { connect(addr.c_str()); }
inline void connect(const char *addr_)
{
@ -595,10 +668,7 @@ namespace zmq
throw error_t();
}
inline void disconnect(std::string const& addr)
{
disconnect(addr.c_str());
}
inline void disconnect(std::string const &addr) { disconnect(addr.c_str()); }
inline void disconnect(const char *addr_)
{
@ -607,10 +677,7 @@ namespace zmq
throw error_t();
}
inline bool connected() const ZMQ_NOTHROW
{
return(ptr != NULL);
}
inline bool connected() const ZMQ_NOTHROW { return (ptr != NULL); }
inline size_t send(const void *buf_, size_t len_, int flags_ = 0)
{
@ -632,17 +699,14 @@ namespace zmq
throw error_t();
}
template<typename I> bool send(I first, I last, int flags_=0)
template<typename T> bool send(T first, T last, int flags_ = 0)
{
zmq::message_t msg(first, last);
return send(msg, flags_);
}
#ifdef ZMQ_HAS_RVALUE_REFS
inline bool send (message_t &&msg_, int flags_ = 0)
{
return send(msg_, flags_);
}
inline bool send(message_t &&msg_, int flags_ = 0) { return send(msg_, flags_); }
#endif
inline size_t recv(void *buf_, size_t len_, int flags_ = 0)
@ -665,6 +729,22 @@ namespace zmq
throw error_t();
}
#if defined(ZMQ_BUILD_DRAFT_API) && ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 0)
inline void join(const char* group)
{
int rc = zmq_join(ptr, group);
if (rc != 0)
throw error_t();
}
inline void leave(const char* group)
{
int rc = zmq_leave(ptr, group);
if (rc != 0)
throw error_t();
}
#endif
private:
inline void init(context_t &context_, int type_)
{
@ -684,40 +764,94 @@ namespace zmq
class monitor_t
{
public:
monitor_t() : socketPtr(NULL) {}
virtual ~monitor_t() {}
monitor_t() : socketPtr(NULL), monitor_socket(NULL) {}
virtual ~monitor_t()
{
if (socketPtr)
zmq_socket_monitor(socketPtr, NULL, 0);
if (monitor_socket)
zmq_close(monitor_socket);
}
void monitor(socket_t &socket, std::string const& addr, int events = ZMQ_EVENT_ALL)
#ifdef ZMQ_HAS_RVALUE_REFS
monitor_t(monitor_t &&rhs) ZMQ_NOTHROW : socketPtr(rhs.socketPtr),
monitor_socket(rhs.monitor_socket)
{
rhs.socketPtr = NULL;
rhs.monitor_socket = NULL;
}
socket_t &operator=(socket_t &&rhs) ZMQ_DELETED_FUNCTION;
#endif
void
monitor(socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL)
{
monitor(socket, addr.c_str(), events);
}
void monitor(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)
{
init(socket, addr_, events);
while (true) {
check_event(-1);
}
}
void init(socket_t &socket, std::string const &addr, int events = ZMQ_EVENT_ALL)
{
init(socket, addr.c_str(), events);
}
void init(socket_t &socket, const char *addr_, int events = ZMQ_EVENT_ALL)
{
int rc = zmq_socket_monitor(socket.ptr, addr_, events);
if (rc != 0)
throw error_t();
socketPtr = socket.ptr;
void *s = zmq_socket (socket.ctxptr, ZMQ_PAIR);
assert (s);
monitor_socket = zmq_socket(socket.ctxptr, ZMQ_PAIR);
assert(monitor_socket);
rc = zmq_connect (s, addr_);
rc = zmq_connect(monitor_socket, addr_);
assert(rc == 0);
on_monitor_started();
}
bool check_event(int timeout = 0)
{
assert(monitor_socket);
while (true) {
zmq_msg_t eventMsg;
zmq_msg_init(&eventMsg);
rc = zmq_msg_recv (&eventMsg, s, 0);
zmq::pollitem_t items[] = {
{monitor_socket, 0, ZMQ_POLLIN, 0},
};
zmq::poll(&items[0], 1, timeout);
if (items[0].revents & ZMQ_POLLIN) {
int rc = zmq_msg_recv(&eventMsg, monitor_socket, 0);
if (rc == -1 && zmq_errno() == ETERM)
break;
return false;
assert(rc != -1);
} else {
zmq_msg_close(&eventMsg);
return false;
}
#if ZMQ_VERSION_MAJOR >= 4
const char *data = static_cast<const char *>(zmq_msg_data(&eventMsg));
zmq_event_t msgEvent;
memcpy(&msgEvent.event, data, sizeof(uint16_t)); data += sizeof(uint16_t);
memcpy(&msgEvent.event, data, sizeof(uint16_t));
data += sizeof(uint16_t);
memcpy(&msgEvent.value, data, sizeof(int32_t));
zmq_event_t *event = &msgEvent;
#else
@ -727,9 +861,12 @@ namespace zmq
#ifdef ZMQ_NEW_MONITOR_EVENT_LAYOUT
zmq_msg_t addrMsg;
zmq_msg_init(&addrMsg);
rc = zmq_msg_recv (&addrMsg, s, 0);
if (rc == -1 && zmq_errno() == ETERM)
break;
int rc = zmq_msg_recv(&addrMsg, monitor_socket, 0);
if (rc == -1 && zmq_errno() == ETERM) {
zmq_msg_close(&eventMsg);
return false;
}
assert(rc != -1);
const char *str = static_cast<const char *>(zmq_msg_data(&addrMsg));
std::string address(str, str + zmq_msg_size(&addrMsg));
@ -740,8 +877,11 @@ namespace zmq
#endif
#ifdef ZMQ_EVENT_MONITOR_STOPPED
if (event->event == ZMQ_EVENT_MONITOR_STOPPED)
break;
if (event->event == ZMQ_EVENT_MONITOR_STOPPED) {
zmq_msg_close(&eventMsg);
return false;
}
#endif
switch (event->event) {
@ -775,14 +915,36 @@ namespace zmq
case ZMQ_EVENT_DISCONNECTED:
on_event_disconnected(*event, address.c_str());
break;
#ifdef ZMQ_BUILD_DRAFT_API
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
case ZMQ_EVENT_HANDSHAKE_FAILED_NO_DETAIL:
on_event_handshake_failed_no_detail(*event, address.c_str());
break;
case ZMQ_EVENT_HANDSHAKE_FAILED_PROTOCOL:
on_event_handshake_failed_protocol(*event, address.c_str());
break;
case ZMQ_EVENT_HANDSHAKE_FAILED_AUTH:
on_event_handshake_failed_auth(*event, address.c_str());
break;
case ZMQ_EVENT_HANDSHAKE_SUCCEEDED:
on_event_handshake_succeeded(*event, address.c_str());
break;
#elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
case ZMQ_EVENT_HANDSHAKE_FAILED:
on_event_handshake_failed(*event, address.c_str());
break;
case ZMQ_EVENT_HANDSHAKE_SUCCEED:
on_event_handshake_succeed(*event, address.c_str());
break;
#endif
#endif
default:
on_event_unknown(*event, address.c_str());
break;
}
zmq_msg_close(&eventMsg);
}
zmq_close (s);
socketPtr = NULL;
return true;
}
#ifdef ZMQ_EVENT_MONITOR_STOPPED
@ -790,23 +952,184 @@ namespace zmq
{
if (socketPtr)
zmq_socket_monitor(socketPtr, NULL, 0);
socketPtr = NULL;
}
#endif
virtual void on_monitor_started() {}
virtual void on_event_connected(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_connect_delayed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_connect_retried(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_listening(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_bind_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_accepted(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_accept_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_closed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_close_failed(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_disconnected(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_unknown(const zmq_event_t &event_, const char* addr_) { (void)event_; (void)addr_; }
virtual void on_event_connected(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_connect_delayed(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_connect_retried(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_listening(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_bind_failed(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_accepted(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_accept_failed(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_closed(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_close_failed(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_disconnected(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
virtual void on_event_handshake_failed_no_detail(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_handshake_failed_protocol(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_handshake_failed_auth(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_handshake_succeeded(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
#elif ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 1)
virtual void on_event_handshake_failed(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
virtual void on_event_handshake_succeed(const zmq_event_t &event_,
const char *addr_)
{
(void) event_;
(void) addr_;
}
#endif
virtual void on_event_unknown(const zmq_event_t &event_, const char *addr_)
{
(void) event_;
(void) addr_;
}
private:
monitor_t(const monitor_t &) ZMQ_DELETED_FUNCTION;
void operator=(const monitor_t &) ZMQ_DELETED_FUNCTION;
void *socketPtr;
void *monitor_socket;
};
#if defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
template<typename T = void> class poller_t
{
public:
void add(zmq::socket_t &socket, short events, T *user_data)
{
if (0
!= zmq_poller_add(poller_ptr.get(), static_cast<void *>(socket),
user_data, events)) {
throw error_t();
}
}
void remove(zmq::socket_t &socket)
{
if (0 != zmq_poller_remove(poller_ptr.get(), static_cast<void *>(socket))) {
throw error_t();
}
}
void modify(zmq::socket_t &socket, short events)
{
if (0
!= zmq_poller_modify(poller_ptr.get(), static_cast<void *>(socket),
events)) {
throw error_t();
}
}
size_t wait_all(std::vector<zmq_poller_event_t> &poller_events,
const std::chrono::microseconds timeout)
{
int rc = zmq_poller_wait_all(poller_ptr.get(), poller_events.data(),
static_cast<int>(poller_events.size()),
static_cast<long>(timeout.count()));
if (rc > 0)
return static_cast<size_t>(rc);
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(4, 2, 3)
if (zmq_errno() == EAGAIN)
#else
if (zmq_errno() == ETIMEDOUT)
#endif
return 0;
throw error_t();
}
private:
std::unique_ptr<void, std::function<void(void *)>> poller_ptr{
[]() {
auto poller_new = zmq_poller_new();
if (poller_new)
return poller_new;
throw error_t();
}(),
[](void *ptr) {
int rc = zmq_poller_destroy(&ptr);
ZMQ_ASSERT(rc == 0);
}};
};
#endif // defined(ZMQ_BUILD_DRAFT_API) && defined(ZMQ_CPP11) && defined(ZMQ_HAVE_POLLER)
inline std::ostream &operator<<(std::ostream &os, const message_t &msg)
{
return os << msg.str();
}
} // namespace zmq
#endif // __ZMQ_HPP_INCLUDED__

Write Preview
Loading…
Cancel
Save