static void client(void *arg)
{
intptr_t id = (intptr_t)arg;
int bytes;
char msg[3];
size_t sz_msg;
int i;
msg[0] = 'A' + id%26;
msg[1] = 'a';
msg[2] = '\0';
/* '\0' too */
sz_msg = strlen (msg) + 1;
for (i = 0; i < TEST_LOOPS; i++) {
int cli_sock = nn_socket (AF_SP, NN_PUSH);
msg[1] = 'a' + i%26;
nn_assert (cli_sock >= 0);
nn_assert (nn_connect (cli_sock, SOCKET_ADDRESS) >= 0);
/* Give time to allow for connect to establish. */
nn_sleep (50);
bytes = nn_send (cli_sock, msg, sz_msg, 0);
/* This would better be handled via semaphore or condvar. */
nn_sleep (100);
nn_assert (bytes == sz_msg);
nn_close (cli_sock);
}
}
int main ()
{
int rc;
int pub1;
int pub2;
int sub1;
int sub2;
char buf [3];
pub1 = test_socket (AF_SP, NN_PUB);
test_bind (pub1, SOCKET_ADDRESS);
sub1 = test_socket (AF_SP, NN_SUB);
rc = nn_setsockopt (sub1, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
test_connect (sub1, SOCKET_ADDRESS);
sub2 = test_socket (AF_SP, NN_SUB);
rc = nn_setsockopt (sub2, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
test_connect (sub2, SOCKET_ADDRESS);
/* Wait till connections are established to prevent message loss. */
nn_sleep (10);
test_send (pub1, "0123456789012345678901234567890123456789");
test_recv (sub1, "0123456789012345678901234567890123456789");
test_recv (sub2, "0123456789012345678901234567890123456789");
test_close (pub1);
test_close (sub1);
test_close (sub2);
/* Check receiving messages from two publishers. */
sub1 = test_socket (AF_SP, NN_SUB);
rc = nn_setsockopt (sub1, NN_SUB, NN_SUB_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
test_bind (sub1, SOCKET_ADDRESS);
pub1 = test_socket (AF_SP, NN_PUB);
test_connect (pub1, SOCKET_ADDRESS);
pub2 = test_socket (AF_SP, NN_PUB);
test_connect (pub2, SOCKET_ADDRESS);
nn_sleep (100);
test_send (pub1, "0123456789012345678901234567890123456789");
test_send (pub2, "0123456789012345678901234567890123456789");
test_recv (sub1, "0123456789012345678901234567890123456789");
test_recv (sub1, "0123456789012345678901234567890123456789");
test_close (pub2);
test_close (pub1);
test_close (sub1);
return 0;
}
int ftw_nanomsg_connect (int s, const char *addr)
{
int connection_id;
nn_sleep (20);
connection_id = nn_connect (s, addr);
if ( connection_id >= 0 ) {
nn_sleep (50);
}
return connection_id;
}
int ftw_nanomsg_bind (int s, const char *addr)
{
int binding_id;
nn_sleep (20);
binding_id = nn_bind (s, addr);
if ( binding_id >= 0 ) {
nn_sleep (50);
}
return binding_id;
}
void worker (void *arg)
{
/* Wait 0.1 sec for the main thread to block. */
nn_sleep (100);
test_send (sc, "ABC");
/* Wait 0.1 sec for the main thread to process the previous message
and block once again. */
nn_sleep (100);
test_send (sc, "ABC");
}
int testterm()
{
int rc;
int s;
struct nn_thread thread;
printf("test term\n");
/* Close the socket with no associated endpoints. */
s = test_socket (AF_SP, NN_PAIR);
test_close (s);
/* Test nn_term() before nn_close(). */
nn_thread_init (&thread, worker, NULL);
nn_sleep (100);
nn_term();
/* Check that it's not possible to create new sockets after nn_term(). */
rc = nn_socket (AF_SP, NN_PAIR);
nn_assert (rc == -1);
errno_assert (nn_errno () == ETERM);
/* Wait till worker thread terminates. */
nn_thread_term(&thread);
printf("nn_thread_term finished\n");
return 0;
}
void worker (void *arg)
{
int rc;
/* Wait 0.1 sec for the main thread to block. */
nn_sleep (100);
rc = nn_send (sc, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
/* Wait 0.1 sec for the main thread to process the previous message
and block once again. */
nn_sleep (100);
rc = nn_send (sc, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
}
int main (int argc, char *argv [])
{
int rc;
int s;
int i;
char *buf;
struct nn_thread thread;
struct nn_stopwatch stopwatch;
uint64_t elapsed;
double latency;
if (argc != 3) {
printf ("usage: inproc_lat <message-size> <roundtrip-count>\n");
return 1;
}
message_size = atoi (argv [1]);
roundtrip_count = atoi (argv [2]);
s = nn_socket (AF_SP, NN_PAIR);
assert (s != -1);
rc = nn_bind (s, "inproc://inproc_lat");
assert (rc >= 0);
buf = malloc (message_size);
assert (buf);
memset (buf, 111, message_size);
/* Wait a bit till the worker thread blocks in nn_recv(). */
nn_thread_init (&thread, worker, NULL);
nn_sleep (100);
nn_stopwatch_init (&stopwatch);
for (i = 0; i != roundtrip_count; i++) {
rc = nn_send (s, buf, message_size, 0);
assert (rc == (int)message_size);
rc = nn_recv (s, buf, message_size, 0);
assert (rc == (int)message_size);
}
elapsed = nn_stopwatch_term (&stopwatch);
latency = (double) elapsed / (roundtrip_count * 2);
printf ("message size: %d [B]\n", (int) message_size);
printf ("roundtrip count: %d\n", (int) roundtrip_count);
printf ("average latency: %.3f [us]\n", (double) latency);
nn_thread_term (&thread);
free (buf);
rc = nn_close (s);
assert (rc == 0);
return 0;
}
int main ()
{
int push1;
int push2;
int pull1;
int pull2;
/* Test fan-out. */
push1 = test_socket (AF_SP, NN_PUSH);
test_bind (push1, SOCKET_ADDRESS);
pull1 = test_socket (AF_SP, NN_PULL);
test_connect (pull1, SOCKET_ADDRESS);
pull2 = test_socket (AF_SP, NN_PULL);
test_connect (pull2, SOCKET_ADDRESS);
/* Wait till both connections are established to get messages spread
evenly between the two pull sockets. */
nn_sleep (10);
test_send (push1, "ABC");
test_send (push1, "DEF");
test_recv (pull1, "ABC");
test_recv (pull2, "DEF");
test_close (push1);
test_close (pull1);
test_close (pull2);
/* Test fan-in. */
pull1 = test_socket (AF_SP, NN_PULL);
test_bind (pull1, SOCKET_ADDRESS);
push1 = test_socket (AF_SP, NN_PUSH);
test_connect (push1, SOCKET_ADDRESS);
push2 = test_socket (AF_SP, NN_PUSH);
test_connect (push2, SOCKET_ADDRESS);
test_send (push1, "ABC");
test_send (push2, "DEF");
test_recv (pull1, "ABC");
test_recv (pull1, "DEF");
test_close (pull1);
test_close (push1);
test_close (push2);
return 0;
}
int main ()
{
int rc;
int pub;
int sub1;
int sub2;
char buf [3];
pub = nn_socket (AF_SP, NN_PUB);
errno_assert (pub != -1);
rc = nn_bind (pub, SOCKET_ADDRESS);
errno_assert (rc >= 0);
sub1 = nn_socket (AF_SP, NN_SUB);
errno_assert (sub1 != -1);
rc = nn_setsockopt (sub1, NN_SUB, NN_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
rc = nn_connect (sub1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
sub2 = nn_socket (AF_SP, NN_SUB);
errno_assert (sub2 != -1);
rc = nn_setsockopt (sub2, NN_SUB, NN_SUBSCRIBE, "", 0);
errno_assert (rc == 0);
rc = nn_connect (sub2, SOCKET_ADDRESS);
errno_assert (rc >= 0);
/* Wait till connections are established to prevent message loss. */
nn_sleep (10);
rc = nn_send (pub, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (sub1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (sub2, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (pub);
errno_assert (rc == 0);
rc = nn_close (sub1);
errno_assert (rc == 0);
rc = nn_close (sub2);
errno_assert (rc == 0);
return 0;
}
int main (int argc, const char *argv[])
{
int end0;
int end1;
struct nn_thread thread5;
struct nn_thread thread6;
int port = get_test_port(argc, argv);
test_addr_from(socket_address_h, "tcp", "127.0.0.1", port);
test_addr_from(socket_address_i, "tcp", "127.0.0.1", port + 1);
test_addr_from(socket_address_j, "tcp", "127.0.0.1", port + 2);
/* Test the bi-directional device with REQ/REP (headers). */
/* Start the devices. */
nn_thread_init (&thread5, device5, NULL);
nn_thread_init (&thread6, device6, NULL);
/* Create two sockets to connect to the device. */
end0 = test_socket (AF_SP, NN_REQ);
test_connect (end0, socket_address_h);
end1 = test_socket (AF_SP, NN_REP);
test_connect (end1, socket_address_j);
/* Wait for TCP to establish. */
nn_sleep (100);
/* Pass a message between endpoints. */
test_send (end0, "XYZ");
test_recv (end1, "XYZ");
/* Now send a reply. */
test_send (end1, "REPLYXYZ");
test_recv (end0, "REPLYXYZ");
/* Clean up. */
test_close (end0);
test_close (end1);
/* Shut down the devices. */
nn_term ();
nn_thread_term (&thread5);
nn_thread_term (&thread6);
return 0;
}
int main ()
{
int end0;
int end1;
struct nn_thread thread5;
struct nn_thread thread6;
/* Test the bi-directional device with REQ/REP (headers). */
/* Start the devices. */
nn_thread_init (&thread5, device5, NULL);
nn_thread_init (&thread6, device6, NULL);
/* Create two sockets to connect to the device. */
end0 = test_socket (AF_SP, NN_REQ);
test_connect (end0, SOCKET_ADDRESS_H);
end1 = test_socket (AF_SP, NN_REP);
test_connect (end1, SOCKET_ADDRESS_J);
/* Wait for TCP to establish. */
nn_sleep (1000);
/* Pass a message between endpoints. */
test_send (end0, "XYZ");
test_recv (end1, "XYZ");
/* Now send a reply. */
test_send (end1, "REPLYXYZ");
test_recv (end0, "REPLYXYZ");
/* Clean up. */
test_close (end0);
test_close (end1);
/* Shut down the devices. */
nn_term ();
nn_thread_term (&thread5);
nn_thread_term (&thread6);
return 0;
}
int main (int argc, const char *argv[])
{
int sb;
int sc1;
int sc2;
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, "inproc://pair");
sc1 = test_socket (AF_SP, NN_PAIR);
test_connect (sc1, "inproc://pair");
nn_sleep (100);
sc2 = test_socket (AF_SP, NN_PAIR);
test_connect (sc2, "inproc://pair");
test_send (sb, "HELLO");
test_recv (sc1, "HELLO");
test_send (sc1, "THERE");
test_recv (sb, "THERE");
return 0;
}
int main ()
{
int enda;
int endb;
int endc;
int endd;
int ende1;
int ende2;
struct nn_thread thread1;
struct nn_thread thread2;
struct nn_thread thread3;
int timeo;
/* Test the bi-directional device. */
/* Start the device. */
nn_thread_init (&thread1, device1, NULL);
/* Create two sockets to connect to the device. */
enda = test_socket (AF_SP, NN_PAIR);
test_connect (enda, SOCKET_ADDRESS_A);
endb = test_socket (AF_SP, NN_PAIR);
test_connect (endb, SOCKET_ADDRESS_B);
/* Pass a pair of messages between endpoints. */
test_send (enda, "ABC");
test_recv (endb, "ABC");
test_send (endb, "ABC");
test_recv (enda, "ABC");
/* Clean up. */
test_close (endb);
test_close (enda);
/* Test the uni-directional device. */
/* Start the device. */
nn_thread_init (&thread2, device2, NULL);
/* Create two sockets to connect to the device. */
endc = test_socket (AF_SP, NN_PUSH);
test_connect (endc, SOCKET_ADDRESS_C);
endd = test_socket (AF_SP, NN_PULL);
test_connect (endd, SOCKET_ADDRESS_D);
/* Pass a message between endpoints. */
test_send (endc, "XYZ");
test_recv (endd, "XYZ");
/* Clean up. */
test_close (endd);
test_close (endc);
/* Test the loopback device. */
/* Start the device. */
nn_thread_init (&thread3, device3, NULL);
/* Create two sockets to connect to the device. */
ende1 = test_socket (AF_SP, NN_BUS);
test_connect (ende1, SOCKET_ADDRESS_E);
ende2 = test_socket (AF_SP, NN_BUS);
test_connect (ende2, SOCKET_ADDRESS_E);
/* BUS is unreliable so wait a bit for connections to be established. */
nn_sleep (100);
/* Pass a message to the bus. */
test_send (ende1, "KLM");
test_recv (ende2, "KLM");
/* Make sure that the message doesn't arrive at the socket it was
originally sent to. */
timeo = 100;
test_setsockopt (ende1, NN_SOL_SOCKET, NN_RCVTIMEO,
&timeo, sizeof (timeo));
test_drop (ende1, ETIMEDOUT);
/* Clean up. */
test_close (ende2);
test_close (ende1);
/* Shut down the devices. */
nn_term ();
nn_thread_term (&thread1);
nn_thread_term (&thread2);
nn_thread_term (&thread3);
return 0;
}
int main ()
{
int rc;
int bus1;
int bus2;
int bus3;
char buf [3];
/* Create a simple bus topology consisting of 3 nodes. */
bus1 = nn_socket (AF_SP, NN_BUS);
errno_assert (bus1 != -1);
rc = nn_bind (bus1, SOCKET_ADDRESS_A);
errno_assert (rc >= 0);
bus2 = nn_socket (AF_SP, NN_BUS);
errno_assert (bus2 != -1);
rc = nn_bind (bus2, SOCKET_ADDRESS_B);
errno_assert (rc >= 0);
rc = nn_connect (bus2, SOCKET_ADDRESS_A);
errno_assert (rc >= 0);
bus3 = nn_socket (AF_SP, NN_BUS);
errno_assert (bus3 != -1);
rc = nn_connect (bus3, SOCKET_ADDRESS_A);
errno_assert (rc >= 0);
rc = nn_connect (bus3, SOCKET_ADDRESS_B);
errno_assert (rc >= 0);
/* Send a message from each node. */
rc = nn_send (bus1, "A", 1, 0);
errno_assert (rc >= 0);
nn_assert (rc == 1);
rc = nn_send (bus2, "AB", 2, 0);
errno_assert (rc >= 0);
nn_assert (rc == 2);
rc = nn_send (bus3, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
/* Check that two messages arrived at each node. */
rc = nn_recv (bus1, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 2 || rc == 3);
rc = nn_recv (bus1, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 2 || rc == 3);
rc = nn_recv (bus2, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 1 || rc == 3);
rc = nn_recv (bus2, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 1 || rc == 3);
rc = nn_recv (bus3, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 1 || rc == 2);
rc = nn_recv (bus3, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 1 || rc == 2);
/* Wait till both connections are established. */
nn_sleep (10);
rc = nn_close (bus3);
errno_assert (rc == 0);
rc = nn_close (bus2);
errno_assert (rc == 0);
rc = nn_close (bus1);
errno_assert (rc == 0);
return 0;
}
int main ()
{
int sb;
int sc;
int i;
int s1, s2;
size_t size;
char * buf;
/* Try closing a IPC socket while it not connected. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
test_close (sc);
/* Open the socket anew. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
/* Leave enough time for at least one re-connect attempt. */
nn_sleep (200);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
/* Ping-pong test. */
for (i = 0; i != 1; ++i) {
test_send (sc, "0123456789012345678901234567890123456789");
test_recv (sb, "0123456789012345678901234567890123456789");
test_send (sb, "0123456789012345678901234567890123456789");
test_recv (sc, "0123456789012345678901234567890123456789");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "XYZ");
}
/* Send something large enough to trigger overlapped I/O on Windows. */
size = 10000;
buf = malloc( size );
for (i =0; i != size - 1; ++i) {
buf[i] = 48 + i % 10;
}
buf[size-1] = '\0';
test_send (sc, buf);
test_recv (sb, buf);
free( buf );
test_close (sc);
test_close (sb);
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, SOCKET_ADDRESS);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
/* Test two sockets binding to the same address. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_bind (s1, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
nn_sleep (100);
test_send (sb, "ABC");
test_recv (sc, "ABC");
test_close (sb);
test_send (s1, "ABC");
test_recv (sc, "ABC");
test_close (sc);
test_close (s1);
return 0;
}
int main ()
{
int rc;
int push1;
int push2;
int pull1;
int pull2;
int sndprio;
int rcvprio;
/* Test send priorities. */
pull1 = test_socket (AF_SP, NN_PULL);
test_bind (pull1, SOCKET_ADDRESS_A);
pull2 = test_socket (AF_SP, NN_PULL);
test_bind (pull2, SOCKET_ADDRESS_B);
push1 = test_socket (AF_SP, NN_PUSH);
sndprio = 1;
rc = nn_setsockopt (push1, NN_SOL_SOCKET, NN_SNDPRIO,
&sndprio, sizeof (sndprio));
errno_assert (rc == 0);
test_connect (push1, SOCKET_ADDRESS_A);
sndprio = 2;
rc = nn_setsockopt (push1, NN_SOL_SOCKET, NN_SNDPRIO,
&sndprio, sizeof (sndprio));
errno_assert (rc == 0);
test_connect (push1, SOCKET_ADDRESS_B);
test_send (push1, "ABC");
test_send (push1, "DEF");
test_recv (pull1, "ABC");
test_recv (pull1, "DEF");
test_close (pull1);
test_close (push1);
test_close (pull2);
/* Test receive priorities. */
push1 = test_socket (AF_SP, NN_PUSH);
test_bind (push1, SOCKET_ADDRESS_A);
push2 = test_socket (AF_SP, NN_PUSH);
test_bind (push2, SOCKET_ADDRESS_B);
pull1 = test_socket (AF_SP, NN_PULL);
rcvprio = 2;
rc = nn_setsockopt (pull1, NN_SOL_SOCKET, NN_RCVPRIO,
&rcvprio, sizeof (rcvprio));
errno_assert (rc == 0);
test_connect (pull1, SOCKET_ADDRESS_A);
rcvprio = 1;
rc = nn_setsockopt (pull1, NN_SOL_SOCKET, NN_RCVPRIO,
&rcvprio, sizeof (rcvprio));
errno_assert (rc == 0);
test_connect (pull1, SOCKET_ADDRESS_B);
test_send (push1, "ABC");
test_send (push2, "DEF");
nn_sleep (100);
test_recv (pull1, "DEF");
test_recv (pull1, "ABC");
test_close (pull1);
test_close (push2);
test_close (push1);
/* Test removing a pipe from the list. */
push1 = test_socket (AF_SP, NN_PUSH);
test_bind (push1, SOCKET_ADDRESS_A);
pull1 = test_socket (AF_SP, NN_PULL);
test_connect (pull1, SOCKET_ADDRESS_A);
test_send (push1, "ABC");
test_recv (pull1, "ABC");
test_close (pull1);
rc = nn_send (push1, "ABC", 3, NN_DONTWAIT);
nn_assert (rc == -1 && nn_errno() == EAGAIN);
pull1 = test_socket (AF_SP, NN_PULL);
test_connect (pull1, SOCKET_ADDRESS_A);
test_send (push1, "ABC");
test_recv (pull1, "ABC");
test_close (pull1);
test_close (push1);
return 0;
}
int main (int argc, const char *argv[])
{
int rc;
int sb;
int sc;
int sb2;
int opt;
size_t sz;
int i;
char any_address[128];
test_addr_from (socket_address, "ws", "127.0.0.1",
get_test_port (argc, argv));
test_addr_from (any_address, "ws", "*",
get_test_port (argc, argv));
/* Try closing bound but unconnected socket. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, any_address);
test_close (sb);
/* Try closing a TCP socket while it not connected. At the same time
test specifying the local address for the connection. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
test_close (sc);
/* Open the socket anew. */
sc = test_socket (AF_SP, NN_PAIR);
/* Check socket options. */
sz = sizeof (opt);
rc = nn_getsockopt (sc, NN_WS, NN_WS_MSG_TYPE, &opt, &sz);
errno_assert (rc == 0);
nn_assert (sz == sizeof (opt));
nn_assert (opt == NN_WS_MSG_TYPE_BINARY);
/* Default port 80 should be assumed if not explicitly declared. */
rc = nn_connect (sc, "ws://127.0.0.1");
errno_assert (rc >= 0);
/* Try using invalid address strings. */
rc = nn_connect (sc, "ws://*:");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://*:1000000");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://*:some_port");
nn_assert (rc < 0);
rc = nn_connect (sc, "ws://eth10000;127.0.0.1:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == ENODEV);
rc = nn_bind (sc, "ws://127.0.0.1:");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "ws://127.0.0.1:1000000");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "ws://eth10000:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == ENODEV);
rc = nn_connect (sc, "ws://:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://-hostname:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://abc.123.---.#:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://[::1]:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://abc.123.:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://abc...123:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "ws://.123:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
test_close (sc);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sb, "DEF");
test_recv (sc, "DEF");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "0123456789012345678901234567890123456789");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "0123456789012345678901234567890123456789");
}
test_close (sc);
test_close (sb);
/* Test two sockets binding to the same address. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
sb2 = test_socket (AF_SP, NN_PAIR);
rc = nn_bind (sb2, socket_address);
nn_assert (rc < 0);
errno_assert (nn_errno () == EADDRINUSE);
test_close(sb);
test_close(sb2);
/* Test that NN_RCVMAXSIZE can be -1, but not lower */
sb = test_socket (AF_SP, NN_PAIR);
opt = -1;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc >= 0);
opt = -2;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
test_close (sb);
/* Test NN_RCVMAXSIZE limit */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
opt = 1000;
test_setsockopt (sc, NN_SOL_SOCKET, NN_SNDTIMEO, &opt, sizeof (opt));
nn_assert (opt == 1000);
opt = 1000;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVTIMEO, &opt, sizeof (opt));
nn_assert (opt == 1000);
opt = 4;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sc, "ABCD");
test_recv (sb, "ABCD");
test_send (sc, "ABCDE");
test_drop (sb, ETIMEDOUT);
/* Increase the size limit, reconnect, then try sending again. The reason a
reconnect is necessary is because after a protocol violation, the
connecting socket will not continue automatic reconnection attempts. */
opt = 5;
test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
test_connect (sc, socket_address);
test_send (sc, "ABCDE");
test_recv (sb, "ABCDE");
test_close (sb);
test_close (sc);
test_text ();
/* Test closing a socket that is waiting to connect. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
nn_sleep (100);
test_close (sc);
return 0;
}
int main ()
{
int rc;
int sb;
int sc;
int s1, s2;
int i;
char buf [256];
int val;
struct nn_msghdr hdr;
struct nn_iovec iovec;
unsigned char body [3];
void *control;
struct nn_cmsghdr *cmsg;
unsigned char *data;
/* Create a simple topology. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
/* Try a duplicate bind. It should fail. */
rc = nn_bind (sc, SOCKET_ADDRESS);
nn_assert (rc < 0 && errno == EADDRINUSE);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sb, "DEFG");
test_recv (sc, "DEFG");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "XYZ");
}
test_close (sc);
test_close (sb);
/* Test whether queue limits are observed. */
sb = test_socket (AF_SP, NN_PAIR);
val = 200;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVBUF, &val, sizeof (val));
errno_assert (rc == 0);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
val = 200;
rc = nn_setsockopt (sc, NN_SOL_SOCKET, NN_SNDTIMEO, &val, sizeof (val));
errno_assert (rc == 0);
i = 0;
while (1) {
rc = nn_send (sc, "0123456789", 10, 0);
if (rc < 0 && nn_errno () == EAGAIN)
break;
errno_assert (rc >= 0);
nn_assert (rc == 10);
++i;
}
nn_assert (i == 20);
test_recv (sb, "0123456789");
test_send (sc, "0123456789");
rc = nn_send (sc, "0123456789", 10, 0);
nn_assert (rc < 0 && nn_errno () == EAGAIN);
for (i = 0; i != 20; ++i) {
test_recv (sb, "0123456789");
}
/* Make sure that even a message that doesn't fit into the buffers
gets across. */
for (i = 0; i != sizeof (buf); ++i)
buf [i] = 'A';
rc = nn_send (sc, buf, 256, 0);
errno_assert (rc >= 0);
nn_assert (rc == 256);
rc = nn_recv (sb, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 256);
test_close (sc);
test_close (sb);
#if 0
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, SOCKET_ADDRESS);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
#endif
/* Check whether SP message header is transferred correctly. */
sb = test_socket (AF_SP_RAW, NN_REP);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_REQ);
test_connect (sc, SOCKET_ADDRESS);
test_send (sc, "ABC");
iovec.iov_base = body;
iovec.iov_len = sizeof (body);
hdr.msg_iov = &iovec;
hdr.msg_iovlen = 1;
hdr.msg_control = &control;
hdr.msg_controllen = NN_MSG;
rc = nn_recvmsg (sb, &hdr, 0);
errno_assert (rc == 3);
cmsg = NN_CMSG_FIRSTHDR (&hdr);
while (1) {
nn_assert (cmsg);
if (cmsg->cmsg_level == PROTO_SP && cmsg->cmsg_type == SP_HDR)
break;
cmsg = NN_CMSG_NXTHDR (&hdr, cmsg);
}
nn_assert (cmsg->cmsg_len == NN_CMSG_SPACE (8));
data = NN_CMSG_DATA (cmsg);
nn_assert (!(data[0] & 0x80));
nn_assert (data[4] & 0x80);
nn_freemsg (control);
test_close (sc);
test_close (sb);
/* Test binding a new socket after originally bound socket shuts down. */
sb = test_socket (AF_SP, NN_BUS);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_BUS);
test_connect (sc, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_BUS);
test_connect (s1, SOCKET_ADDRESS);
/* Close bound socket, leaving connected sockets connect. */
test_close (sb);
nn_sleep (100);
/* Rebind a new socket to the address to which our connected sockets are listening. */
s2 = test_socket (AF_SP, NN_BUS);
test_bind (s2, SOCKET_ADDRESS);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_send (s1, "QRS");
test_recv (s2, "ABC");
test_recv (s2, "QRS");
test_send (s2, "DEFG");
test_recv (sc, "DEFG");
test_recv (s1, "DEFG");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (s2, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_send (s1, "MNO");
}
for (i = 0; i != 100; ++i) {
test_recv (s2, "MNO");
}
test_close (s1);
test_close (sc);
test_close (s2);
return 0;
}
int main ()
{
#ifndef NN_HAVE_WSL
int sb;
int sc;
int i;
int s1, s2;
void * dummy_buf;
int rc;
int opt;
size_t opt_sz = sizeof (opt);
int size;
char * buf;
/* Try closing a IPC socket while it not connected. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
test_close (sc);
/* Open the socket anew. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
/* Leave enough time for at least one re-connect attempt. */
nn_sleep (200);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
/* Ping-pong test. */
for (i = 0; i != 1; ++i) {
test_send (sc, "0123456789012345678901234567890123456789");
test_recv (sb, "0123456789012345678901234567890123456789");
test_send (sb, "0123456789012345678901234567890123456789");
test_recv (sc, "0123456789012345678901234567890123456789");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "XYZ");
}
/* Send something large enough to trigger overlapped I/O on Windows. */
size = 10000;
buf = malloc (size);
for (i = 0; i < size; ++i) {
buf[i] = 48 + i % 10;
}
buf[size-1] = '\0';
test_send (sc, buf);
test_recv (sb, buf);
free (buf);
test_close (sc);
test_close (sb);
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, SOCKET_ADDRESS);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
/* On Windows, CreateNamedPipeA does not run exclusively.
We should look at fixing this, but it will require
changing the usock code for Windows. In the meantime just
disable this test on Windows. */
#if !defined(NN_HAVE_WINDOWS)
/* Test two sockets binding to the same address. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
rc = nn_bind (s1, SOCKET_ADDRESS);
nn_assert (rc < 0);
errno_assert (nn_errno () == EADDRINUSE);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
nn_sleep (100);
test_send (sb, "ABC");
test_recv (sc, "ABC");
test_close (sb);
test_close (sc);
test_close (s1);
#endif
/* Test NN_RCVMAXSIZE limit */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
opt = 4;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, opt_sz);
nn_assert (rc == 0);
nn_sleep (100);
test_send (s1, "ABCD");
test_recv (sb, "ABCD");
test_send (s1, "ABCDE");
/* Without sleep nn_recv returns EAGAIN even for string
of acceptable size, so false positives are possible. */
nn_sleep (100);
rc = nn_recv (sb, &dummy_buf, NN_MSG, NN_DONTWAIT);
nn_assert (rc < 0);
errno_assert (nn_errno () == EAGAIN);
test_close (sb);
test_close (s1);
/* Test that NN_RCVMAXSIZE can be -1, but not lower */
sb = test_socket (AF_SP, NN_PAIR);
opt = -1;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, opt_sz);
nn_assert (rc >= 0);
opt = -2;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, opt_sz);
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
test_close (sb);
/* Test closing a socket that is waiting to connect. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
nn_sleep (100);
test_close (sc);
#endif /* NN_HAVE_WSL */
return 0;
}
int main ()
{
int rc;
int sb;
int sc;
int i;
char buf [256];
int val;
/* Create a simple topology. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
/* Try a duplicate bind. It should fail. */
rc = nn_bind (sc, SOCKET_ADDRESS);
nn_assert (rc < 0 && errno == EADDRINUSE);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sb, "DEFG");
test_recv (sc, "DEFG");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "XYZ");
}
test_close (sc);
test_close (sb);
/* Test whether queue limits are observed. */
sb = test_socket (AF_SP, NN_PAIR);
val = 200;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVBUF, &val, sizeof (val));
errno_assert (rc == 0);
test_bind (sb, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
val = 200;
rc = nn_setsockopt (sc, NN_SOL_SOCKET, NN_SNDTIMEO, &val, sizeof (val));
errno_assert (rc == 0);
i = 0;
while (1) {
rc = nn_send (sc, "0123456789", 10, 0);
if (rc < 0 && nn_errno () == ETIMEDOUT)
break;
errno_assert (rc >= 0);
nn_assert (rc == 10);
++i;
}
nn_assert (i == 20);
test_recv (sb, "0123456789");
test_send (sc, "0123456789");
rc = nn_send (sc, "0123456789", 10, 0);
nn_assert (rc < 0 && nn_errno () == ETIMEDOUT);
for (i = 0; i != 20; ++i) {
test_recv (sb, "0123456789");
}
/* Make sure that even a message that doesn't fit into the buffers
gets across. */
for (i = 0; i != sizeof (buf); ++i)
buf [i] = 'A';
rc = nn_send (sc, buf, 256, 0);
errno_assert (rc >= 0);
nn_assert (rc == 256);
rc = nn_recv (sb, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 256);
test_close (sc);
test_close (sb);
#if 0
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, SOCKET_ADDRESS);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
#endif
return 0;
}
int main ()
{
#if !defined NN_HAVE_WINDOWS
int rc;
int sb;
int sc;
int i;
char buf [3];
/* Try closing a IPC socket while it not connected. */
sc = nn_socket (AF_SP, NN_PAIR);
errno_assert (sc != -1);
rc = nn_connect (sc, SOCKET_ADDRESS);
errno_assert (rc >= 0);
rc = nn_close (sc);
errno_assert (rc == 0);
/* Open the socket anew. */
sc = nn_socket (AF_SP, NN_PAIR);
errno_assert (sc != -1);
rc = nn_connect (sc, SOCKET_ADDRESS);
errno_assert (rc >= 0);
/* Leave enough time for at least on re-connect attempt. */
nn_sleep (200);
sb = nn_socket (AF_SP, NN_PAIR);
errno_assert (sb != -1);
rc = nn_bind (sb, SOCKET_ADDRESS);
errno_assert (rc >= 0);
/* Ping-pong test. */
for (i = 0; i != 1; ++i) {
rc = nn_send (sc, "0123456789012345678901234567890123456789", 40, 0);
errno_assert (rc >= 0);
nn_assert (rc == 40);
rc = nn_recv (sb, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 40);
rc = nn_send (sb, "0123456789012345678901234567890123456789", 40, 0);
errno_assert (rc >= 0);
nn_assert (rc == 40);
rc = nn_recv (sc, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 40);
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
rc = nn_send (sc, "XYZ", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
}
for (i = 0; i != 100; ++i) {
rc = nn_recv (sb, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
}
rc = nn_close (sc);
errno_assert (rc == 0);
rc = nn_close (sb);
errno_assert (rc == 0);
#endif
return 0;
}
void routine1 (NN_UNUSED void *arg)
{
nn_sleep (10);
test_send (sc, "ABC");
}
void zmq_sleep (int seconds)
{
nn_sleep (seconds * 1000);
}
int main ()
{
int rc;
int rep1;
int rep2;
int req1;
int req2;
int resend_ivl;
char buf [7];
int timeo;
/* Test req/rep with full socket types. */
rep1 = nn_socket (AF_SP, NN_REP);
errno_assert (rep1 != -1);
rc = nn_bind (rep1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
req1 = nn_socket (AF_SP, NN_REQ);
errno_assert (req1 != -1);
rc = nn_connect (req1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
req2 = nn_socket (AF_SP, NN_REQ);
errno_assert (req2 != -1);
rc = nn_connect (req2, SOCKET_ADDRESS);
errno_assert (rc >= 0);
/* Check invalid sequence of sends and recvs. */
rc = nn_send (rep1, "ABC", 3, 0);
nn_assert (rc == -1 && nn_errno () == EFSM);
rc = nn_recv (req1, buf, sizeof (buf), 0);
nn_assert (rc == -1 && nn_errno () == EFSM);
/* Check fair queueing the requests. */
rc = nn_send (req2, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (rep1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (rep1, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (req2, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (req1, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (rep1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (rep1, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (req1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (rep1);
errno_assert (rc == 0);
rc = nn_close (req1);
errno_assert (rc == 0);
rc = nn_close (req2);
errno_assert (rc == 0);
/* Check load-balancing of requests. */
req1 = nn_socket (AF_SP, NN_REQ);
errno_assert (req1 != -1);
rc = nn_bind (req1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
rep1 = nn_socket (AF_SP, NN_REP);
errno_assert (rep1 != -1);
rc = nn_connect (rep1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
rep2 = nn_socket (AF_SP, NN_REP);
errno_assert (rep2 != -1);
rc = nn_connect (rep2, SOCKET_ADDRESS);
errno_assert (rc >= 0);
rc = nn_send (req1, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (rep1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (rep1, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (req1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (req1, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (rep2, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_send (rep2, buf, 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (req1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (rep2);
errno_assert (rc == 0);
rc = nn_close (rep1);
errno_assert (rc == 0);
rc = nn_close (req1);
errno_assert (rc == 0);
/* Test re-sending of the request. */
rep1 = nn_socket (AF_SP, NN_REP);
errno_assert (rep1 != -1);
rc = nn_bind (rep1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
req1 = nn_socket (AF_SP, NN_REQ);
errno_assert (req1 != -1);
rc = nn_connect (req1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
resend_ivl = 100;
rc = nn_setsockopt (req1, NN_REQ, NN_REQ_RESEND_IVL,
&resend_ivl, sizeof (resend_ivl));
errno_assert (rc == 0);
rc = nn_send (req1, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (rep1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_recv (rep1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (req1);
errno_assert (rc == 0);
rc = nn_close (rep1);
errno_assert (rc == 0);
/* Check sending a request when the peer is not available. (It should
be sent immediatelly when the peer comes online rather than relying
on the resend algorithm. */
req1 = nn_socket (AF_SP, NN_REQ);
errno_assert (req1 != -1);
rc = nn_connect (req1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
rc = nn_send (req1, "ABC", 3, 0);
errno_assert (rc >= 0);
nn_sleep (10);
rep1 = nn_socket (AF_SP, NN_REP);
errno_assert (rep1 != -1);
rc = nn_bind (rep1, SOCKET_ADDRESS);
errno_assert (rc >= 0);
timeo = 100;
rc = nn_setsockopt (rep1, NN_SOL_SOCKET, NN_RCVTIMEO,
&timeo, sizeof (timeo));
errno_assert (rc == 0);
rc = nn_recv (rep1, buf, sizeof (buf), 0);
errno_assert (rc >= 0);
nn_assert (rc == 3);
rc = nn_close (req1);
errno_assert (rc == 0);
rc = nn_close (rep1);
errno_assert (rc == 0);
return 0;
}
void routine2 (NN_UNUSED void *arg)
{
nn_sleep (10);
nn_term ();
}
int testipc()
{
int sb;
int sc;
int i;
int s1, s2;
size_t size;
char * buf;
printf("test ipc\n");
if ( 1 )
{
/* Try closing a IPC socket while it not connected. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
test_close (sc);
/* Open the socket anew. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
/* Leave enough time for at least one re-connect attempt. */
nn_sleep (200);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
/* Ping-pong test. */
for (i = 0; i != 1; ++i) {
test_send (sc, "0123456789012345678901234567890123456789");
test_recv (sb, "0123456789012345678901234567890123456789");
test_send (sb, "0123456789012345678901234567890123456789");
test_recv (sc, "0123456789012345678901234567890123456789");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "XYZ");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "XYZ");
}
/* Send something large enough to trigger overlapped I/O on Windows. */
size = 10000;
buf = malloc( size );
for (i =0; i != size - 1; ++i) {
buf[i] = 48 + i % 10;
}
buf[size-1] = '\0';
test_send (sc, buf);
test_recv (sb, buf);
free( buf );
test_close (sc);
test_close (sb);
}
if ( 1 )
{
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, SOCKET_ADDRESS);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, SOCKET_ADDRESS);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
}
if ( 1 )
{
/* Test two sockets binding to the same address. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, SOCKET_ADDRESS);
s1 = test_socket (AF_SP, NN_PAIR);
test_bind (s1, SOCKET_ADDRESS);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, SOCKET_ADDRESS);
//printf("sb.%d s1.%d sc.%d\n",sb,s1,sc);
nn_sleep (100);
//printf("send.(ABC) to sb\n");
test_send (sb, "ABC");
//printf("check recv.(ABC) via sc\n");
test_recv (sc, "ABC");
//printf("close sb\n");
test_close (sb);
//printf("send.(DEF) to s1 getchar()\n"), getchar();
test_send (s1, "DEF");
//printf("check recv.(DEF) via sc, getchar()\n"); getchar();
//nn_sleep(1000);
test_recv (sc, "DEF");
//printf("close sc getchar()\n"); getchar();
test_close (sc);
//printf("close s1\n");
test_close (s1);
}
//printf("finished ipc test\n");
return 0;
}
int ftw_nanomsg_close (int s)
{
nn_sleep(100);
return nn_close(s);
nn_sleep(10);
}
int main (int argc, const char *argv[])
{
int rc;
int sb;
int i;
int opt;
size_t sz;
int s1, s2;
void * dummy_buf;
char addr[128];
char socket_address[128];
int port = get_test_port(argc, argv);
test_addr_from(socket_address, "tcp", "127.0.0.1", port);
/* Try closing bound but unconnected socket. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
test_close (sb);
/* Try closing a TCP socket while it not connected. At the same time
test specifying the local address for the connection. */
sc = test_socket (AF_SP, NN_PAIR);
test_addr_from(addr, "tcp", "127.0.0.1;127.0.0.1", port);
test_connect (sc, addr);
test_close (sc);
/* Open the socket anew. */
sc = test_socket (AF_SP, NN_PAIR);
/* Check NODELAY socket option. */
sz = sizeof (opt);
rc = nn_getsockopt (sc, NN_TCP, NN_TCP_NODELAY, &opt, &sz);
errno_assert (rc == 0);
nn_assert (sz == sizeof (opt));
nn_assert (opt == 0);
opt = 2;
rc = nn_setsockopt (sc, NN_TCP, NN_TCP_NODELAY, &opt, sizeof (opt));
nn_assert (rc < 0 && nn_errno () == EINVAL);
opt = 1;
rc = nn_setsockopt (sc, NN_TCP, NN_TCP_NODELAY, &opt, sizeof (opt));
errno_assert (rc == 0);
sz = sizeof (opt);
rc = nn_getsockopt (sc, NN_TCP, NN_TCP_NODELAY, &opt, &sz);
errno_assert (rc == 0);
nn_assert (sz == sizeof (opt));
nn_assert (opt == 1);
/* Try using invalid address strings. */
rc = nn_connect (sc, "tcp://*:");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://*:1000000");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://*:some_port");
nn_assert (rc < 0);
rc = nn_connect (sc, "tcp://eth10000;127.0.0.1:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == ENODEV);
rc = nn_connect (sc, "tcp://127.0.0.1");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "tcp://127.0.0.1:");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "tcp://127.0.0.1:1000000");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_bind (sc, "tcp://eth10000:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == ENODEV);
rc = nn_connect (sc, "tcp://:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://-hostname:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://abc.123.---.#:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://[::1]:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://abc.123.:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://abc...123:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
rc = nn_connect (sc, "tcp://.123:5555");
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
/* Connect correctly. Do so before binding the peer socket. */
test_connect (sc, socket_address);
/* Leave enough time for at least on re-connect attempt. */
nn_sleep (200);
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
/* Ping-pong test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "ABC");
test_recv (sb, "ABC");
test_send (sb, "DEF");
test_recv (sc, "DEF");
}
/* Batch transfer test. */
for (i = 0; i != 100; ++i) {
test_send (sc, "0123456789012345678901234567890123456789");
}
for (i = 0; i != 100; ++i) {
test_recv (sb, "0123456789012345678901234567890123456789");
}
test_close (sc);
test_close (sb);
/* Test whether connection rejection is handled decently. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, socket_address);
s2 = test_socket (AF_SP, NN_PAIR);
test_connect (s2, socket_address);
nn_sleep (100);
test_close (s2);
test_close (s1);
test_close (sb);
/* Test two sockets binding to the same address. */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
s1 = test_socket (AF_SP, NN_PAIR);
rc = nn_bind (s1, socket_address);
nn_assert (rc < 0);
errno_assert (nn_errno () == EADDRINUSE);
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
nn_sleep (100);
test_send (sb, "ABC");
test_recv (sc, "ABC");
test_close (sb);
test_close (sc);
test_close (s1);
/* Test NN_RCVMAXSIZE limit */
sb = test_socket (AF_SP, NN_PAIR);
test_bind (sb, socket_address);
s1 = test_socket (AF_SP, NN_PAIR);
test_connect (s1, socket_address);
opt = 4;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc == 0);
nn_sleep (100);
test_send (s1, "ABC");
test_recv (sb, "ABC");
test_send (s1, "0123456789012345678901234567890123456789");
rc = nn_recv (sb, &dummy_buf, NN_MSG, NN_DONTWAIT);
nn_assert (rc < 0);
errno_assert (nn_errno () == EAGAIN);
test_close (sb);
test_close (s1);
/* Test that NN_RCVMAXSIZE can be -1, but not lower */
sb = test_socket (AF_SP, NN_PAIR);
opt = -1;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc >= 0);
opt = -2;
rc = nn_setsockopt (sb, NN_SOL_SOCKET, NN_RCVMAXSIZE, &opt, sizeof (opt));
nn_assert (rc < 0);
errno_assert (nn_errno () == EINVAL);
test_close (sb);
/* Test closing a socket that is waiting to connect. */
sc = test_socket (AF_SP, NN_PAIR);
test_connect (sc, socket_address);
nn_sleep (100);
test_close (sc);
return 0;
}
static void msleep2(uint32_t milliseconds)
{
void nn_sleep (int milliseconds);
nn_sleep(milliseconds);
}
