void test_null_event_pointers (void *ctx)
{
void *socket = zmq_socket (ctx, ZMQ_PAIR);
assert (socket != NULL);
void *poller = zmq_poller_new ();
assert (poller != NULL);
int rc = zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_poller_wait (poller, NULL, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (poller, NULL, 1, 0);
assert (rc == -1 && errno == EFAULT);
// TODO this causes an assertion, which is not consistent if the number
// of events may be 0, the pointer should be allowed to by NULL in that
// case too
#if 0
rc = zmq_poller_wait_all (poller, NULL, 0, 0);
assert (rc == 0);
#endif
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
rc = zmq_close (socket);
assert (rc == 0);
}
void test_null_poller_pointers (void *ctx)
{
int rc = zmq_poller_destroy (NULL);
assert (rc == -1 && errno == EFAULT);
void *null_poller = NULL;
rc = zmq_poller_destroy (&null_poller);
assert (rc == -1 && errno == EFAULT);
void *socket = zmq_socket (ctx, ZMQ_PAIR);
assert (socket != NULL);
rc = zmq_poller_add (NULL, socket, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_add (&null_poller, socket, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify (NULL, socket, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify (&null_poller, socket, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove (NULL, socket);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove (&null_poller, socket);
assert (rc == -1 && errno == EFAULT);
fd_t fd;
size_t fd_size = sizeof fd;
rc = zmq_getsockopt(socket, ZMQ_FD, &fd, &fd_size);
assert (rc == 0);
rc = zmq_poller_add_fd (NULL, fd, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_add_fd (&null_poller, fd, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify_fd (NULL, fd, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify_fd (&null_poller, fd, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove_fd (NULL, fd);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove_fd (&null_poller, fd);
assert (rc == -1 && errno == EFAULT);
zmq_poller_event_t event;
rc = zmq_poller_wait (NULL, &event, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait (&null_poller, &event, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (NULL, &event, 1, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (&null_poller, &event, 1, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_close (socket);
assert (rc == 0);
}
void test_wait_corner_cases (void)
{
void *poller = zmq_poller_new ();
assert (poller != NULL);
zmq_poller_event_t event;
int rc = zmq_poller_wait(poller, &event, 0);
assert (rc == -1 && errno == EAGAIN);
// this can never return since no socket was registered, and should yield an error
rc = zmq_poller_wait(poller, &event, -1);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (poller, &event, -1, 0);
assert (rc == -1 && errno == EINVAL);
rc = zmq_poller_wait_all (poller, &event, 0, 0);
assert (rc == -1 && errno == EAGAIN);
// this can never return since no socket was registered, and should yield an error
rc = zmq_poller_wait_all (poller, &event, 0, -1);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
}
int zmq_poller_wait (void *poller_, zmq_poller_event_t *event_, long timeout_)
{
int rc = zmq_poller_wait_all (poller_, event_, 1, timeout_);
if (rc < 0 && event_) {
// TODO this is not portable... zmq_poller_event_t contains pointers,
// for which nullptr does not need to be represented by all-zeroes
memset (event_, 0, sizeof (zmq_poller_event_t));
}
// wait_all returns number of events, but we return 0 for any success
return rc >= 0 ? 0 : rc;
}
int zmq_poller_wait (void *poller_, zmq_poller_event_t *event, long timeout_)
{
if (!poller_ || !((zmq::socket_poller_t*)poller_)->check_tag ()) {
errno = EFAULT;
return -1;
}
zmq_assert (event != NULL);
int rc = zmq_poller_wait_all(poller_, event, 1, timeout_);
if (rc < 0) {
memset (event, 0, sizeof(zmq_poller_event_t));
}
// wait_all returns number of events, but we return 0 for any success
return rc >= 0 ? 0 : rc;
}
inline int zmq_poller_poll (zmq_pollitem_t *items_, int nitems_, long timeout_)
{
// implement zmq_poll on top of zmq_poller
int rc;
zmq_poller_event_t *events;
zmq::socket_poller_t poller;
events = new (std::nothrow) zmq_poller_event_t[nitems_];
alloc_assert(events);
bool repeat_items = false;
// Register sockets with poller
for (int i = 0; i < nitems_; i++) {
items_[i].revents = 0;
bool modify = false;
short e = items_[i].events;
if (items_[i].socket) {
// Poll item is a 0MQ socket.
for (int j = 0; j < i; ++j) {
// Check for repeat entries
if (items_[j].socket == items_[i].socket) {
repeat_items = true;
modify = true;
e |= items_[j].events;
}
}
if (modify) {
rc = zmq_poller_modify (&poller, items_[i].socket, e);
} else {
rc = zmq_poller_add (&poller, items_[i].socket, NULL, e);
}
if (rc < 0) {
delete [] events;
return rc;
}
} else {
// Poll item is a raw file descriptor.
for (int j = 0; j < i; ++j) {
// Check for repeat entries
if (!items_[j].socket && items_[j].fd == items_[i].fd) {
repeat_items = true;
modify = true;
e |= items_[j].events;
}
}
if (modify) {
rc = zmq_poller_modify_fd (&poller, items_[i].fd, e);
} else {
rc = zmq_poller_add_fd (&poller, items_[i].fd, NULL, e);
}
if (rc < 0) {
delete [] events;
return rc;
}
}
}
// Wait for events
rc = zmq_poller_wait_all (&poller, events, nitems_, timeout_);
if (rc < 0) {
delete [] events;
if (zmq_errno() == ETIMEDOUT) {
return 0;
}
return rc;
}
// Transform poller events into zmq_pollitem events.
// items_ contains all items, while events only contains fired events.
// If no sockets are repeated (likely), the two are still co-ordered, so step through the items
// checking for matches only on the first event.
// If there are repeat items, they cannot be assumed to be co-ordered,
// so each pollitem must check fired events from the beginning.
int j_start = 0, found_events = rc;
for (int i = 0; i < nitems_; i++) {
for (int j = j_start; j < found_events; ++j) {
if (
(items_[i].socket && items_[i].socket == events[j].socket) ||
(!(items_[i].socket || events[j].socket) && items_[i].fd == events[j].fd)
) {
items_[i].revents = events[j].events & items_[i].events;
if (!repeat_items) {
// no repeats, we can ignore events we've already seen
j_start++;
}
break;
}
if (!repeat_items) {
// no repeats, never have to look at j > j_start
break;
}
}
}
// Cleanup
delete [] events;
return rc;
}
void test_get_peer_state ()
{
#ifdef ZMQ_BUILD_DRAFT_API
void *router = test_context_socket (ZMQ_ROUTER);
int mandatory = 1;
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (router, ZMQ_ROUTER_MANDATORY,
&mandatory, sizeof (mandatory)));
const char *my_endpoint = "inproc://test_get_peer_state";
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (router, my_endpoint));
void *dealer1 = test_context_socket (ZMQ_DEALER);
void *dealer2 = test_context_socket (ZMQ_DEALER);
// Lower HWMs to allow doing the test with fewer messages
const int hwm = 100;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (router, ZMQ_SNDHWM, &hwm, sizeof (int)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (dealer1, ZMQ_RCVHWM, &hwm, sizeof (int)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (dealer2, ZMQ_RCVHWM, &hwm, sizeof (int)));
const char *dealer1_routing_id = "X";
const char *dealer2_routing_id = "Y";
// Name dealer1 "X" and connect it to our router
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (dealer1, ZMQ_ROUTING_ID, dealer1_routing_id, 1));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer1, my_endpoint));
// Name dealer2 "Y" and connect it to our router
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (dealer2, ZMQ_ROUTING_ID, dealer2_routing_id, 1));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (dealer2, my_endpoint));
// Get message from both dealers to know when connection is ready
send_string_expect_success (dealer1, "Hello", 0);
recv_string_expect_success (router, dealer1_routing_id, 0);
recv_string_expect_success (router, "Hello", 0);
send_string_expect_success (dealer2, "Hello", 0);
recv_string_expect_success (router, dealer2_routing_id, 0);
recv_string_expect_success (router, "Hello", 0);
void *poller = zmq_poller_new ();
TEST_ASSERT_NOT_NULL (poller);
// Poll on router and dealer1, but not on dealer2
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add (poller, router, NULL, ZMQ_POLLOUT));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add (poller, dealer1, NULL, ZMQ_POLLIN));
const unsigned int count = 10000;
const unsigned int event_size = 2;
bool dealer2_blocked = false;
unsigned int dealer1_sent = 0, dealer2_sent = 0, dealer1_received = 0;
zmq_poller_event_t events[event_size];
for (unsigned int iteration = 0; iteration < count; ++iteration) {
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_wait_all (poller, events, event_size, -1));
for (unsigned int event_no = 0; event_no < event_size; ++event_no) {
const zmq_poller_event_t ¤t_event = events[event_no];
if (current_event.socket == router
&& current_event.events & ZMQ_POLLOUT) {
if (send_msg_to_peer_if_ready (router, dealer1_routing_id))
++dealer1_sent;
if (send_msg_to_peer_if_ready (router, dealer2_routing_id))
++dealer2_sent;
else
dealer2_blocked = true;
}
if (current_event.socket == dealer1
&& current_event.events & ZMQ_POLLIN) {
recv_string_expect_success (dealer1, "Hello", ZMQ_DONTWAIT);
int more;
size_t more_size = sizeof (more);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_getsockopt (dealer1, ZMQ_RCVMORE, &more, &more_size));
TEST_ASSERT_FALSE (more);
++dealer1_received;
}
// never read from dealer2, so its pipe becomes full eventually
}
}
printf ("dealer1_sent = %u, dealer2_sent = %u, dealer1_received = %u\n",
dealer1_sent, dealer2_sent, dealer1_received);
TEST_ASSERT_TRUE (dealer2_blocked);
zmq_poller_destroy (&poller);
test_context_socket_close (router);
test_context_socket_close (dealer1);
test_context_socket_close (dealer2);
#endif
}