int zmq_unbind_x(void* s, const char* addr)
{
const char* endpoint = 0;
if (is_x_addr(addr)) {
endpoint = zmq_endpoint_x(addr);
if (!endpoint)
return -1; // not bound yet
else
return zmq_unbind(s, endpoint);
} else {
return zmq_unbind(s, addr);
}
}
void test_single_connect_ipv4 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int rc = zmq_bind (sb, "tcp://127.0.0.1:5560");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_connect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_unbind (sb, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
/**
* Called by Java's Socket::unbind(String addr).
*/
JNIEXPORT void JNICALL Java_org_zeromq_ZMQ_00024Socket_unbind (JNIEnv *env,
jobject obj,
jstring addr)
{
#if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,2,0)
void *s = get_socket (env, obj);
if (addr == NULL) {
raise_exception (env, EINVAL);
return;
}
const char *c_addr = env->GetStringUTFChars (addr, NULL);
if (c_addr == NULL) {
raise_exception (env, EINVAL);
return;
}
int rc = zmq_unbind (s, c_addr);
int err = zmq_errno();
env->ReleaseStringUTFChars (addr, c_addr);
if (rc != 0) {
raise_exception (env, err);
return;
}
#endif
}
void test_unbind ()
{
// Bind and unbind socket 1
void *bind_socket1 = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (bind_socket1, "inproc://unbind"));
TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (bind_socket1, "inproc://unbind"));
// Bind socket 2
void *bind_socket2 = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (bind_socket2, "inproc://unbind"));
// Now connect
void *connect_socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (connect_socket, "inproc://unbind"));
// Queue up some data
send_string_expect_success (connect_socket, "foobar", 0);
// Read pending message
recv_string_expect_success (bind_socket2, "foobar", 0);
// Cleanup
test_context_socket_close (connect_socket);
test_context_socket_close (bind_socket1);
test_context_socket_close (bind_socket2);
}
SETUP_TEARDOWN_TESTCONTEXT
void test_reconnect_ivl_against_pair_socket (const char *my_endpoint_,
void *sb_)
{
void *sc = test_context_socket (ZMQ_PAIR);
int interval = -1;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (sc, ZMQ_RECONNECT_IVL, &interval, sizeof (int)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint_));
bounce (sb_, sc);
TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb_, my_endpoint_));
expect_bounce_fail (sb_, sc);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb_, my_endpoint_));
expect_bounce_fail (sb_, sc);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint_));
bounce (sb_, sc);
test_context_socket_close (sc);
}
unsigned short ZmqSocket::unbind(const char* endpoint)
{
CHECK_RET_CODE(sock != 0, ERR_CLOSE);
CHECK_API_RET(zmq_unbind(sock, endpoint) != -1);
onDisconnect();
return NO_ERR;
}
Object HHVM_METHOD(ZMQSocket, disconnect, const String& dsn) {
auto sock = Native::data<ZMQSocket>(this_);
if (zmq_unbind(sock->socket->z_socket, dsn.data()) != 0) {
throwExceptionClassZMQErr(s_ZMQSocketExceptionClass, "Failed to disconnect the ZMQ socket: {}", errno);
}
sock->socket->connect.erase(dsn);
return Object(Native::object(sock));
}
void test_single_connect (const char *address)
{
size_t len = MAX_SOCKET_STRING;
char my_endpoint[MAX_SOCKET_STRING];
void *ctx = zmq_ctx_new ();
assert (ctx);
int ipv6;
if (streq (address, "tcp://127.0.0.1:*"))
ipv6 = 0;
else if (streq (address, "tcp://[::1]:*"))
ipv6 = 1;
else
assert (false);
if (ipv6 && !is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, address);
assert (rc == 0);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, my_endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, my_endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, my_endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
int main(int argc, char *argv[])
{
void *ctx, *handler, *thread, *server, *client;
const char *domain, *connect_addr;
int optval;
domain = argc > 1 ? argv[1] : "test";
connect_addr = strcmp(domain, "fail") ? "tcp://127.0.0.1:9000" : "tcp://127.0.0.1:9001";
assert((ctx = zmq_ctx_new()));
/* Start ZAP handler thread. */
assert((handler = zmq_socket(ctx, ZMQ_REP)));
assert(!(zmq_bind(handler, "inproc://zeromq.zap.01")));
assert((thread = zmq_threadstart(zap_handler, handler)));
/* Bind server. */
assert((server = zmq_socket(ctx, ZMQ_DEALER)));
assert(!(zmq_setsockopt(server, ZMQ_ZAP_DOMAIN, domain, strlen(domain))));
assert(!zmq_bind(server, "tcp://127.0.0.1:9000"));
/* Connect client. */
assert((client = zmq_socket(ctx, ZMQ_DEALER)));
optval = 200;
assert(!(zmq_setsockopt(client, ZMQ_RECONNECT_IVL, &optval, sizeof(optval))));
optval = 5000;
assert(!(zmq_setsockopt(client, ZMQ_RECONNECT_IVL_MAX, &optval, sizeof(optval))));
optval = 30000;
assert(!(zmq_setsockopt(client, ZMQ_SNDTIMEO, &optval, sizeof(optval))));
optval = 1;
assert(!(zmq_setsockopt(client, ZMQ_IMMEDIATE, &optval, sizeof(optval))));
assert(!zmq_connect(client, connect_addr));
/* Bounce test. */
s_send(client, "Hello, Server!");
assert(!strcmp(s_recv(server), "Hello, Server!"));
s_send(server, "Hello, Client!");
assert(!strcmp(s_recv(client), "Hello, Client!"));
/* Cleanup. */
assert(!zmq_disconnect(client, connect_addr));
assert(!zmq_close(client));
assert(!zmq_unbind(server, "tcp://127.0.0.1:9000"));
assert(!zmq_close(server));
assert(!zmq_term(ctx));
zmq_threadclose(thread);
return 0;
}
int
zsocket_unbind (void *self, const char *format, ...)
{
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3, 2, 0))
char endpoint [256];
va_list argptr;
va_start (argptr, format);
vsnprintf (endpoint, 256, format, argptr);
va_end (argptr);
return zmq_unbind (self, endpoint);
#else
return -1;
#endif
}
void test_stream_2_stream ()
{
char buff[256];
const char msg[] = "hi 1";
const int disabled = 0;
const int zero = 0;
char my_endpoint[MAX_SOCKET_STRING];
// Set up listener STREAM.
void *rbind = test_context_socket (ZMQ_STREAM);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rbind, ZMQ_STREAM_NOTIFY, &disabled, sizeof (disabled)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rbind, ZMQ_LINGER, &zero, sizeof zero));
bind_loopback_ipv4 (rbind, my_endpoint, sizeof my_endpoint);
// Set up connection stream.
void *rconn1 = test_context_socket (ZMQ_STREAM);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rconn1, ZMQ_LINGER, &zero, sizeof zero));
// Do the connection.
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (rconn1, ZMQ_CONNECT_ROUTING_ID,
rconn1routing_id,
strlen (rconn1routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rconn1, my_endpoint));
/* Uncomment to test assert on duplicate routing id.
// Test duplicate connect attempt.
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (rconn1, ZMQ_CONNECT_ROUTING_ID, rconn1routing_id, strlen(rconn1routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rconn1, bindip));
*/
// Send data to the bound stream.
send_string_expect_success (rconn1, rconn1routing_id, ZMQ_SNDMORE);
send_string_expect_success (rconn1, msg, 0);
// Accept data on the bound stream.
TEST_ASSERT_GREATER_THAN (
0, TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (rbind, buff, 256, 0)));
TEST_ASSERT_EQUAL (0, buff[0]); // an auto-generated routing id
recv_string_expect_success (rbind, msg, 0);
// Handle close of the socket.
TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (rbind, my_endpoint));
test_context_socket_close (rbind);
test_context_socket_close (rconn1);
}
void test_unbind ()
{
void *ctx = zmq_ctx_new ();
assert (ctx);
// Bind and unbind socket 1
void *bindSocket1 = zmq_socket (ctx, ZMQ_PAIR);
assert (bindSocket1);
int rc = zmq_bind (bindSocket1, "inproc://unbind");
assert (rc == 0);
zmq_unbind (bindSocket1, "inproc://unbind");
assert (rc == 0);
// Bind socket 2
void *bindSocket2 = zmq_socket (ctx, ZMQ_PAIR);
assert (bindSocket2);
rc = zmq_bind (bindSocket2, "inproc://unbind");
assert (rc == 0);
// Now connect
void *connectSocket = zmq_socket (ctx, ZMQ_PAIR);
assert (connectSocket);
rc = zmq_connect (connectSocket, "inproc://unbind");
assert (rc == 0);
// Queue up some data
rc = zmq_send_const (connectSocket, "foobar", 6, 0);
assert (rc == 6);
// Read pending message
zmq_msg_t msg;
rc = zmq_msg_init (&msg);
assert (rc == 0);
rc = zmq_msg_recv (&msg, bindSocket2, 0);
assert (rc == 6);
void *data = zmq_msg_data (&msg);
assert (memcmp ("foobar", data, 6) == 0);
// Cleanup
rc = zmq_close (connectSocket);
assert (rc == 0);
rc = zmq_close (bindSocket1);
assert (rc == 0);
rc = zmq_close (bindSocket2);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
/**
* unbind a socket from the specified endpoint
*/
static void _zmq_unbind(t_zmq *x, t_symbol *s) {
if(! x->zmq_socket) {
error("no socket");
return;
}
if(x->socket_state != BOUND) {
error("socket not bound");
return;
}
int r = zmq_unbind(x->zmq_socket, s->s_name);
if(r==0) {
x->socket_state = NONE;
post("socket unbound");
}
else _zmq_error(zmq_errno());
}
int pcore_stop(void *core_ptr)
{
int rc = 0, i;
pb_core_t *core = NULL;
if (!core_ptr)
return 0;
core = (pb_core_t *)core_ptr;
pb_log (core, PBYTE_WARN, "Stop detected");
if (!core->active)
return 0;
core->active = 0;
rc = pthread_join (core->thread_recv_send, NULL);
for (i = 0; i < core->worker_count; i++)
{
rc |= pthread_join (core->thread_worker[i], NULL);
}
if (rc == 0)
{
sleep (1);
zmq_unbind (core->sock, core->URL);
zmq_close (core->sock);
zmq_ctx_destroy (core->ctx);
mqueue_close (&core->queue_in);
mqueue_close (&core->queue_out);
pcore_init (core);
}
pb_log (core, PBYTE_INFO, "Stop success [%d]", rc);
free (core);
return rc;
}
int
zsock_unbind (zsock_t *self, const char *format, ...)
{
assert (self);
assert (zsock_is (self));
#if (ZMQ_VERSION >= ZMQ_MAKE_VERSION (3,2,0))
// Expand format to get full endpoint
va_list argptr;
va_start (argptr, format);
char *endpoint = zsys_vprintf (format, argptr);
va_end (argptr);
int rc = zmq_unbind (self->handle, endpoint);
free (endpoint);
return rc;
#else
return -1;
#endif
}
void test_single_connect_ipv6 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
if (!is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int ipv6 = 1;
int rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://[::1]:5560");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5560");
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_unbind (sb, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
LastValueCache::~LastValueCache()
{
if (_cache_thread)
{
_terminate = true;
pthread_join(_cache_thread, NULL);
}
delete[] _subscriber;
for (int ii = 0; ii < _statcount; ii++)
{
std::string statname = _statnames[ii];
LOG_DEBUG("Unbinding and closing statistics socket inproc://%s", statname.c_str());
zmq_unbind(_internal_publishers[statname], ("inproc://" + statname).c_str());
zmq_close(_internal_publishers[statname]);
}
zmq_ctx_destroy(_context);
}
int main (void)
{
setup_test_environment();
void *ctx = zmq_ctx_new ();
assert (ctx);
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
int rc = zmq_bind (sb, "inproc://a");
assert (rc == 0);
rc = zmq_unbind (sb, "inproc://a");
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
inline void unbind (const char *addr_)
{
int rc = zmq_unbind (ptr, addr_);
if (rc != 0)
throw error_t ();
}
int main (void)
{
setup_test_environment();
void *ctx = zmq_ctx_new ();
assert (ctx);
int ipv6 = is_ipv6_available ();
/* Address wildcard, IPv6 disabled */
void *sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
int rc = zmq_bind (sb, "tcp://*:*");
assert (rc == 0);
char bindEndpoint[256];
char connectEndpoint[256];
size_t endpoint_len = sizeof (bindEndpoint);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, bindEndpoint, &endpoint_len);
assert (rc == 0);
// Apparently Windows can't connect to 0.0.0.0. A better fix would be welcome.
#ifdef ZMQ_HAVE_WINDOWS
sprintf (connectEndpoint, "tcp://127.0.0.1:%s",
strrchr(bindEndpoint, ':') + 1);
#else
strcpy (connectEndpoint, bindEndpoint);
#endif
rc = zmq_connect (sc, connectEndpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, connectEndpoint);
assert (rc == 0);
rc = zmq_unbind (sb, bindEndpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
/* Address wildcard, IPv6 enabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://*:*");
assert (rc == 0);
endpoint_len = sizeof (bindEndpoint);
memset(bindEndpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, bindEndpoint, &endpoint_len);
assert (rc == 0);
#ifdef ZMQ_HAVE_WINDOWS
if (ipv6)
sprintf (connectEndpoint, "tcp://[::1]:%s",
strrchr(bindEndpoint, ':') + 1);
else
sprintf (connectEndpoint, "tcp://127.0.0.1:%s",
strrchr(bindEndpoint, ':') + 1);
#else
strcpy (connectEndpoint, bindEndpoint);
#endif
rc = zmq_connect (sc, connectEndpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, connectEndpoint);
assert (rc == 0);
rc = zmq_unbind (sb, bindEndpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
/* Port wildcard, IPv4 address, IPv6 disabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_bind (sb, "tcp://127.0.0.1:*");
assert (rc == 0);
char endpoint[256];
endpoint_len = sizeof (endpoint);
memset(endpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &endpoint_len);
assert (rc == 0);
rc = zmq_connect (sc, endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
/* Port wildcard, IPv4 address, IPv6 enabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://127.0.0.1:*");
assert (rc == 0);
endpoint_len = sizeof (endpoint);
memset(endpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &endpoint_len);
assert (rc == 0);
rc = zmq_connect (sc, endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
if (ipv6) {
/* Port wildcard, IPv6 address, IPv6 enabled */
sb = zmq_socket (ctx, ZMQ_REP);
assert (sb);
sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb, "tcp://[::1]:*");
assert (rc == 0);
endpoint_len = sizeof (endpoint);
memset(endpoint, 0, endpoint_len);
rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &endpoint_len);
assert (rc == 0);
rc = zmq_connect (sc, endpoint);
assert (rc == 0);
bounce (sb, sc);
rc = zmq_disconnect (sc, endpoint);
assert (rc == 0);
rc = zmq_unbind (sb, endpoint);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb);
assert (rc == 0);
}
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
void test_multi_connect_ipv6 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
if (!is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb0 = zmq_socket (ctx, ZMQ_REP);
assert (sb0);
int ipv6 = 1;
int rc = zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb0, "tcp://[::1]:5560");
assert (rc == 0);
void *sb1 = zmq_socket (ctx, ZMQ_REP);
assert (sb1);
rc = zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb1, "tcp://[::1]:5561");
assert (rc == 0);
void *sb2 = zmq_socket (ctx, ZMQ_REP);
assert (sb2);
rc = zmq_setsockopt (sb2, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb2, "tcp://[::1]:5562");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5561");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://[::1]:5564;[::1]:5562");
assert (rc == 0);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
rc = zmq_disconnect (sc, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://[::1]:5564;[::1]:5562");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://[::1]:5561");
assert (rc == 0);
rc = zmq_unbind (sb0, "tcp://[::1]:5560");
assert (rc == 0);
rc = zmq_unbind (sb1, "tcp://[::1]:5561");
assert (rc == 0);
rc = zmq_unbind (sb2, "tcp://[::1]:5562");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb0);
assert (rc == 0);
rc = zmq_close (sb1);
assert (rc == 0);
rc = zmq_close (sb2);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
void test_multi_connect_ipv4 (void)
{
void *ctx = zmq_ctx_new ();
assert (ctx);
void *sb0 = zmq_socket (ctx, ZMQ_REP);
assert (sb0);
int rc = zmq_bind (sb0, "tcp://127.0.0.1:5560");
assert (rc == 0);
void *sb1 = zmq_socket (ctx, ZMQ_REP);
assert (sb1);
rc = zmq_bind (sb1, "tcp://127.0.0.1:5561");
assert (rc == 0);
void *sb2 = zmq_socket (ctx, ZMQ_REP);
assert (sb2);
rc = zmq_bind (sb2, "tcp://127.0.0.1:5562");
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_connect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://127.0.0.1:5561");
assert (rc == 0);
rc = zmq_connect (sc, "tcp://127.0.0.1:5564;127.0.0.1:5562");
assert (rc == 0);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5564;127.0.0.1:5562");
assert (rc == 0);
rc = zmq_disconnect (sc, "tcp://127.0.0.1:5561");
assert (rc == 0);
rc = zmq_unbind (sb0, "tcp://127.0.0.1:5560");
assert (rc == 0);
rc = zmq_unbind (sb1, "tcp://127.0.0.1:5561");
assert (rc == 0);
rc = zmq_unbind (sb2, "tcp://127.0.0.1:5562");
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb0);
assert (rc == 0);
rc = zmq_close (sb1);
assert (rc == 0);
rc = zmq_close (sb2);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
int main (void)
{
int rc;
char buf[32];
const char *ep = "tcp://127.0.0.1:5560";
fprintf (stderr, "unbind endpoint test running...\n");
// Create infrastructure.
void *ctx = zmq_init (1);
assert (ctx);
void *push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep);
assert (rc == 0);
void *pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_connect (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established.
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Unbind the lisnening endpoint
rc = zmq_unbind (push, ep);
assert (rc == 0);
// Let events some time
zmq_sleep (1);
// Check that sending would block (there's no outbound connection).
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_term (ctx);
assert (rc == 0);
// Now the other way round.
fprintf (stderr, "disconnect endpoint test running...\n");
// Create infrastructure.
ctx = zmq_init (1);
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_connect (push, ep);
assert (rc == 0);
pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_bind (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established.
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Disconnect the bound endpoint
rc = zmq_disconnect (push, ep);
assert (rc == 0);
// Let events some time
zmq_sleep (1);
// Check that sending would block (there's no inbound connections).
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_term (ctx);
assert (rc == 0);
return 0;
}
void LastValueCache::run()
{
// One for each internal statistic (0.._statcount-1) and one for the publisher.
zmq_pollitem_t items[_statcount + 1];
for (int ii = 0; ii < _statcount; ii++)
{
_subscriber[ii] = zmq_socket(_context, ZMQ_SUB);
LOG_DEBUG("Initializing inproc://%s statistic listener", _statnames[ii].c_str());
zmq_connect(_subscriber[ii], ("inproc://" + _statnames[ii]).c_str());
zmq_setsockopt(_subscriber[ii], ZMQ_SUBSCRIBE, "", 0);
}
_publisher = zmq_socket(_context, ZMQ_XPUB);
zmq_bind(_publisher, "tcp://*:6666");
while (!_terminate)
{
// Reset the poll items
for (int ii = 0; ii < _statcount; ii++)
{
items[ii].socket = _subscriber[ii];
items[ii].fd = 0;
items[ii].events = ZMQ_POLLIN;
items[ii].revents = 0;
}
items[_statcount].socket = _publisher;
items[_statcount].fd = 0;
items[_statcount].events = ZMQ_POLLIN;
items[_statcount].revents = 0;
// Poll for an event
//LOG_DEBUG("Poll for %d items", _statcount + 1);
int rc = zmq_poll(items, _statcount + 1, _poll_timeout_ms);
assert(rc >= 0 || errno == EINTR);
for (int ii = 0; ii < _statcount; ii++)
{
if (items[ii].revents & ZMQ_POLLIN)
{
LOG_DEBUG("Update to %s statistic", _statnames[ii].c_str());
clear_cache(_subscriber[ii]);
while (1)
{
zmq_msg_t message;
zmq_msg_t *cached_message = (zmq_msg_t *)malloc(sizeof(zmq_msg_t));
int more;
size_t more_size = sizeof (more);
zmq_msg_init(&message);
zmq_msg_init(cached_message);
zmq_msg_recv(&message, _subscriber[ii], 0);
zmq_msg_copy(cached_message, &message);
_cache[_subscriber[ii]].push_back(cached_message);
zmq_getsockopt(_subscriber[ii], ZMQ_RCVMORE, &more, &more_size);
zmq_msg_send(&message, _publisher, more ? ZMQ_SNDMORE : 0);
zmq_msg_close(&message);
if (!more)
break; // Last message frame
}
}
}
// Recognize incoming subscription events
if (items[_statcount].revents & ZMQ_POLLIN)
{
zmq_msg_t message;
zmq_msg_init(&message);
zmq_msg_recv(&message, _publisher, 0);
char *msg_body = (char *)zmq_msg_data(&message);
if (msg_body[0] == ZMQ_NEW_SUBSCRIPTION_MARKER)
{
// This is a new subscription
std::string topic = std::string(msg_body + 1, zmq_msg_size(&message) - 1);
LOG_DEBUG("New subscription for %s", topic.c_str());
bool recognized = false;
for (int ii = 0; ii < _statcount; ii++)
{
if (topic == _statnames[ii])
{
LOG_DEBUG("Statistic found, check for cached value");
recognized = true;
// Replay the cached message if one exists
if (_cache.find(_subscriber[ii]) != _cache.end())
{
replay_cache(_subscriber[ii]);
}
else
{
LOG_DEBUG("No cached record found, reporting empty statistic");
std::string status = "OK";
zmq_send(_publisher, _statnames[ii].c_str(), _statnames[ii].length(), ZMQ_SNDMORE);
zmq_send(_publisher, status.c_str(), status.length(), 0);
}
}
}
if (!recognized)
{
LOG_DEBUG("Subscription for unknown stat %s", topic.c_str());
std::string status = "Unknown";
zmq_send(_publisher, topic.c_str(), topic.length(), ZMQ_SNDMORE);
zmq_send(_publisher, status.c_str(), status.length(), 0);
}
}
zmq_msg_close(&message);
}
}
for (int ii = 0; ii < _statcount; ii++)
{
zmq_disconnect(_subscriber[ii], ("inproc://" + _statnames[ii]).c_str());
zmq_close(_subscriber[ii]);
clear_cache(_subscriber[ii]);
}
zmq_unbind(_publisher, "tcp://*:6666");
zmq_close(_publisher);
}
tc_readinfo_t * tc_readfromcache (tc_readconfig_t * config)
{
tc_readinfo_t *info;
info = NULL;
uint32_t sbufsize = 256 - (blength(config->cachepath) + 2);
char sbuf[ sbufsize ];
c_readf readf = (config->miss) ? readempty : readcontentsfromfile;
void *hint = NULL;
int32_t r = -1;
#if defined HAVE_LIBCDB
cdb_t cdb;
int32_t usecdb = c_iscdbfile(config->cachepath);
if (usecdb) {
syslog(LOG_INFO,"%s -> trying to open cdb file %s",__FUNCTION__,btocstr(config->cachepath));
int32_t fd = open(btocstr(config->cachepath),O_RDONLY); /*FIXME : unsigned ? */
if (!fd) {
syslog(LOG_ERR,"%s, cdb init error, failed to open file",__FUNCTION__);
goto exitearly;
}
if (cdb_init(&cdb,fd) != 0) {
syslog(LOG_ERR,"%s, cdb init error",__FUNCTION__);
goto exitearly;
}
readf = readcontentsfromcdb;
hint = (void *)&cdb;
}
#endif
void *ctx, *sock;
ctx = zmq_ctx_new(); /*xs_init();*/
if (ctx == NULL) {
syslog(LOG_ERR,"%s! %s",__FUNCTION__,zmq_strerror(zmq_errno()));
goto exitearly;
}
zmq_ctx_set(ctx,ZMQ_IO_THREADS,2);
sock = zmq_socket (ctx,ZMQ_XREP);
if (sock == NULL) {
syslog(LOG_ERR,"cannot open XREP socket - %s",zmq_strerror(zmq_errno()));
zmq_ctx_destroy(ctx); /*xs_term(ctx);*/
goto exitearly;
}
info = (tc_readinfo_t *)c_malloc(sizeof(tc_readinfo_t),NULL);
info->numofreads = 0;
info->numofmisses = 0;
uint32_t rcvhwm = 500;
r = zmq_setsockopt (sock,ZMQ_RCVHWM,&rcvhwm,sizeof(rcvhwm));
zmq_assertmsg (r == 0,"xs setsockopt rcvhwm error");
r = zmq_bind (sock,btocstr(config->address));
if (r == -1) {
syslog(LOG_ERR,"cannot not open %s - %s",btocstr(config->address),zmq_strerror(zmq_errno()));
zmq_close (sock);
zmq_ctx_destroy(ctx); /*xs_term (ctx);*/
goto exitearly;
}
zmq_pollitem_t pitems[1];
pitems[0].socket = sock;
pitems[0].events = ZMQ_POLLIN;
uint32_t count = 0;
uint64_t rsize = 0;
void *data = NULL;
for (;;) {
if (count == 0)
count = zmq_poll (pitems,1,(1000 * 3)); /*FIXME*/
if ((*config->signalf)() == 1)
break;
if (count == 0) {
continue;
}
zmq_msg_t msg_ident;
r = zmq_msg_init (&msg_ident);
zmq_assertmsg (r != -1,"ident init error");
zmq_msg_t msg_blank;
r = zmq_msg_init (&msg_blank);
zmq_assertmsg (r != -1,"blank init error");
zmq_msg_t msg_key;
r = zmq_msg_init (&msg_key);
zmq_assertmsg (r != -1,"key init error");
r = zmq_msg_recv (&msg_ident,sock,0);
zmq_assertmsg (r != -1,"recvmsg ident error");
r = zmq_msg_recv (&msg_blank,sock,0);
zmq_assertmsg (r != -1,"recvmsg blank error");
r = zmq_msg_recv (&msg_key,sock,0);
zmq_assertmsg (r != -1,"recvmsg key error");
count--;
memset (&sbuf[0],'\0',256); /*FIXME, possible out of bounds error*/
memcpy (&sbuf[0],zmq_msg_data(&msg_key),zmq_msg_size(&msg_key));
bstring key = bfromcstr(sbuf);
int32_t filtered = c_filterkey(key);
/* filter */
if (filtered)
syslog(LOG_DEBUG,"%s! %s filtered\n",__FUNCTION__,btocstr(key));
#if defined HAVE_LIBCDB
key = (usecdb) ? bfromcstr(sbuf) : bformat("%s/%s\0",btocstr(config->cachepath),sbuf);
#else
key = bformat ("%s/%s\0",btocstr(config->cachepath),sbuf);
#endif
if (!filtered) {
if (!data)
data = (void *)c_malloc (config->size,NULL);
rsize = (*readf)(hint,key,data,config->size);
}
zmq_msg_t msg_part;
if (rsize) {
r = zmq_msg_init_data (&msg_part,data,rsize,c_free,NULL);
zmq_assertmsg (r != -1,"msg part init error");
data = NULL;
} else {
r = zmq_msg_init (&msg_part);
zmq_assertmsg (r != -1,"msg part init error");
info->numofmisses ++;
}
bdestroy (key);
r = zmq_msg_send (&msg_ident,sock,ZMQ_SNDMORE);
zmq_assertmsg (r != -1,"sendmsg ident error");
r = zmq_msg_send (&msg_blank,sock,ZMQ_SNDMORE);
zmq_assertmsg (r != -1,"sendmsg blank error");
r = zmq_msg_send (&msg_key,sock,ZMQ_SNDMORE);
zmq_assertmsg (r != -1,"sendmsg key error");
r = zmq_msg_send (&msg_part,sock,0);
zmq_assertmsg (r != -1,"sendmsg part error");
zmq_msg_close (&msg_ident);
zmq_msg_close (&msg_blank);
zmq_msg_close (&msg_key);
zmq_msg_close (&msg_part);
info->numofreads ++;
} /*for loop*/
error:
zmq_unbind (sock,btocstr(config->address)); /*FIXME, check return*/
r = zmq_close (sock);
if (r == -1) {
syslog(LOG_ERR,"%s! %s",__FUNCTION__,zmq_strerror(zmq_errno()));
zmq_ctx_destroy(ctx); /*xs_term (ctx);*/
goto exitearly;
}
r = zmq_ctx_destroy(ctx); /*xs_term (ctx);*/
if (r == -1) {
syslog(LOG_ERR,"%s! %s",__FUNCTION__,zmq_strerror(zmq_errno()));
goto exitearly;
}
#if defined HAVE_LIBCDB
if (usecdb)
cdb_free (&cdb);
#endif
exitearly:
return info;
}
void test_router_2_router (bool named_)
{
char buff[256];
const char msg[] = "hi 1";
const int zero = 0;
char my_endpoint[MAX_SOCKET_STRING];
// Create bind socket.
void *rbind = test_context_socket (ZMQ_ROUTER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rbind, ZMQ_LINGER, &zero, sizeof (zero)));
bind_loopback_ipv4 (rbind, my_endpoint, sizeof my_endpoint);
// Create connection socket.
void *rconn1 = test_context_socket (ZMQ_ROUTER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rconn1, ZMQ_LINGER, &zero, sizeof (zero)));
// If we're in named mode, set some identities.
if (named_) {
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rbind, ZMQ_ROUTING_ID, x_routing_id, 1));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (rconn1, ZMQ_ROUTING_ID, y_routing_id, 1));
}
// Make call to connect using a connect_routing_id.
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (rconn1, ZMQ_CONNECT_ROUTING_ID,
rconn1routing_id,
strlen (rconn1routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rconn1, my_endpoint));
/* Uncomment to test assert on duplicate routing id
// Test duplicate connect attempt.
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (rconn1, ZMQ_CONNECT_ROUTING_ID, rconn1routing_id, strlen (rconn1routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (rconn1, bindip));
*/
// Send some data.
send_string_expect_success (rconn1, rconn1routing_id, ZMQ_SNDMORE);
send_string_expect_success (rconn1, msg, 0);
// Receive the name.
const int routing_id_len = zmq_recv (rbind, buff, 256, 0);
if (named_) {
TEST_ASSERT_EQUAL_INT (strlen (y_routing_id), routing_id_len);
TEST_ASSERT_EQUAL_STRING_LEN (y_routing_id, buff, routing_id_len);
} else {
TEST_ASSERT_TRUE (routing_id_len && 0 == buff[0]);
}
// Receive the data.
recv_string_expect_success (rbind, msg, 0);
// Send some data back.
const int ret = zmq_send (rbind, buff, routing_id_len, ZMQ_SNDMORE);
TEST_ASSERT_EQUAL_INT (routing_id_len, ret);
send_string_expect_success (rbind, "ok", 0);
// If bound socket identity naming a problem, we'll likely see something funky here.
recv_string_expect_success (rconn1, rconn1routing_id, 0);
recv_string_expect_success (rconn1, "ok", 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (rbind, my_endpoint));
test_context_socket_close (rbind);
test_context_socket_close (rconn1);
}
int pcore_start (void **core_ptr,
pcore_params_t *pcore_params,
void *application)
{
int rc = 0, i;
pb_core_t *core = NULL;
if (!pcore_params || !application)
{
rc = -1;
goto err;
}
*core_ptr = (pb_core_t *)calloc(1, sizeof (pb_core_t));
if (!*core_ptr)
{
rc = -1;
goto err;
}
core = *core_ptr;
pcore_init(core);
if (pcore_params->mode != ePBYTE_SERVER &&
pcore_params->mode != ePBYTE_CLIENT)
{
rc = -2;
goto err;
}
core->mode = pcore_params->mode;
core->application = application;
if (pcore_params->message_handler)
core->message_handler = pcore_params->message_handler;
if (pcore_params->error_handler)
core->error_handler = pcore_params->error_handler;
if (pcore_params->logger)
{
sprintf (core->logger.prefix, "PCORE_%s:",
(pcore_params->mode == ePBYTE_SERVER)? "S":"C");
pb_log_set_logger (&core->logger, pcore_params->logger);
pb_log_set_prio (&core->logger, pcore_params->logger_prio);
}
if (pcore_params->thread_init)
{
core->thread_init = pcore_params->thread_init;
} else {
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Thread init callback not set");
rc = -2;
goto err;
}
if (!pcore_params->addr ||
(pcore_params->port <= 0 || 65535 <= pcore_params->port) ||
(pcore_params->io_threads <= 0))
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Invalid params");
rc = -3;
goto err;
}
if (pcore_params->worker_count <= 0 ||
pcore_params->worker_count >= MAX_WORKER_COUNT)
{
core->worker_count = DEF_WORKER_COUNT;
} else {
core->worker_count = pcore_params->worker_count;
}
sprintf(core->URL, "tcp://%s:%d", pcore_params->addr, pcore_params->port);
core->ctx = zmq_init (pcore_params->io_threads);
if (!core->ctx)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Can't init context: %s",
zmq_strerror(zmq_errno()));
rc = -4;
goto err;
}
if (pcore_params->mode == ePBYTE_SERVER)
{
core->sock = zmq_socket (core->ctx, ZMQ_ROUTER);
if (!core->sock)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Can't init socket: %s",
zmq_strerror(zmq_errno()));
rc = -5;
goto err;
}
pb_log (core, PBYTE_INFO, "Try bind in '%s'", core->URL);
rc = zmq_bind (core->sock, core->URL);
if (rc != 0)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Bind failed: %s",
zmq_strerror(zmq_errno()));
rc = -6;
goto err;
}
} else {
core->sock = zmq_socket (core->ctx, ZMQ_DEALER);
if (!core->sock)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Can't init socket: %s",
zmq_strerror(zmq_errno()));
rc = -5;
goto err;
}
rc = zmq_setsockopt (core->sock,
ZMQ_IDENTITY,
pcore_params->identity.identity,
strlen(pcore_params->identity.identity));
if (rc != 0)
{
pb_log (core, PBYTE_ERR,
"Failed to set identity: %s",
zmq_strerror(zmq_errno()));
rc = -6;
goto err;
}
pb_log (core, PBYTE_INFO,
"Try connect to '%s'",
core->URL);
rc = zmq_connect (core->sock, core->URL);
if (rc != 0)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Connect failed: %s",
zmq_strerror(zmq_errno()));
rc = -6;
goto err;
}
}
mqueue_init (&core->queue_in, MQUEUESIZE);
mqueue_init (&core->queue_out, MQUEUESIZE);
core->pollitem.socket = core->sock;
core->pollitem.fd = 0;
core->pollitem.events = ZMQ_POLLIN;
core->pollitem.revents = 0;
core->active = 1;
rc = pthread_create(&core->thread_recv_send,
NULL,
&pcore_thread_recv_send,
(void *)core);
if(rc < 0)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Can't create recv/send switcher thread: %s",
strerror(errno));
rc = -7;
goto err;
}
for (i = 0; i < core->worker_count; i++)
{
rc = pthread_create (&core->thread_worker[i],
NULL,
&pcore_thread_worker,
(void *)core);
if(rc < 0)
{
pb_log (core, PBYTE_ERR,
"Failed to start. "
"Can't create primary worker%d thread: %s",
i, strerror(errno));
rc = -8 - i;
goto err;
}
}
pb_log (core, PBYTE_INFO,
"Start success. Worker count: %d",
core->worker_count);
return 0;
err:
switch(rc)
{
case -7:
if (core && core->sock)
zmq_unbind (core->sock, core->URL);
case -6:
if (core && core->sock)
zmq_close (core->sock);
case -5:
if (core && core->ctx)
zmq_ctx_destroy (core->ctx);
case -4:
case -3:
case -2:
free (core);
case -1: break;
default:
pcore_stop (core);
break;
}
return rc;
}
void test_multi_connect (const char *address)
{
size_t len = MAX_SOCKET_STRING;
char my_endpoint_0[MAX_SOCKET_STRING];
char my_endpoint_1[MAX_SOCKET_STRING];
char my_endpoint_2[MAX_SOCKET_STRING];
char my_endpoint_3[MAX_SOCKET_STRING * 2];
void *ctx = zmq_ctx_new ();
assert (ctx);
int ipv6;
if (streq (address, "tcp://127.0.0.1:*"))
ipv6 = 0;
else if (streq (address, "tcp://[::1]:*"))
ipv6 = 1;
else
assert (false);
if (ipv6 && !is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb0 = zmq_socket (ctx, ZMQ_REP);
assert (sb0);
int rc = zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb0, address);
assert (rc == 0);
rc = zmq_getsockopt (sb0, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len);
assert (rc == 0);
void *sb1 = zmq_socket (ctx, ZMQ_REP);
assert (sb1);
rc = zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb1, address);
assert (rc == 0);
len = MAX_SOCKET_STRING;
rc = zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
assert (rc == 0);
void *sb2 = zmq_socket (ctx, ZMQ_REP);
assert (sb2);
rc = zmq_setsockopt (sb2, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_bind (sb2, address);
assert (rc == 0);
len = MAX_SOCKET_STRING;
rc = zmq_getsockopt (sb2, ZMQ_LAST_ENDPOINT, my_endpoint_2, &len);
assert (rc == 0);
void *sc = zmq_socket (ctx, ZMQ_REQ);
assert (sc);
rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
assert (rc == 0);
rc = zmq_connect (sc, my_endpoint_0);
assert (rc == 0);
rc = zmq_connect (sc, my_endpoint_1);
assert (rc == 0);
if (!ipv6)
sprintf (my_endpoint_3, "tcp://127.0.0.1:5564;%s",
strrchr (my_endpoint_2, '/') + 1);
else
sprintf (my_endpoint_3, "tcp://[::1]:5564;%s",
strrchr (my_endpoint_2, '/') + 1);
rc = zmq_connect (sc, my_endpoint_3);
assert (rc == 0);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
bounce (sb1, sc);
bounce (sb2, sc);
bounce (sb0, sc);
rc = zmq_disconnect (sc, my_endpoint_0);
assert (rc == 0);
rc = zmq_disconnect (sc, my_endpoint_3);
assert (rc == 0);
rc = zmq_disconnect (sc, my_endpoint_1);
assert (rc == 0);
rc = zmq_unbind (sb0, my_endpoint_0);
assert (rc == 0);
rc = zmq_unbind (sb1, my_endpoint_1);
assert (rc == 0);
rc = zmq_unbind (sb2, my_endpoint_2);
assert (rc == 0);
rc = zmq_close (sc);
assert (rc == 0);
rc = zmq_close (sb0);
assert (rc == 0);
rc = zmq_close (sb1);
assert (rc == 0);
rc = zmq_close (sb2);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
}
int main (void)
{
setup_test_environment();
int rc;
char buf[BUF_SIZE];
size_t buf_size;
const char *ep = "tcp://127.0.0.1:5560";
const char *ep_wc_tcp = "tcp://127.0.0.1:*";
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
const char *ep_wc_ipc = "ipc://*";
#endif
#if defined ZMQ_HAVE_VMCI
const char *ep_wc_vmci = "vmci://*:*";
#endif
// Create infrastructure.
void *ctx = zmq_ctx_new ();
assert (ctx);
void *push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep);
assert (rc == 0);
void *pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_connect (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Unbind the listening endpoint
rc = zmq_unbind (push, ep);
assert (rc == 0);
// Allow unbind to settle
msleep (SETTLE_TIME);
// Check that sending would block (there's no outbound connection)
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
// Create infrastructure
ctx = zmq_ctx_new ();
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_connect (push, ep);
assert (rc == 0);
pull = zmq_socket (ctx, ZMQ_PULL);
assert (pull);
rc = zmq_bind (pull, ep);
assert (rc == 0);
// Pass one message through to ensure the connection is established.
rc = zmq_send (push, "ABC", 3, 0);
assert (rc == 3);
rc = zmq_recv (pull, buf, sizeof (buf), 0);
assert (rc == 3);
// Disconnect the bound endpoint
rc = zmq_disconnect (push, ep);
assert (rc == 0);
// Allow disconnect to settle
msleep (SETTLE_TIME);
// Check that sending would block (there's no inbound connections).
rc = zmq_send (push, "ABC", 3, ZMQ_DONTWAIT);
assert (rc == -1 && zmq_errno () == EAGAIN);
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
// Create infrastructure (wild-card binding)
ctx = zmq_ctx_new ();
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep_wc_tcp);
assert (rc == 0);
pull = zmq_socket(ctx, ZMQ_PULL);
assert(pull);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
rc = zmq_bind (pull, ep_wc_ipc);
assert (rc == 0);
#endif
#if defined ZMQ_HAVE_VMCI
void *req = zmq_socket (ctx, ZMQ_REQ);
assert (req);
rc = zmq_bind (req, ep_wc_vmci);
assert (rc == 0);
#endif
// Unbind sockets binded by wild-card address
buf_size = sizeof(buf);
rc = zmq_getsockopt (push, ZMQ_LAST_ENDPOINT, buf, &buf_size);
assert (rc == 0);
rc = zmq_unbind (push, buf);
assert (rc == 0);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
buf_size = sizeof(buf);
rc = zmq_getsockopt (pull, ZMQ_LAST_ENDPOINT, buf, &buf_size);
assert (rc == 0);
rc = zmq_unbind (pull, buf);
assert (rc == 0);
#endif
#if defined ZMQ_HAVE_VMCI
buf_size = sizeof(buf);
rc = zmq_getsockopt (req, ZMQ_LAST_ENDPOINT, buf, &buf_size);
assert (rc == 0);
rc = zmq_unbind(req, buf);
assert (rc == 0);
#endif
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
// Create infrastructure (wild-card binding)
ctx = zmq_ctx_new ();
assert (ctx);
push = zmq_socket (ctx, ZMQ_PUSH);
assert (push);
rc = zmq_bind (push, ep_wc_tcp);
assert (rc == 0);
pull = zmq_socket(ctx, ZMQ_PULL);
assert(pull);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
rc = zmq_bind (pull, ep_wc_ipc);
assert (rc == 0);
#endif
#if defined ZMQ_HAVE_VMCI
req = zmq_socket (ctx, ZMQ_REQ);
assert (req);
rc = zmq_bind (req, ep_wc_vmci);
assert (rc == 0);
#endif
// Sockets binded by wild-card address can't be unbinded by wild-card address
rc = zmq_unbind (push, ep_wc_tcp);
assert (rc == -1 && zmq_errno () == ENOENT);
#if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS
rc = zmq_unbind (pull, ep_wc_ipc);
assert (rc == -1 && zmq_errno () == ENOENT);
#endif
#if defined ZMQ_HAVE_VMCI
rc = zmq_unbind (req, ep_wc_vmci);
assert (rc == -1 && zmq_errno () == ENOENT);
#endif
// Clean up.
rc = zmq_close (pull);
assert (rc == 0);
rc = zmq_close (push);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
void test_router_2_router_while_receiving ()
{
char buff[256];
const char msg[] = "hi 1";
const int zero = 0;
char x_endpoint[MAX_SOCKET_STRING];
char z_endpoint[MAX_SOCKET_STRING];
// Create xbind socket.
void *xbind = test_context_socket (ZMQ_ROUTER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (xbind, ZMQ_LINGER, &zero, sizeof (zero)));
bind_loopback_ipv4 (xbind, x_endpoint, sizeof x_endpoint);
// Create zbind socket.
void *zbind = test_context_socket (ZMQ_ROUTER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (zbind, ZMQ_LINGER, &zero, sizeof (zero)));
bind_loopback_ipv4 (zbind, z_endpoint, sizeof z_endpoint);
// Create connection socket.
void *yconn = test_context_socket (ZMQ_ROUTER);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (yconn, ZMQ_LINGER, &zero, sizeof (zero)));
// set identities for each socket
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
xbind, ZMQ_ROUTING_ID, x_routing_id, strlen (x_routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_setsockopt (yconn, ZMQ_ROUTING_ID, y_routing_id, 2));
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
zbind, ZMQ_ROUTING_ID, z_routing_id, strlen (z_routing_id)));
// Connect Y to X using a routing id
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
yconn, ZMQ_CONNECT_ROUTING_ID, x_routing_id, strlen (x_routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (yconn, x_endpoint));
// Send some data from Y to X.
send_string_expect_success (yconn, x_routing_id, ZMQ_SNDMORE);
send_string_expect_success (yconn, msg, 0);
// wait for the Y->X message to be received
msleep (SETTLE_TIME);
// Now X tries to connect to Z and send a message
TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (
xbind, ZMQ_CONNECT_ROUTING_ID, z_routing_id, strlen (z_routing_id)));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (xbind, z_endpoint));
// Try to send some data from X to Z.
send_string_expect_success (xbind, z_routing_id, ZMQ_SNDMORE);
send_string_expect_success (xbind, msg, 0);
// wait for the X->Z message to be received (so that our non-blocking check will actually
// fail if the message is routed to Y)
msleep (SETTLE_TIME);
// nothing should have been received on the Y socket
TEST_ASSERT_FAILURE_ERRNO (EAGAIN,
zmq_recv (yconn, buff, 256, ZMQ_DONTWAIT));
// the message should have been received on the Z socket
recv_string_expect_success (zbind, x_routing_id, 0);
recv_string_expect_success (zbind, msg, 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (xbind, x_endpoint));
TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (zbind, z_endpoint));
test_context_socket_close (yconn);
test_context_socket_close (xbind);
test_context_socket_close (zbind);
}
