int main (void) { setup_test_environment(); int count; // send 1000 msg on hwm 1000, receive 1000 count = test_defaults (1000,1000); assert (count == 1000); // send 6000 msg on hwm 2000, drops above hwm, only receive hwm count = test_blocking (2000,6000); assert (count == 6000); return 0; }
int main () { setup_test_environment (); UNITY_BEGIN (); // repeat the test for both TCP, INPROC and IPC transports: RUN_TEST (test_tcp); RUN_TEST (test_inproc); #if !defined(ZMQ_HAVE_WINDOWS) && !defined(ZMQ_HAVE_GNU) RUN_TEST (test_ipc); #endif RUN_TEST (test_reset_hwm); return UNITY_END (); }
int main (void) { setup_test_environment(); // No filters run_test<int> (0, 0, 0, 1); #if defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED // Get the group and supplimental groups of the process owner gid_t groups[100]; int ngroups = getgroups(100, groups); 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]; if (notgroup <= groups[i]) notgroup = groups[i] + 1; } // Test filter with UID of process owner run_test<uid_t> (ZMQ_IPC_FILTER_UID, getuid(), 0, 1); // Test filter with UID of another (possibly non-existent) user run_test<uid_t> (ZMQ_IPC_FILTER_UID, getuid() + 1, 0, -1); // Test filter with GID of process owner run_test<gid_t> (ZMQ_IPC_FILTER_GID, group, 0, 1); // Test filter with supplimental group of process owner run_test<gid_t> (ZMQ_IPC_FILTER_GID, supgroup, 0, 1); // Test filter with GID of another (possibly non-existent) group run_test<gid_t> (ZMQ_IPC_FILTER_GID, notgroup, 0, -1); # if defined ZMQ_HAVE_SO_PEERCRED // Test filter with PID of current process run_test<pid_t> (ZMQ_IPC_FILTER_PID, getpid(), 0, 1); // Test filter with PID of another (possibly non-existent) process run_test<pid_t> (ZMQ_IPC_FILTER_PID, getpid() + 1, 0, -1); # else // Setup of PID filter should fail with operation not supported error run_test<pid_t> (ZMQ_IPC_FILTER_PID, getpid(), EINVAL, 0); # endif #else run_test<uid_t> (ZMQ_IPC_FILTER_UID, 0, EINVAL, 0); run_test<gid_t> (ZMQ_IPC_FILTER_GID, 0, EINVAL, 0); run_test<pid_t> (ZMQ_IPC_FILTER_PID, 0, EINVAL, 0); #endif // defined ZMQ_HAVE_SO_PEERCRED || defined ZMQ_HAVE_LOCAL_PEERCRED return 0 ; }
int main (void) { setup_test_environment (); void *ctx = zmq_ctx_new (); assert (ctx); // client socket pings proxy over tcp void *req = zmq_socket (ctx, ZMQ_REQ); assert (req); int rc = zmq_connect (req, "tcp://127.0.0.1:5563"); assert (rc == 0); // Control socket receives terminate command from main over inproc void *control = zmq_socket (ctx, ZMQ_PUB); assert (control); rc = zmq_bind (control, "inproc://control"); assert (rc == 0); void *server_thread = zmq_threadstart(&server_task, ctx); char buf[255]; rc = zmq_send(req, "msg1", 4, 0); assert (rc == 4); rc = zmq_recv(req, buf, 255, 0); assert (rc == 4); assert (memcmp (buf, "msg1", 4) == 0); rc = zmq_send(req, "msg22", 5, 0); assert (rc == 5); rc = zmq_recv(req, buf, 255, 0); assert (rc == 5); assert (memcmp (buf, "msg22", 5) == 0); rc = zmq_send (control, "TERMINATE", 9, 0); assert (rc == 9); rc = zmq_close (control); assert (rc == 0); rc = zmq_close (req); assert (rc == 0); zmq_threadclose (server_thread); rc = zmq_ctx_term (ctx); assert (rc == 0); return 0; }
int main (void) { setup_test_environment(); void *s1; void *s2; int i; int j; int rc; void* threads [THREAD_COUNT]; for (j = 0; j != 10; j++) { // Check the shutdown with many parallel I/O threads. void *ctx = zmq_ctx_new (); assert (ctx); zmq_ctx_set (ctx, ZMQ_IO_THREADS, 7); s1 = zmq_socket (ctx, ZMQ_PUB); assert (s1); rc = zmq_bind (s1, "tcp://127.0.0.1:5560"); assert (rc == 0); printf("Kicking off worker threads\n"); for (i = 0; i != THREAD_COUNT; i++) { s2 = zmq_socket (ctx, ZMQ_SUB); assert (s2); threads [i] = zmq_threadstart(&worker, s2); } printf("Waiting on them to finish\n"); for (i = 0; i != THREAD_COUNT; i++) { zmq_threadclose(threads [i]); } printf("Closing sockets\n"); rc = zmq_close (s1); assert (rc == 0); printf("Releasing context\n"); rc = zmq_ctx_term (ctx); assert (rc == 0); } return 0; }
int main (void) { setup_test_environment (); void *ctx = zmq_ctx_new (); assert (ctx); // Control socket receives terminate command from main over inproc void *control = zmq_socket (ctx, ZMQ_PUB); assert (control); int rc = zmq_bind (control, "inproc://control"); assert (rc == 0); void *thread = zmq_threadstart(&server_task, ctx); msleep (500); // Run for 500 ms // Start a secondary publisher which writes data to the SUB-PUSH server socket void *publisher = zmq_socket (ctx, ZMQ_PUB); assert (publisher); rc = zmq_connect (publisher, "tcp://127.0.0.1:15564"); assert (rc == 0); msleep (50); rc = zmq_send (publisher, "This is a test", 14, 0); assert (rc == 14); msleep (50); rc = zmq_send (publisher, "This is a test", 14, 0); assert (rc == 14); msleep (50); rc = zmq_send (publisher, "This is a test", 14, 0); assert (rc == 14); rc = zmq_send (control, "TERMINATE", 9, 0); assert (rc == 9); rc = zmq_close (publisher); assert (rc == 0); rc = zmq_close (control); assert (rc == 0); zmq_threadclose (thread); rc = zmq_ctx_term (ctx); assert (rc == 0); return 0; }
int main (void) { setup_test_environment (); test_bind_before_connect (); test_connect_before_bind (); test_connect_before_bind_pub_sub (); test_multiple_connects (); test_multiple_threads (); test_simultaneous_connect_bind_threads (); test_identity (); test_connect_only (); test_unbind (); test_shutdown_during_pend (); return 0; }
int main (void) { setup_test_environment(); int count; // Default values are 1000 on send and 1000 one receive, so 2000 total count = test_defaults (); assert (count == 2000); // Infinite send and receive buffer count = test_inproc_bind_first (0, 0); assert (count == MAX_SENDS); count = test_inproc_connect_first (0, 0); assert (count == MAX_SENDS); // Infinite send buffer count = test_inproc_bind_first (1, 0); assert (count == MAX_SENDS); count = test_inproc_connect_first (1, 0); assert (count == MAX_SENDS); // Infinite receive buffer count = test_inproc_bind_first (0, 1); assert (count == MAX_SENDS); count = test_inproc_connect_first (0, 1); assert (count == MAX_SENDS); // Send and recv buffers hwm 1, so total that can be queued is 2 count = test_inproc_bind_first (1, 1); assert (count == 2); count = test_inproc_connect_first (1, 1); assert (count == 2); // Send hwm of 1, send before bind so total that can be queued is 1 count = test_inproc_connect_and_close_first (1, 0); assert (count == 1); // Send hwm of 1, send from bind side before connect so total that can be queued should be 1, // however currently all messages get thrown away before the connect. BUG? count = test_inproc_bind_and_close_first (1, 0); //assert (count == 1); return 0; }
int main (void) { setup_test_environment (); UNITY_BEGIN (); RUN_TEST (test_ctx_destroy); RUN_TEST (test_ctx_shutdown); RUN_TEST (test_zmq_ctx_term_null_fails); RUN_TEST (test_zmq_term_null_fails); RUN_TEST (test_zmq_ctx_shutdown_null_fails); RUN_TEST ( test_poller_exists_with_socket_on_zmq_ctx_term_non_thread_safe_socket); RUN_TEST ( test_poller_exists_with_socket_on_zmq_ctx_term_thread_safe_socket); return UNITY_END (); }
int main (void) { setup_test_environment (); UNITY_BEGIN (); RUN_TEST (test_bind_before_connect); RUN_TEST (test_connect_before_bind); RUN_TEST (test_connect_before_bind_pub_sub); RUN_TEST (test_connect_before_bind_ctx_term); RUN_TEST (test_multiple_connects); RUN_TEST (test_multiple_threads); RUN_TEST (test_simultaneous_connect_bind_threads); RUN_TEST (test_routing_id); RUN_TEST (test_connect_only); RUN_TEST (test_unbind); RUN_TEST (test_shutdown_during_pend); return UNITY_END (); }
int main (void) { setup_test_environment (); test_single_connect_ipv4 (); test_multi_connect_ipv4 (); test_multi_connect_ipv4_same_port (); test_single_connect_ipv6 (); test_multi_connect_ipv6 (); test_multi_connect_ipv6_same_port (); return 0 ; }
int main (void) { setup_test_environment (); test_single_connect ("tcp://127.0.0.1:*"); test_multi_connect ("tcp://127.0.0.1:*"); test_multi_connect_same_port ("tcp://127.0.0.1:*"); test_single_connect ("tcp://[::1]:*"); test_multi_connect ("tcp://[::1]:*"); test_multi_connect_same_port ("tcp://[::1]:*"); return 0; }
int main (void) { UNITY_BEGIN (); zmq::initialize_network (); setup_test_environment (); RUN_TEST (test_create); RUN_TEST (test_add_fd_and_start_and_receive_data); RUN_TEST (test_add_fd_and_remove_by_timer); #if defined _WIN32 RUN_TEST (test_add_fd_with_pending_failing_connect); #endif zmq::shutdown_network (); return UNITY_END (); }
int main (void) { setup_test_environment(); int count; // send 1000 msg on hwm 1000, receive 1000 count = test_defaults (1000,1000); assert (count == 1000); // send 6000 msg on hwm 2000, drops above hwm, only receive hwm count = test_blocking (2000,6000); assert (count == 6000); // hwm should apply to the messages that have already been received test_reset_hwm (); return 0; }
int main (void) { setup_test_environment(); void *socket; int i; int j; int rc; void* threads [THREAD_COUNT]; for (j = 0; j != 10; j++) { // Check the shutdown with many parallel I/O threads. struct thread_data tdata; tdata.ctx = zmq_ctx_new (); assert (tdata.ctx); zmq_ctx_set (tdata.ctx, ZMQ_IO_THREADS, 7); socket = zmq_socket (tdata.ctx, ZMQ_PUB); assert (socket); rc = zmq_bind (socket, "tcp://127.0.0.1:*"); assert (rc == 0); size_t len = MAX_SOCKET_STRING; rc = zmq_getsockopt (socket, ZMQ_LAST_ENDPOINT, tdata.endpoint, &len); assert (rc == 0); for (i = 0; i != THREAD_COUNT; i++) { threads [i] = zmq_threadstart(&worker, &tdata); } for (i = 0; i != THREAD_COUNT; i++) { zmq_threadclose(threads [i]); } rc = zmq_close (socket); assert (rc == 0); rc = zmq_ctx_term (tdata.ctx); assert (rc == 0); } return 0; }
int main (void) { setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); const char *binds [] = { "inproc://a", "tcp://127.0.0.1:5555" }; const char *connects [] = { "inproc://a", "tcp://localhost:5555" }; for (int transport = 0; transport < 2; transport++) { bind_address = binds [transport]; connect_address = connects [transport]; // SHALL route outgoing messages to connected peers using a round-robin // strategy. test_round_robin_out (ctx); // The request and reply messages SHALL have this format on the wire: // * A delimiter, consisting of an empty frame, added by the REQ socket. // * One or more data frames, comprising the message visible to the // application. test_req_message_format (ctx); // SHALL block on sending, or return a suitable error, when it has no // connected peers. test_block_on_send_no_peers (ctx); // SHALL accept an incoming message only from the last peer that it sent a // request to. // SHALL discard silently any messages received from other peers. // PH: this test is still failing; disabled for now to allow build to // complete. // test_req_only_listens_to_current_peer (ctx); } int rc = zmq_ctx_term (ctx); assert (rc == 0); return 0 ; }
int main (void) { setup_test_environment (); void *ctx = zmq_ctx_new (); assert (ctx); void *sock = zmq_socket (ctx, ZMQ_PUB); assert (sock); int rc = zmq_connect (sock, "tcp://localhost:1234"); assert (rc == 0); rc = zmq_connect (sock, "tcp://[::1]:1234"); assert (rc == 0); rc = zmq_connect (sock, "tcp://localhost:invalid"); assert (rc == -1); rc = zmq_connect (sock, "tcp://in val id:1234"); assert (rc == -1); rc = zmq_connect (sock, "tcp://"); assert (rc == -1); rc = zmq_connect (sock, "tcp://192.168.0.200:*"); assert (rc == -1); rc = zmq_connect (sock, "invalid://localhost:1234"); assert (rc == -1); assert (errno == EPROTONOSUPPORT); rc = zmq_close (sock); assert (rc == 0); rc = zmq_ctx_term (ctx); assert (rc == 0); return 0; }
int main(void) { setup_test_environment (); test_basic (); test_unsubscribe_manual (); const char *frontend; const char *backend; #if !defined ZMQ_HAVE_WINDOWS && !defined ZMQ_HAVE_OPENVMS frontend = "ipc://frontend"; backend = "ipc://backend"; test_xpub_proxy_unsubscribe_on_disconnect (frontend, backend); test_missing_subscriptions (frontend, backend); #endif frontend = "tcp://127.0.0.1:5560"; backend = "tcp://127.0.0.1:5561"; test_xpub_proxy_unsubscribe_on_disconnect (frontend, backend); test_missing_subscriptions (frontend, backend); return 0; }
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; }
int main (void) { setup_test_environment (); void *ctx = zmq_ctx_new (); assert (ctx); void *stream = zmq_socket (ctx, ZMQ_STREAM); assert (stream); void *dealer = zmq_socket (ctx, ZMQ_DEALER); assert (dealer); int rc = zmq_bind (stream, "tcp://127.0.0.1:5555"); assert (rc >= 0); rc = zmq_connect (dealer, "tcp://127.0.0.1:5555"); assert (rc >= 0); zmq_send (dealer, "", 0, 0); zmq_msg_t ident, empty; zmq_msg_init (&ident); rc = zmq_msg_recv (&ident, stream, 0); assert (rc >= 0); rc = zmq_msg_init_data (&empty, (void *) "", 0, NULL, NULL); assert (rc >= 0); rc = zmq_msg_send (&ident, stream, ZMQ_SNDMORE); assert (rc >= 0); rc = zmq_msg_close (&ident); assert (rc >= 0); rc = zmq_msg_send (&empty, stream, 0); assert (rc >= 0); // This close used to fail with Bad Address rc = zmq_msg_close (&empty); assert (rc >= 0); close_zero_linger (dealer); close_zero_linger (stream); zmq_ctx_term (ctx); }
int main (void) { setup_test_environment (); fprintf (stderr, "NULL mechanism\n"); test_zap_errors (&socket_config_null_server, NULL, &socket_config_null_client, NULL); fprintf (stderr, "PLAIN mechanism\n"); test_zap_errors (&socket_config_plain_server, NULL, &socket_config_plain_client, NULL); if (zmq_has ("curve")) { fprintf (stderr, "CURVE mechanism\n"); setup_testutil_security_curve (); curve_client_data_t curve_client_data = { valid_server_public, valid_client_public, valid_client_secret}; test_zap_errors (&socket_config_curve_server, valid_server_secret, &socket_config_curve_client, &curve_client_data); } }
int main (void) { setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); // Spawn ZAP handler void *zap_thread = zmq_threadstart (&zap_handler, ctx); // Server socket will accept connections void *server = zmq_socket (ctx, ZMQ_DEALER); assert (server); int rc = zmq_setsockopt (server, ZMQ_IDENTITY, "IDENT", 6); assert (rc == 0); rc = zmq_bind (server, "tcp://*:9999"); assert (rc == 0); // Client socket that will try to connect to server void *client = zmq_socket (ctx, ZMQ_DEALER); assert (client); rc = zmq_connect (client, "tcp://localhost:9999"); assert (rc == 0); bounce (server, client); rc = zmq_close (client); assert (rc == 0); rc = zmq_close (server); assert (rc == 0); // Shutdown rc = zmq_ctx_term (ctx); assert (rc == 0); // Wait until ZAP handler terminates. zmq_threadclose (zap_thread); return 0; }
int main (void) { int64_t more; size_t more_size = sizeof(more); setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); void *sb = zmq_socket (ctx, ZMQ_PUB); assert (sb); int rc = zmq_bind (sb, "inproc://a"); assert (rc == 0); void *sc = zmq_socket (ctx, ZMQ_SUB); assert (sc); rc = zmq_connect (sc, "inproc://a"); assert (rc == 0); memset(&more, 0xFF, sizeof(int64_t)); zmq_getsockopt(sc, ZMQ_RCVMORE, &more, &more_size); assert (more_size == sizeof(int)); assert (more == 0); // Cleanup 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 do_check(void* sb, void* sc, unsigned int msgsz) { setup_test_environment(); int rc; int sum =0; for (int i = 0; i < 10; i++) { zmq_msg_t msg; zmq_msg_init_size(&msg, msgsz); void * data = zmq_msg_data(&msg); memcpy(data,&i, sizeof(int)); rc = zmq_msg_send(&msg,sc,i==9 ? 0 :ZMQ_SNDMORE); assert (rc == (int)msgsz); zmq_msg_close(&msg); sum += i; } struct iovec ibuffer[32] ; memset(&ibuffer[0], 0, sizeof(ibuffer)); size_t count = 10; rc = zmq_recviov(sb,&ibuffer[0],&count,0); assert (rc == 10); int rsum=0; for(;count;--count) { int v; memcpy(&v,ibuffer[count-1].iov_base,sizeof(int)); rsum += v; assert(ibuffer[count-1].iov_len == msgsz); // free up the memory free(ibuffer[count-1].iov_base); } assert ( sum == rsum ); }
int main (void) { setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); const char *binds [] = { "inproc://a", "tcp://127.0.0.1:5555" }; const char *connects [] = { "inproc://a", "tcp://localhost:5555" }; for (int transport = 0; transport < 2; ++transport) { bind_address = binds [transport]; connect_address = connects [transport]; // PUSH: SHALL route outgoing messages to connected peers using a // round-robin strategy. test_push_round_robin_out (ctx); // PULL: SHALL receive incoming messages from its peers using a fair-queuing // strategy. test_pull_fair_queue_in (ctx); // PUSH: SHALL block on sending, or return a suitable error, when it has no // available peers. test_push_block_on_send_no_peers (ctx); // PUSH and PULL: SHALL create this queue when a peer connects to it. If // this peer disconnects, the socket SHALL destroy its queue and SHALL // discard any messages it contains. // *** Test disabled until libzmq does this properly *** // test_destroy_queue_on_disconnect (ctx); } int rc = zmq_ctx_term (ctx); assert (rc == 0); return 0 ; }
int main (void) { setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); void *sb = zmq_socket (ctx, ZMQ_DEALER); assert (sb); int rc = zmq_bind (sb, "ipc://@tmp-tester"); assert (rc == 0); char endpoint[200]; size_t size = sizeof(endpoint); rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, endpoint, &size); assert (rc == 0); rc = strncmp(endpoint, "ipc://@tmp-tester", size); assert (rc == 0); void *sc = zmq_socket (ctx, ZMQ_DEALER); assert (sc); rc = zmq_connect (sc, "ipc://@tmp-tester"); assert (rc == 0); bounce (sb, sc); rc = zmq_close (sc); assert (rc == 0); rc = zmq_close (sb); assert (rc == 0); rc = zmq_ctx_term (ctx); assert (rc == 0); return 0 ; }
int main (void) { setup_test_environment(); // Create the infrastructure void *ctx = zmq_ctx_new (); assert (ctx); void *sb = zmq_socket (ctx, ZMQ_ROUTER); assert (sb); int val = 0; int rc = zmq_setsockopt (sb, ZMQ_LINGER, &val, sizeof (val)); assert (rc == 0); do_bind_and_verify (sb, "tcp://127.0.0.1:5560"); do_bind_and_verify (sb, "tcp://127.0.0.1:5561"); rc = zmq_close (sb); assert (rc == 0); rc = zmq_ctx_term (ctx); assert (rc == 0); return 0 ; }
int main (void) { setup_test_environment (); void *ctx = zmq_ctx_new (); assert (ctx); // Create few sockets void *vent = zmq_socket (ctx, ZMQ_PUSH); assert (vent); int rc = zmq_bind (vent, "tcp://127.0.0.1:55556"); assert (rc == 0); void *sink = zmq_socket (ctx, ZMQ_PULL); assert (sink); rc = zmq_connect (sink, "tcp://127.0.0.1:55556"); assert (rc == 0); void *bowl = zmq_socket (ctx, ZMQ_PULL); assert (bowl); #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT) void *server = zmq_socket (ctx, ZMQ_SERVER); assert (server); rc = zmq_bind (server, "tcp://127.0.0.1:55557"); assert (rc == 0); void *client = zmq_socket (ctx, ZMQ_CLIENT); assert (client); #endif // Set up poller void* poller = zmq_poller_new (); zmq_poller_event_t event; // waiting on poller with no registered sockets should report error rc = zmq_poller_wait(poller, &event, 0); assert (rc == -1); assert (errno == ETIMEDOUT); // register sink rc = zmq_poller_add (poller, sink, sink, ZMQ_POLLIN); assert (rc == 0); // Send a message char data[1] = {'H'}; rc = zmq_send_const (vent, data, 1, 0); assert (rc == 1); // We expect a message only on the sink rc = zmq_poller_wait (poller, &event, -1); assert (rc == 0); assert (event.socket == sink); assert (event.user_data == sink); rc = zmq_recv (sink, data, 1, 0); assert (rc == 1); // We expect timed out rc = zmq_poller_wait (poller, &event, 0); assert (rc == -1); assert (errno == ETIMEDOUT); // Stop polling sink rc = zmq_poller_remove (poller, sink); assert (rc == 0); // Check we can poll an FD rc = zmq_connect (bowl, "tcp://127.0.0.1:55556"); assert (rc == 0); #if defined _WIN32 SOCKET fd; size_t fd_size = sizeof (SOCKET); #else int fd; size_t fd_size = sizeof (int); #endif rc = zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size); assert (rc == 0); rc = zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN); assert (rc == 0); rc = zmq_poller_wait (poller, &event, 500); assert (rc == 0); assert (event.socket == NULL); assert (event.fd == fd); assert (event.user_data == bowl); zmq_poller_remove_fd (poller, fd); #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT) // Polling on thread safe sockets rc = zmq_poller_add (poller, server, NULL, ZMQ_POLLIN); assert (rc == 0); rc = zmq_connect (client, "tcp://127.0.0.1:55557"); assert (rc == 0); rc = zmq_send_const (client, data, 1, 0); assert (rc == 1); rc = zmq_poller_wait (poller, &event, 500); assert (rc == 0); assert (event.socket == server); assert (event.user_data == NULL); rc = zmq_recv (server, data, 1, 0); assert (rc == 1); // Polling on pollout rc = zmq_poller_modify (poller, server, ZMQ_POLLOUT | ZMQ_POLLIN); assert (rc == 0); rc = zmq_poller_wait (poller, &event, 0); assert (rc == 0); assert (event.socket == server); assert (event.user_data == NULL); assert (event.events == ZMQ_POLLOUT); #endif // Destory sockets, poller and ctx rc = zmq_close (sink); assert (rc == 0); rc = zmq_close (vent); assert (rc == 0); rc = zmq_close (bowl); assert (rc == 0); #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT) rc = zmq_close (server); assert (rc == 0); rc = zmq_close (client); assert (rc == 0); #endif // Test error - null poller pointers 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); rc = zmq_poller_destroy (&poller); assert(rc == 0); rc = zmq_ctx_term (ctx); assert (rc == 0); return 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; }
int main (void) { setup_test_environment(); void *ctx = zmq_ctx_new (); assert (ctx); // Spawn ZAP handler // We create and bind ZAP socket in main thread to avoid case // where child thread does not start up fast enough. void *handler = zmq_socket (ctx, ZMQ_REP); assert (handler); int rc = zmq_bind (handler, "inproc://zeromq.zap.01"); assert (rc == 0); void *zap_thread = zmq_threadstart (&zap_handler, handler); // We bounce between a binding server and a connecting client // We first test client/server with no ZAP domain // Libzmq does not call our ZAP handler, the connect must succeed void *server = zmq_socket (ctx, ZMQ_DEALER); assert (server); void *client = zmq_socket (ctx, ZMQ_DEALER); assert (client); rc = zmq_bind (server, "tcp://127.0.0.1:9000"); assert (rc == 0); rc = zmq_connect (client, "tcp://127.0.0.1:9000"); assert (rc == 0); bounce (server, client); close_zero_linger (client); close_zero_linger (server); // Now define a ZAP domain for the server; this enables // authentication. We're using the wrong domain so this test // must fail. server = zmq_socket (ctx, ZMQ_DEALER); assert (server); client = zmq_socket (ctx, ZMQ_DEALER); assert (client); rc = zmq_setsockopt (server, ZMQ_ZAP_DOMAIN, "WRONG", 5); assert (rc == 0); rc = zmq_bind (server, "tcp://127.0.0.1:9001"); assert (rc == 0); rc = zmq_connect (client, "tcp://127.0.0.1:9001"); assert (rc == 0); expect_bounce_fail (server, client); close_zero_linger (client); close_zero_linger (server); // Now use the right domain, the test must pass server = zmq_socket (ctx, ZMQ_DEALER); assert (server); client = zmq_socket (ctx, ZMQ_DEALER); assert (client); rc = zmq_setsockopt (server, ZMQ_ZAP_DOMAIN, "TEST", 4); assert (rc == 0); rc = zmq_bind (server, "tcp://127.0.0.1:9002"); assert (rc == 0); rc = zmq_connect (client, "tcp://127.0.0.1:9002"); assert (rc == 0); bounce (server, client); close_zero_linger (client); close_zero_linger (server); // Shutdown rc = zmq_ctx_term (ctx); assert (rc == 0); // Wait until ZAP handler terminates zmq_threadclose (zap_thread); return 0; }