int main () { int rc; int push; int pull1; int pull2; int sndprio; 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); push = test_socket (AF_SP, NN_PUSH); sndprio = 1; rc = nn_setsockopt (push, NN_SOL_SOCKET, NN_SNDPRIO, &sndprio, sizeof (sndprio)); errno_assert (rc == 0); test_connect (push, SOCKET_ADDRESS_A); sndprio = 2; rc = nn_setsockopt (push, NN_SOL_SOCKET, NN_SNDPRIO, &sndprio, sizeof (sndprio)); errno_assert (rc == 0); test_connect (push, SOCKET_ADDRESS_B); test_send (push, "ABC"); test_send (push, "DEF"); test_recv (pull1, "ABC"); test_recv (pull1, "DEF"); test_close (pull1); test_close (push); test_close (pull2); /* Test removing a pipe from the list. */ push = test_socket (AF_SP, NN_PUSH); test_bind (push, SOCKET_ADDRESS_A); pull1 = test_socket (AF_SP, NN_PULL); test_connect (pull1, SOCKET_ADDRESS_A); test_send (push, "ABC"); test_recv (pull1, "ABC"); test_close (pull1); rc = nn_send (push, "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 (push, "ABC"); test_recv (pull1, "ABC"); test_close (pull1); test_close (push); return 0; }
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 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; }
PROCESS_THREAD(test, ev, data) { static struct etimer et; PROCESS_BEGIN(); myaddr = init_l2addr_154_char("45:67"); l2 = startL2_154( myaddr, CHANNEL, PANID); dest = l2addr_154_broadcast; setMTU(l2, MTU); while(1) { test_send (l2, dest) ; test_recv (l2) ; printf("\n"); printf("*************************************************************************"); printf("\n"); etimer_set(&et,5*CLOCK_SECOND); PROCESS_WAIT_EVENT_UNTIL(etimer_expired(&et)); } PROCESS_END(); }
static void test_subscribe(void) { char buf[512]; char *msg[] = { "SUBSCRIBE\n", "destination:/queue/test\n", "content-length:0\n", "id:test1\n", "\n", NULL, }; int sock; char *headers[] = { "destination:/queue/test\n", }; sock = connect_server(); // success to connect with server CU_ASSERT(stomp_connect(sock) == RET_SUCCESS); // success to send test message CU_ASSERT(stomp_send(sock, "hoge\n", 5, headers, 1) == RET_SUCCESS); int i; for(i=0; msg[i] != NULL; i++) { send(sock, msg[i], strlen(msg[i]), 0); } send(sock, "\0", 1, 0); int len = test_recv(sock, buf, sizeof(buf)); CU_ASSERT(len > 0); CU_ASSERT(strncmp(buf, "MESSAGE\n", 8) == 0); close(sock); }
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 (NN_UNUSED int argc, const NN_UNUSED 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"); 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 result = test_recv(); if (result) { printf("Test FAILED.\n"); return 1; } printf("Test PASSED.\n"); 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 () { struct nn_thread thread; sb = test_socket (AF_SP, NN_PAIR); test_bind (sb, SOCKET_ADDRESS); sc = test_socket (AF_SP, NN_PAIR); test_connect (sc, SOCKET_ADDRESS); nn_thread_init (&thread, worker, NULL); test_recv (sb, "ABC"); test_recv (sb, "ABC"); nn_thread_term (&thread); test_close (sc); test_close (sb); return 0; }
int main(int argc, char* argv[]) { char* host = NULL; int port = 0; char* url = NULL; char* filename = NULL; if(argc < 2 || strcmp(argv[1], "--help") == 0) { MMS_PRINTF("usage: %s recv host port url file\n", argv[0]); MMS_PRINTF(" %s recv 10.0.0.172 80 http://211.139.144.165/LOAsR9qunOKB recv.mms\n", argv[0]); MMS_PRINTF("usage: %s send host port url file\n", argv[0]); MMS_PRINTF(" %s send 10.0.0.172 80 http://mmsc.monternet.com:80 ./testdata/tosendok.mms\n", argv[0]); MMS_PRINTF("usage: %s sendfile host port url file\n", argv[0]); MMS_PRINTF("usage: %s sendfake host port url file\n", argv[0]); MMS_PRINTF("usage: %s createfake\n", argv[0]); return -1; } host = argv[2]; port = atoi(argv[3]); url = argv[4]; filename = argv[5]; if(strcmp(argv[1], "recv") == 0) { test_recv(host, port, url, filename); } else if(strcmp(argv[1], "send") == 0) { test_send(host, port, url, filename); } else if(strcmp(argv[1], "sendfile") == 0) { test_send_file(host, port, url, filename); } else if(strcmp(argv[1], "sendfake") == 0) { test_send_fake(host, port, url); } else if(strcmp(argv[1], "createfake") == 0) { mms_destroy(construct_fake_mms()); } return 0; }
static void routine2 (NN_UNUSED void *arg) { int s; int i; s = test_socket (AF_SP, NN_PULL); for (i = 0; i < 10; ++i) { test_connect (s, SOCKET_ADDRESS); } for (i = 0; i < 10; ++i) { test_recv (s, "hello"); } test_close (s); active --; }
static void routine2 (NN_UNUSED void *arg) { int s; int i; s = test_socket (AF_SP, NN_PULL); for (i = 0; i < 10; ++i) { test_connect (s, SOCKET_ADDRESS); } for (i = 0; i < MESSAGES_PER_THREAD; ++i) { test_recv (s, "hello"); } test_close (s); nn_atomic_dec(&active, 1); }
static void routine2 (NN_UNUSED void *arg) { int s; int i; s = test_socket (AF_SP, NN_PULL); for (i = 0; i < 10; ++i) { test_connect (s, SOCKET_ADDRESS); } for (i = 0; i < MESSAGES_PER_THREAD; ++i) { test_recv (s, "hello"); } //printf("inactivate socket active.%d\n",active); test_close (s); active --; }
/* test_text() verifies that we drop messages properly when sending invalid UTF-8, but not when we send valid data. */ void test_text () { int sb; int sc; int opt; uint8_t bad[20]; /* Negative testing... bad UTF-8 data for text. */ sb = test_socket (AF_SP, NN_PAIR); sc = test_socket (AF_SP, NN_PAIR); opt = NN_WS_MSG_TYPE_TEXT; test_setsockopt (sb, NN_WS, NN_WS_MSG_TYPE, &opt, sizeof (opt)); opt = NN_WS_MSG_TYPE_TEXT; test_setsockopt (sc, NN_WS, NN_WS_MSG_TYPE, &opt, sizeof (opt)); opt = 500; test_setsockopt (sb, NN_SOL_SOCKET, NN_RCVTIMEO, &opt, sizeof (opt)); test_bind (sb, socket_address); test_connect (sc, socket_address); test_send (sc, "GOOD"); test_recv (sb, "GOOD"); /* and the bad ... */ strcpy ((char *)bad, "BAD."); bad[2] = (char)0xDD; test_send (sc, (char *)bad); /* Make sure we dropped the frame. */ test_drop (sb, ETIMEDOUT); test_close (sb); test_close (sc); return; }
int main(int argc, char *argv[]) { int clnt_sk[MAX_CLIENTS], acpt_sk[MAX_CLIENTS], sk; int lstn_sk; struct sockaddr_in lstn_addr, acpt_addr; socklen_t addrlen; int error, i; char *message = "hello, world!\n"; char msgbuf[100]; int pf_class; /* Rather than fflush() throughout the code, set stdout to * be unbuffered. */ setvbuf(stdout, NULL, _IONBF, 0); setvbuf(stderr, NULL, _IONBF, 0); /* Initialize the server and client addresses. */ pf_class = PF_INET; lstn_addr.sin_family = AF_INET; lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; lstn_addr.sin_port = htons(SCTP_TESTPORT_1); sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); lstn_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); test_bind(lstn_sk, (struct sockaddr *)&lstn_addr, sizeof(lstn_addr)); test_listen(lstn_sk, MAX_CLIENTS); for (i = 0; i < MAX_CLIENTS; i++) { clnt_sk[i] = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); test_connect(clnt_sk[i], (struct sockaddr *)&lstn_addr, sizeof(lstn_addr)); } for (i = 0; i < MAX_CLIENTS; i++) { addrlen = sizeof(acpt_addr); acpt_sk[i] = test_accept(lstn_sk, (struct sockaddr *)&acpt_addr, &addrlen); } /*shutdown() TEST1: Bad socket descriptor, EBADF Expected error */ error = shutdown(-1, SHUT_WR); if (error != -1 || errno != EBADF) tst_brkm(TBROK, NULL, "shutdown with a bad socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "shutdown() with a bad socket descriptor - EBADF"); /*shutdown() TEST2: Invalid socket, ENOTSOCK Expected error */ error = shutdown(0, SHUT_WR); if (error != -1 || errno != ENOTSOCK) tst_brkm(TBROK, NULL, "shutdown with an invalid socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "shutdown() with an invalid socket - ENOTSOCK"); errno = 0; /*Do a send first before doing shutdown */ test_send(acpt_sk[0], message, strlen(message), 0); /*shutdown() TEST3: shutdown with SHUT_WR flag to disable new send */ error = shutdown(clnt_sk[0], SHUT_WR); if (error < 0) tst_brkm(TBROK, NULL, "shutdown with SHUT_WR flag " "error:%d, errno:%d", error, errno); /* Reading on a socket that has received SHUTDOWN should return 0 * indicating EOF. */ error = recv(acpt_sk[0], msgbuf, 100, 0); if ((error != 0) || (errno != 0)) tst_brkm(TBROK, NULL, "recv on a SHUTDOWN received socket " "error:%d, errno:%d", error, errno); /* Read the pending message on clnt_sk[0] that was received before * SHUTDOWN call. */ test_recv(clnt_sk[0], msgbuf, 100, 0); /* No more messages and the association is SHUTDOWN, should fail. */ error = recv(clnt_sk[0], msgbuf, 100, 0); if ((error != -1) || (errno != ENOTCONN)) tst_brkm(TBROK, NULL, "recv on a SHUT_WR socket with no " "messages error:%d, errno:%d", error, errno); tst_resm(TPASS, "shutdown() with SHUT_WR flag - SUCCESS"); errno = 0; /*shutdown() TEST4: shutdown with SHUT_RD flag to disable new receive */ test_shutdown(clnt_sk[1], SHUT_RD); error = recv(clnt_sk[1], msgbuf, 100, 0); if ((error != 0) || (errno != 0)) tst_brkm(TBROK, NULL, "recv on a SHUT_RD socket " "error:%d, errno:%d", error, errno); /* Sending a message on SHUT_RD socket. */ error = test_send(clnt_sk[1], message, strlen(message), 0); if (error < 0) tst_brkm(TBROK, NULL, "send on a SHUT_RD socket " "error:%d, errno:%d", error, errno); /* Receive the message sent on SHUT_RD socket. */ test_recv(acpt_sk[1], msgbuf, 100, 0); /* Send a message to the SHUT_RD socket. */ test_send(acpt_sk[1], message, strlen(message), 0); /* We should not receive the message as the socket is SHUT_RD */ error = recv(clnt_sk[1], msgbuf, 100, 0); if ((error != 0) || (errno != 0)) tst_brkm(TBROK, NULL, "recv on a SHUT_RD socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "shutdown() with SHUT_RD flag - SUCCESS"); /*shutdown() TEST5: shutdown with SHUT_RDWR flag to disable new receive/send */ test_shutdown(clnt_sk[2], SHUT_RDWR); error = recv(acpt_sk[2], msgbuf, 100, 0); if ((error != 0) || (errno != 0)) tst_brkm(TBROK, NULL, "recv on a SHUTDOWN received socket " "error:%d, errno:%d", error, errno); error = recv(clnt_sk[2], msgbuf, 100, 0); if ((error != 0) || (errno != 0)) tst_brkm(TBROK, NULL, "recv on a SHUT_RDWR socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "shutdown() with SHUT_RDWR flag - SUCCESS"); /*shutdown() TEST6: Unconnected socket, ENOTCONN Expected error */ error = shutdown(sk, SHUT_RD); if ((error != -1) || (errno != ENOTCONN)) tst_brkm(TBROK, NULL, "shutdown on an unconnected socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "shutdown() on an unconnected socket - SUCCESS"); for (i = 0; i < MAX_CLIENTS; i++) close(clnt_sk[i]); for (i = 0; i < MAX_CLIENTS; i++) close(acpt_sk[i]); close(lstn_sk); close(sk); tst_exit(); }
int main () { int rc; int surveyor; int respondent1; int respondent2; int respondent3; int deadline; char buf [7]; /* Test a simple survey with three respondents. */ surveyor = test_socket (AF_SP, GRID_SURVEYOR); deadline = 500; rc = grid_setsockopt (surveyor, GRID_SURVEYOR, GRID_SURVEYOR_DEADLINE, &deadline, sizeof (deadline)); errno_assert (rc == 0); test_bind (surveyor, SOCKET_ADDRESS); respondent1 = test_socket (AF_SP, GRID_RESPONDENT); test_connect (respondent1, SOCKET_ADDRESS); respondent2 = test_socket (AF_SP, GRID_RESPONDENT); test_connect (respondent2, SOCKET_ADDRESS); respondent3 = test_socket (AF_SP, GRID_RESPONDENT); test_connect (respondent3, SOCKET_ADDRESS); /* Check that attempt to recv with no survey pending is EFSM. */ rc = grid_recv (surveyor, buf, sizeof (buf), 0); errno_assert (rc == -1 && grid_errno () == EFSM); /* Send the survey. */ test_send (surveyor, "ABC"); /* First respondent answers. */ test_recv (respondent1, "ABC"); test_send (respondent1, "DEF"); /* Second respondent answers. */ test_recv (respondent2, "ABC"); test_send (respondent2, "DEF"); /* Surveyor gets the responses. */ test_recv (surveyor, "DEF"); test_recv (surveyor, "DEF"); /* There are no more responses. Surveyor hits the deadline. */ rc = grid_recv (surveyor, buf, sizeof (buf), 0); errno_assert (rc == -1 && grid_errno () == ETIMEDOUT); /* Third respondent answers (it have already missed the deadline). */ test_recv (respondent3, "ABC"); test_send (respondent3, "GHI"); /* Surveyor initiates new survey. */ test_send (surveyor, "ABC"); /* Check that stale response from third respondent is not delivered. */ rc = grid_recv (surveyor, buf, sizeof (buf), 0); errno_assert (rc == -1 && grid_errno () == ETIMEDOUT); /* Check that subsequent attempt to recv with no survey pending is EFSM. */ rc = grid_recv (surveyor, buf, sizeof (buf), 0); errno_assert (rc == -1 && grid_errno () == EFSM); test_close (surveyor); test_close (respondent1); test_close (respondent2); test_close (respondent3); return 0; }
int main(void) { /* <1> Enable flash. */ sysFlushCache (I_D_CACHE); sysDisableCache (); sysEnableCache (CACHE_WRITE_BACK); sysInit(); printf("REG_APLLCON=0x%x REG_UPLLCON=0x%x\n", inpw(REG_APLLCON), inpw(REG_UPLLCON)); printf("REG_CLKCON=0x%x REG_CLKSEL=0x%x\n", inpw(REG_CLKCON), inpw(REG_CLKSEL)); printf("REG_CLKDIV0=0x%x REG_CLKDIV1=0x%x\n", inpw(REG_CLKDIV0), inpw(REG_CLKDIV1)); printf("REG_TICR0=%d\n", inpw(REG_TICR0)); FTH_Init(); #if 0 test_inet(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_gethost(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_socket(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netread(); test_netwrite(); test_send(); test_recv(); test_recvmsg(); test_sendmsg(); test_recvfrom(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_sendto(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netselect(); test_getsockname(); test_getsockopt(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netfcntl(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netioctl(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netioctl_withbuf(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_wb740getgateway(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_wb740reboot(g_RemoteNet_Buf, RNT_BUFFER_LEN); #endif test_inet(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_gethost(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_socket(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netread(); test_netwrite(); test_send(); test_recv(); test_recvmsg(); test_sendmsg(); test_recvfrom(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_sendto(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netselect(); test_getsockname(); test_getsockopt(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netfcntl(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netioctl(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_netioctl_withbuf(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_wb740getgateway(g_RemoteNet_Buf, RNT_BUFFER_LEN); test_wb740reboot(g_RemoteNet_Buf, RNT_BUFFER_LEN); // insert test program here //GetDevInterface(); //simple_getgateway(); //simple_ioctl_withbuf(); //simple_udpserver(); //simple_tcpserver(); //simple_inet_addr(); //simple_uname(); //simple_gethostbyaddr(); //simple_multi_thread(); //wb740reboot(g_RemoteNet_Buf, RNT_BUFFER_LEN); return 0; }
int main(int argc, char *argv[]) { socklen_t len,len_snd; int msg_count; int sk,sk1,pf_class,lstn_sk,acpt_sk,acpt1_sk, flag, count; char *message = "hello, world!\n"; char *message_rcv; struct sockaddr_in conn_addr,lstn_addr,svr_addr; /* Rather than fflush() throughout the code, set stdout to * be unbuffered. */ setvbuf(stdout, NULL, _IONBF, 0); setvbuf(stderr, NULL, _IONBF, 0); pf_class = PF_INET; sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); sk1 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); lstn_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); conn_addr.sin_family = AF_INET; conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; conn_addr.sin_port = htons(SCTP_TESTPORT_1); lstn_addr.sin_family = AF_INET; lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; lstn_addr.sin_port = htons(SCTP_TESTPORT_1); /*Binding the listen socket*/ test_bind(lstn_sk, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr)); /*Listening the socket*/ test_listen(lstn_sk, 10); len = sizeof(struct sockaddr_in); test_connect(sk, (struct sockaddr *) &conn_addr, len); acpt_sk = test_accept(lstn_sk, (struct sockaddr *)&svr_addr, &len); len_snd = (strlen(message) + 1); flag = MSG_NOSIGNAL; /*send () TEST1: Bad socket descriptor, EBADF Expected error*/ count = send(-1, message, len_snd, flag); if (count != -1 || errno != EBADF) tst_brkm(TBROK, tst_exit, "send with a bad socket " "descriptor count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() with a bad socket descriptor - EBADF"); /*send () TEST2: Invalid socket, ENOTSOCK Expected error*/ count = send(0, message, len_snd, flag); if (count != -1 || errno != ENOTSOCK) tst_brkm(TBROK, tst_exit, "send with invalid socket " "count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() with invalid socket - ENOTSOCK"); /*send () TEST3: send on listening socket, EPIPE Expected error*/ count = send(lstn_sk, message, len_snd, flag); if (count != -1 || errno != EPIPE) tst_brkm(TBROK, tst_exit, "send on a listening socket " "count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() on a listening socket - EPIPE"); #if 0 /*send () TEST4: Invalid message address, EFAULT Expected error*/ /* FIXME this test should pass. Don't catch why... */ count = send(sk, (char *)0x1, len_snd, flag); if (count != -1 || errno != EFAULT) tst_brkm(TBROK, tst_exit, "send with invalid message " "pointer count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() with invalid message ptr - EFAULT"); #endif test_connect(sk1, (struct sockaddr *) &lstn_addr, len); count = test_send(sk1, message, len_snd, flag); close(sk1); acpt1_sk = test_accept(lstn_sk, (struct sockaddr *)&conn_addr, &len); /*send () TEST5: send on closed association, EPIPE Expected error*/ count = send(acpt1_sk, message, len_snd, flag); if (count != -1 || errno != EPIPE) tst_brkm(TBROK, tst_exit, "send on a closed association " "count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() on a closed association - EPIPE"); close(acpt1_sk); close(sk); close(lstn_sk); close(acpt_sk); sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); lstn_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); message_rcv = malloc(512); /*Binding the listen socket*/ test_bind(lstn_sk, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr)); /*Listening the socket*/ test_listen(lstn_sk, 10); conn_addr.sin_family = AF_INET; conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; conn_addr.sin_port = htons(SCTP_TESTPORT_1); len = sizeof(struct sockaddr_in); test_connect(sk, (struct sockaddr *) &conn_addr, len); acpt_sk = test_accept(lstn_sk, (struct sockaddr *)&svr_addr, &len); msg_count = strlen(message) + 1; /*send() TEST6: Sending data from client socket to server socket*/ count = send(sk, message, msg_count, flag); if (count != msg_count) tst_brkm(TBROK, tst_exit, "send from client to server " "count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() from client to server - SUCCESS"); test_recv(acpt_sk, message_rcv, msg_count, flag); strncpy(message_rcv,"\0",512); /*send() TEST7: Sending data from accept socket to client socket*/ count = send(acpt_sk, message, msg_count, flag); if (count != msg_count) tst_brkm(TBROK, tst_exit, "send from accept socket to client " "count:%d, errno:%d", count, errno); tst_resm(TPASS, "send() from accept socket to client - SUCCESS"); test_recv(sk, message_rcv, msg_count, flag); /*send() TEST8: Sending less number of data from the buffer*/ /*Sending only 5 bytes so that only hello is received*/ test_send(sk, message, 5 , flag); test_recv(acpt_sk, message_rcv, 5, flag); tst_resm(TPASS, "send() partial data from a buffer - SUCCESS"); /* TEST9: sctp_send with no sinfo */ test_sctp_send(sk, message, strlen(message) + 1 , NULL, flag); test_recv(acpt_sk, message_rcv, strlen(message) + 1, flag); tst_resm(TPASS, "sctp_send() with no sinfo - SUCCESS"); close(sk1); close(lstn_sk); close(acpt_sk); return 0; }
void handle_loopback (struct deviceinfo *unit, struct digi_node *node, struct digi_chan *chan, int port) { char full_line[81]; int i = 0, option = EOF; struct termios sv_tios; char test_data[TBUFSIZ + 1]; char read_data[TBUFSIZ + 1]; char string[200], ttyname[200]; int r = 3; int rwfd; WINDOW *lbwin = GetWin(LBWin); #define TITLE_LINE 1 #define DESC_LINE 2 #define DESC2_LINE 3 #define SEP_LINE 4 #define FIRST_DATA 5 #define SEP2_LINE 15 #define RESULT_LINE 16 show_panel (GetPan(LBWin)); update_panels (); doupdate (); next_result = 0; test_cases = 0; test_passes = 0; if (DPAGetPortName(unit, node, chan, port, ttyname) == NULL) { ttyname[0] ='\0'; } while (option == EOF) { erase_win (LBWin); wattrset (lbwin, make_attr (A_BOLD, WHITE, BLUE)); mvwprintw (lbwin, TITLE_LINE, 1, "%-*.*s", 76, 76, " "); mvwprintw (lbwin, RESULT_LINE, 1, "%-*.*s", 76, 76, " "); mvwprintw (lbwin, TITLE_LINE, 32, " Loop Back Test "); sprintf (full_line, "Tests Executed: %-12d Passed: %-12d Failed: %d", test_cases, test_passes, test_cases - test_passes); mvwprintw (lbwin, RESULT_LINE, center(LBWin, strlen(full_line)), full_line); sprintf (clbuf, "Unit IP Address: %s Port #: %d Name: %s", unit->host, port + 1, ttyname); i = strlen (clbuf); mvwprintw (GetWin(LBWin), DESC_LINE, 1, "%*s", GetWidth(LBWin) - 2, " "); mvwprintw (GetWin(LBWin), DESC2_LINE, 1, "%*s", GetWidth(LBWin) - 2, " "); mvwprintw (lbwin, DESC2_LINE, 2, clbuf); mvwprintw (lbwin, DESC_LINE, 2, "Device Description: %-*.*s", GetWidth(LBWin) - 2 - 2 - 2 - 20, GetWidth(LBWin) - 2 - 2 - 2 - 20, node->nd_ps_desc); if (!vanilla) wattrset (lbwin, make_attr (A_ALTCHARSET, CYAN, BLACK)); else wattrset (lbwin, make_attr (A_NORMAL, CYAN, BLACK)); wmove (lbwin, SEP_LINE, 1); for (i = 0; i < 77; i++) waddch (lbwin, mapchar(ACS_HLINE)); mvwaddch (lbwin, SEP_LINE, 0, mapchar(ACS_LTEE)); mvwaddch (lbwin, SEP_LINE, 77, mapchar(ACS_RTEE)); wmove (lbwin, SEP2_LINE, 1); for (i = 0; i < 77; i++) waddch (lbwin, mapchar(ACS_HLINE)); mvwaddch (lbwin, SEP2_LINE, 0, mapchar(ACS_LTEE)); mvwaddch (lbwin, SEP2_LINE, 77, mapchar(ACS_RTEE)); wattrset (lbwin, make_attr (A_NORMAL, WHITE, BLACK)); wrefresh (lbwin); wattrset (GetWin(MainWin), make_attr (A_NORMAL, WHITE, BLUE)); commandline (clbuf, "Press ANY key to Halt the test", NULL); mvwprintw (GetWin(MainWin), KEY_LINE, 0, clbuf); wattroff (GetWin(MainWin), make_attr (A_NORMAL, WHITE, BLUE)); wrefresh (GetWin(MainWin)); change_term (0, 10); option = EOF; r = 5; if (chan->ch_open) { mvwprintw (lbwin, r++, 2, "***** Port is Busy."); wrefresh(lbwin); test_cases++; sleep(1); goto user_input; } for (i = 0; i < 256; i++) { test_data[i] = (char) i; } test_data[TBUFSIZ]='\0'; /* Get port name. Can't run the test without it. */ if (DPAGetPortName(unit, node, chan, port, ttyname) == NULL) { mvwprintw (lbwin, r++, 2, "***** Loop Back Test Failure. Port has no known tty name"); test_cases++; wrefresh (lbwin); sleep(1); goto user_input; } sprintf(string, "/dev/%s", ttyname); if( (rwfd = tty_open(string, &sv_tios )) < 0 ) { test_cases++; goto user_input; } tcflush(rwfd, TCIOFLUSH); if ((i = test_send (test_data, TBUFSIZ, rwfd)) != 0) { mvwprintw (lbwin, r++, 2, "***** Loop Back Test Failure=%d, Sending %d Bytes", i, TBUFSIZ); wrefresh (lbwin); tty_close (rwfd, &sv_tios); test_cases++; goto user_input; } mvwprintw (lbwin, r++, 2, "Loop Back: %d Bytes Sent.", TBUFSIZ); wrefresh (lbwin); mvwprintw (lbwin, r++, 2, "Loop Back: Receiving %d Bytes.", TBUFSIZ); wrefresh (lbwin); if ((i = test_recv (read_data, TBUFSIZ, 5, rwfd)) != TBUFSIZ) { mvwprintw (lbwin, r++, 2, "***** Loop Back Failure=%d Receiving %d bytes.", i, TBUFSIZ); wrefresh (lbwin); tty_close (rwfd, &sv_tios); test_cases++; goto user_input; } /* Reset termios as before and close channel */ tty_close (rwfd, &sv_tios); mvwprintw (lbwin, r++, 2, "Loop Back: Verifying %d bytes.", TBUFSIZ); wrefresh (lbwin); if (memcmp (test_data, read_data, TBUFSIZ)) { mvwprintw (lbwin, r++, 2, "***** Loop Back Failure Verifying %d Bytes.", TBUFSIZ); mvwprintw (lbwin, r++, 2, "***** Data Incorrectly Transferred."); wrefresh (lbwin); test_cases++; goto user_input; } else { mvwprintw (lbwin, r++, 2, "Loop Back: Test Passed."); wrefresh (lbwin); test_cases++; test_passes++; } user_input: option = getch(); /* * If the user hasn't selected anything, loop. * Otherwise, break. */ switch (option) { case EOF: break; case '': refresh_screen (); option = EOF; break; #ifdef KEY_PRINT case KEY_PRINT: #endif case '': screen_save (LBWin, logfile); touchwin (lbwin); wrefresh (lbwin); update_panels (); doupdate (); option = EOF; break; default: break; } /* End Case */ } /* End While */ hide_panel (GetPan(LBWin)); update_panels (); doupdate (); return; }
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 testreqrep() { int rc; int rep1; int rep2; int req1; int req2; int resend_ivl; char buf [7]; int timeo; printf("test reqrep\n"); /* Test req/rep with full socket types. */ rep1 = test_socket (AF_SP, NN_REP); test_bind (rep1, SOCKET_ADDRESS); req1 = test_socket (AF_SP, NN_REQ); test_connect (req1, SOCKET_ADDRESS); req2 = test_socket (AF_SP, NN_REQ); test_connect (req2, SOCKET_ADDRESS); /* 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. */ test_send (req2, "ABC"); test_recv (rep1, "ABC"); test_send (rep1, "ABC"); test_recv (req2, "ABC"); test_send (req1, "ABC"); test_recv (rep1, "ABC"); test_send (rep1, "ABC"); test_recv (req1, "ABC"); test_close (rep1); test_close (req1); test_close (req2); /* Check load-balancing of requests. */ req1 = test_socket (AF_SP, NN_REQ); test_bind (req1, SOCKET_ADDRESS); rep1 = test_socket (AF_SP, NN_REP); test_connect (rep1, SOCKET_ADDRESS); rep2 = test_socket (AF_SP, NN_REP); test_connect (rep2, SOCKET_ADDRESS); test_send (req1, "ABC"); test_recv (rep1, "ABC"); test_send (rep1, "ABC"); test_recv (req1, "ABC"); test_send (req1, "ABC"); test_recv (rep2, "ABC"); test_send (rep2, "ABC"); test_recv (req1, "ABC"); test_close (rep2); test_close (rep1); test_close (req1); /* Test re-sending of the request. */ rep1 = test_socket (AF_SP, NN_REP); test_bind (rep1, SOCKET_ADDRESS); req1 = test_socket (AF_SP, NN_REQ); test_connect (req1, SOCKET_ADDRESS); resend_ivl = 100; rc = nn_setsockopt (req1, NN_REQ, NN_REQ_RESEND_IVL, &resend_ivl, sizeof (resend_ivl)); errno_assert (rc == 0); test_send (req1, "ABC"); test_recv (rep1, "ABC"); /* The following waits for request to be resent */ test_recv (rep1, "ABC"); test_close (req1); test_close (rep1); /* 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 = test_socket (AF_SP, NN_REQ); test_connect (req1, SOCKET_ADDRESS); test_send (req1, "ABC"); rep1 = test_socket (AF_SP, NN_REP); test_bind (rep1, SOCKET_ADDRESS); timeo = 200; rc = nn_setsockopt (rep1, NN_SOL_SOCKET, NN_RCVTIMEO, &timeo, sizeof (timeo)); errno_assert (rc == 0); test_recv (rep1, "ABC"); test_close (req1); test_close (rep1); /* Check removing socket request sent to (It should be sent immediatelly to other peer rather than relying on the resend algorithm). */ req1 = test_socket (AF_SP, NN_REQ); test_bind (req1, SOCKET_ADDRESS); rep1 = test_socket (AF_SP, NN_REP); test_connect (rep1, SOCKET_ADDRESS); rep2 = test_socket (AF_SP, NN_REP); test_connect (rep2, SOCKET_ADDRESS); timeo = 200; rc = nn_setsockopt (rep1, NN_SOL_SOCKET, NN_RCVTIMEO, &timeo, sizeof (timeo)); errno_assert (rc == 0); rc = nn_setsockopt (rep2, NN_SOL_SOCKET, NN_RCVTIMEO, &timeo, sizeof (timeo)); errno_assert (rc == 0); test_send (req1, "ABC"); /* We got request through rep1 */ test_recv (rep1, "ABC"); /* But instead replying we simulate crash */ test_close (rep1); /* The rep2 should get request immediately */ test_recv (rep2, "ABC"); /* Let's check it's delivered well */ test_send (rep2, "REPLY"); test_recv (req1, "REPLY"); test_close (req1); test_close (rep2); /* Test cancelling delayed request */ req1 = test_socket (AF_SP, NN_REQ); test_connect (req1, SOCKET_ADDRESS); test_send (req1, "ABC"); test_send (req1, "DEF"); rep1 = test_socket (AF_SP, NN_REP); test_bind (rep1, SOCKET_ADDRESS); timeo = 100; // rc = nn_setsockopt (rep1, NN_SOL_SOCKET, NN_RCVTIMEO, // &timeo, sizeof (timeo)); // errno_assert (rc == 0); test_recv (rep1, "DEF"); test_close (req1); test_close (rep1); return 0; }
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; }
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 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 rep; int req; struct nn_msghdr hdr; struct nn_iovec iovec; unsigned char body [3]; unsigned char ctrl [256]; struct nn_cmsghdr *cmsg; unsigned char *data; void *buf; rep = test_socket (AF_SP_RAW, NN_REP); test_bind (rep, SOCKET_ADDRESS); req = test_socket (AF_SP, NN_REQ); test_connect (req, SOCKET_ADDRESS); /* Test ancillary data in static buffer. */ test_send (req, "ABC"); iovec.iov_base = body; iovec.iov_len = sizeof (body); hdr.msg_iov = &iovec; hdr.msg_iovlen = 1; hdr.msg_control = ctrl; hdr.msg_controllen = sizeof (ctrl); rc = nn_recvmsg (rep, &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); rc = nn_sendmsg (rep, &hdr, 0); nn_assert (rc == 3); test_recv (req, "ABC"); /* Test ancillary data in dynamically allocated buffer (NN_MSG). */ test_send (req, "ABC"); iovec.iov_base = body; iovec.iov_len = sizeof (body); hdr.msg_iov = &iovec; hdr.msg_iovlen = 1; hdr.msg_control = &buf; hdr.msg_controllen = NN_MSG; rc = nn_recvmsg (rep, &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); rc = nn_sendmsg (rep, &hdr, 0); nn_assert (rc == 3); test_recv (req, "ABC"); test_close (req); test_close (rep); return 0; }
int main (int argc, char **argv) { int sk1, sk2, sk3, pf_class; socklen_t len; struct sockaddr_in lstn_addr, acpt_addr; struct sockaddr_in conn_addr; char * buffer_rcv; struct sctp_initmsg sinmsg; char *message = "Hello World!\n"; /* Rather than fflush() throughout the code, set stdout to * be unbuffered. */ setvbuf(stdout, NULL, _IONBF, 0); setvbuf(stderr, NULL, _IONBF, 0); /* Opening the socket*/ pf_class = PF_INET; sk1 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); sk3 = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); conn_addr.sin_family = AF_INET; conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; conn_addr.sin_port = htons(SCTP_TESTPORT_1); lstn_addr.sin_family = AF_INET; lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK; lstn_addr.sin_port = htons(SCTP_TESTPORT_1); test_bind(sk3, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr)); len = sizeof(struct sctp_initmsg); sinmsg.sinit_num_ostreams = 65535; sinmsg.sinit_max_instreams = 10; sinmsg.sinit_max_attempts = 1; sinmsg.sinit_max_init_timeo = 0; test_setsockopt(sk1, SCTP_INITMSG, &sinmsg, len); sinmsg.sinit_num_ostreams = 10; sinmsg.sinit_max_instreams = 65535; test_setsockopt(sk3, SCTP_INITMSG, &sinmsg, len); test_listen(sk3, 1); len = sizeof(struct sockaddr_in); test_connect(sk1, (struct sockaddr *) &conn_addr, len); sk2 = test_accept(sk3, (struct sockaddr *) &acpt_addr, &len); test_sctp_sendmsg(sk1, message, strlen(message) + 1, (struct sockaddr *)&conn_addr, len, 0, 0, 65534, 0, 0); buffer_rcv = malloc(100); test_recv(sk2, buffer_rcv, (strlen(message) + 1), MSG_NOSIGNAL); tst_resm(TPASS, "connect() with init timeout set to 0 - SUCCESS"); close (sk1); close (sk2); close (sk3); 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(int argc, char *argv[]) { int clt_sk[MAX_CLIENTS], accept_sk[MAX_CLIENTS]; int listen_sk, clt2_sk, accept2_sk; sockaddr_storage_t clt_loop[MAX_CLIENTS]; sockaddr_storage_t svr_loop, accept_loop, clt2_loop; socklen_t addrlen; int error, i; char *message = "hello, world!\n"; char msgbuf[100]; int pf_class; struct pollfd poll_fd; fd_set set; struct msghdr outmessage; char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))]; struct iovec out_iov; struct cmsghdr *cmsg; struct sctp_sndrcvinfo *sinfo; struct msghdr inmessage; char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))]; char *big_buffer; struct iovec iov; /* Rather than fflush() throughout the code, set stdout to * be unbuffered. */ setvbuf(stdout, NULL, _IONBF, 0); /* Initialize the server and client addresses. */ #if TEST_V6 pf_class = PF_INET6; svr_loop.v6.sin6_family = AF_INET6; svr_loop.v6.sin6_addr = in6addr_loopback; svr_loop.v6.sin6_port = htons(SCTP_TESTPORT_1); for (i = 0; i < MAX_CLIENTS; i++) { clt_loop[i].v6.sin6_family = AF_INET6; clt_loop[i].v6.sin6_addr = in6addr_loopback; clt_loop[i].v6.sin6_port = htons(SCTP_TESTPORT_2 + i); } clt2_loop.v6.sin6_family = AF_INET6; clt2_loop.v6.sin6_addr = in6addr_loopback; clt2_loop.v6.sin6_port = htons(SCTP_TESTPORT_2 + i); #else pf_class = PF_INET; svr_loop.v4.sin_family = AF_INET; svr_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK; svr_loop.v4.sin_port = htons(SCTP_TESTPORT_1); for (i = 0; i < MAX_CLIENTS; i++) { clt_loop[i].v4.sin_family = AF_INET; clt_loop[i].v4.sin_addr.s_addr = SCTP_IP_LOOPBACK; clt_loop[i].v4.sin_port = htons(SCTP_TESTPORT_2 + i); } clt2_loop.v4.sin_family = AF_INET; clt2_loop.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK; clt2_loop.v4.sin_port = htons(SCTP_TESTPORT_2 + i); #endif /* Create and bind the listening server socket. */ listen_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); test_bind(listen_sk, &svr_loop.sa, sizeof(svr_loop)); /* Mark listen_sk as being able to accept new associations. */ test_listen(listen_sk, MAX_CLIENTS-1); /* Create and bind the client sockets. */ for (i = 0; i < MAX_CLIENTS; i++) { clt_sk[i] = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); test_bind(clt_sk[i], &clt_loop[i].sa, sizeof(clt_loop[i])); } clt2_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); test_bind(clt2_sk, &clt2_loop.sa, sizeof(clt2_loop)); addrlen = sizeof(accept_loop); /* Try to do accept on a non-listening socket. It should fail. */ error = accept(clt_sk[0], &accept_loop.sa, &addrlen); if ((-1 != error) && (EINVAL != errno)) tst_brkm(TBROK, tst_exit, "accept on non-listening socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "accept on non-listening socket"); /* Try to do a connect from a listening socket. It should fail. */ error = connect(listen_sk, (struct sockaddr *)&clt_loop[0], sizeof(clt_loop[0])); if ((-1 != error) && (EISCONN != errno)) tst_brkm(TBROK, tst_exit, "connect to non-listening socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "connect to non-listening socket"); /* Do a blocking connect from clt_sk's to listen_sk */ for (i = 0; i < MAX_CLIENTS; i++) test_connect(clt_sk[i], &svr_loop.sa, sizeof(svr_loop)); tst_resm(TPASS, "connect to listening socket"); /* Verify that no more connect's can be done after the acceptq * backlog has reached the max value. */ error = connect(clt2_sk, &svr_loop.sa, sizeof(svr_loop)); if ((-1 != error) && (ECONNREFUSED != errno)) tst_brkm(TBROK, tst_exit, "connect after max backlog " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "connect after max backlog"); /* Extract the associations on the listening socket as new sockets. */ for (i = 0; i < MAX_CLIENTS; i++) { poll_fd.fd = listen_sk; poll_fd.events = POLLIN; poll_fd.revents = 0; error = poll(&poll_fd, 1, -1); if ((1 != error) && (1 != poll_fd.revents)) tst_brkm(TBROK, tst_exit, "Unexpected return value " "with poll, error:%d errno:%d, revents:%d", error, errno, poll_fd.revents); addrlen = sizeof(accept_loop); accept_sk[i] = test_accept(listen_sk, &accept_loop.sa, &addrlen); } tst_resm(TPASS, "accept from listening socket"); /* Try to do a connect on an established socket. It should fail. */ error = connect(accept_sk[0], &clt_loop[0].sa, sizeof(clt_loop[0])); if ((-1 != error) || (EISCONN != errno)) tst_brkm(TBROK, tst_exit, "connect on an established socket " "error:%d errno:%d", error, errno); tst_resm(TPASS, "connect on an established socket"); /* Try to do accept on an established socket. It should fail. */ error = accept(accept_sk[0], &accept_loop.sa, &addrlen); if ((-1 != error) && (EINVAL != errno)) tst_brkm(TBROK, tst_exit, "accept on an established socket " "error:%d errno:%d", error, errno); error = accept(clt_sk[0], &accept_loop.sa, &addrlen); if ((-1 != error) && (EINVAL != errno)) tst_brkm(TBROK, tst_exit, "accept on an established socket " "failure: error:%d errno:%d", error, errno); tst_resm(TPASS, "accept on an established socket"); /* Send and receive a message from the client sockets to the accepted * sockets. */ for (i = 0; i < MAX_CLIENTS; i++) { test_send(clt_sk[i], message, strlen(message), 0); test_recv(accept_sk[i], msgbuf, 100, 0); } tst_resm(TPASS, "client sockets -> accepted sockets"); /* Send and receive a message from the accepted sockets to the client * sockets. */ for (i = 0; i < MAX_CLIENTS; i++) { test_send(accept_sk[i], message, strlen(message), 0); test_recv(clt_sk[i], msgbuf, 100, 0); } tst_resm(TPASS, "accepted sockets -> client sockets"); /* Sending a message on a listening socket should fail. */ error = send(listen_sk, message, strlen(message), MSG_NOSIGNAL); if ((-1 != error) || (EPIPE != errno)) tst_brkm(TBROK, tst_exit, "send on a listening socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "send on a listening socket"); /* Trying to receive a message on a listening socket should fail. */ error = recv(listen_sk, msgbuf, 100, 0); if ((-1 != error) || (ENOTCONN != errno)) tst_brkm(TBROK, tst_exit, "recv on a listening socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "recv on a listening socket"); /* TESTCASES for shutdown() */ errno = 0; test_send(accept_sk[0], message, strlen(message), 0); /* Enable ASSOC_CHANGE and SNDRCVINFO notifications. */ test_enable_assoc_change(clt_sk[0]); /* Do a SHUT_WR on clt_sk[0] to disable any new sends. */ test_shutdown(clt_sk[0], SHUT_WR); /* Reading on a socket that has received SHUTDOWN should return 0 * indicating EOF. */ error = recv(accept_sk[0], msgbuf, 100, 0); if ((0 != error) || (0 != errno)) tst_brkm(TBROK, tst_exit, "recv on a SHUTDOWN received socket " "error:%d errno:%d", error, errno); tst_resm(TPASS, "recv on a SHUTDOWN received socket"); /* Read the pending message on clt_sk[0] that was received before * SHUTDOWN call. */ test_recv(clt_sk[0], msgbuf, 100, 0); /* Initialize inmessage for all receives. */ big_buffer = test_malloc(REALLY_BIG); memset(&inmessage, 0, sizeof(inmessage)); iov.iov_base = big_buffer; iov.iov_len = REALLY_BIG; inmessage.msg_iov = &iov; inmessage.msg_iovlen = 1; inmessage.msg_control = incmsg; inmessage.msg_controllen = sizeof(incmsg); /* Receive the SHUTDOWN_COMP notification as they are enabled. */ error = test_recvmsg(clt_sk[0], &inmessage, MSG_WAITALL); test_check_msg_notification(&inmessage, error, sizeof(struct sctp_assoc_change), SCTP_ASSOC_CHANGE, SCTP_SHUTDOWN_COMP); tst_resm(TPASS, "recv SHUTDOWN_COMP notification on a SHUT_WR socket"); /* No more messages and the association is SHUTDOWN, should fail. */ error = recv(clt_sk[0], msgbuf, 100, 0); if ((-1 != error) || (ENOTCONN != errno)) tst_brkm(TBROK, tst_exit, "recv on a SHUTDOWN sent socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "recv on a SHUTDOWN sent socket"); errno = 0; /* Do a SHUT_RD on clt_sk[1] to disable any new receives. */ test_shutdown(clt_sk[1], SHUT_RD); error = recv(clt_sk[1], msgbuf, 100, 0); if ((0 != error) || (0 != errno)) tst_brkm(TBROK, tst_exit, "recv on a SHUT_RD socket " "error:%d, errno:%d", error, errno); /* Sending a message on SHUT_RD socket. */ test_send(clt_sk[1], message, strlen(message), 0); /* Receive the message sent on SHUT_RD socket. */ test_recv(accept_sk[1], msgbuf, 100, 0); /* Send a message to the SHUT_RD socket. */ test_send(accept_sk[1], message, strlen(message), 0); /* We should not receive the message as the socket is SHUT_RD */ error = recv(clt_sk[1], msgbuf, 100, 0); if ((0 != error) || (0 != errno)) tst_brkm(TBROK, tst_exit, "recv on a SHUT_RD socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "recv on a SHUT_RD socket"); /* Do a SHUT_RDWR on clt_sk[2] to disable any new sends/receives. */ test_shutdown(clt_sk[2], SHUT_RDWR); error = recv(accept_sk[2], msgbuf, 100, 0); if ((0 != error) || (0 != errno)) tst_brkm(TBROK, tst_exit, "recv on a SHUT_RDWR socket " "error:%d, errno:%d", error, errno); error = recv(clt_sk[2], msgbuf, 100, 0); if ((0 != error) || (0 != errno)) tst_brkm(TBROK, tst_exit, "recv on a SHUT_RDWR socket " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "recv on a SHUT_RDWR socket"); error = 0; for (i = 0; i < MAX_CLIENTS; i++) close(clt_sk[i]); for (i = 0; i < MAX_CLIENTS; i++) close(accept_sk[i]); /* Test case to verify accept of a CLOSED association. */ /* Do a connect, send and a close to ESTABLISH and CLOSE an * association on the listening socket. */ test_connect(clt2_sk, &svr_loop.sa, sizeof(svr_loop)); test_send(clt2_sk, message, strlen(message), 0); close(clt2_sk); FD_ZERO(&set); FD_SET(listen_sk, &set); error = select(listen_sk + 1, &set, NULL, NULL, NULL); if (1 != error) tst_brkm(TBROK, tst_exit, "select error:%d, " "errno: %d", error, errno); /* Now accept the CLOSED association waiting on the listening * socket. */ accept2_sk = test_accept(listen_sk, &accept_loop.sa, &addrlen); /* Receive the message sent before doing a close. */ test_recv(accept2_sk, msgbuf, 100, 0); /* Receive EOF indication as there are no more messages and the * socket is SHUTDOWN. */ error = recv(accept2_sk, msgbuf, 100, 0); if ((0 != error) || (0 != errno)) tst_brkm(TBROK, tst_exit, "Unexpected error return on " "recv(error:%d, errno:%d)", error, errno); tst_resm(TPASS, "accept of a CLOSED association"); /* Trying to send a message over the CLOSED association should * generate EPIPE. */ error = send(accept2_sk, message, strlen(message), MSG_NOSIGNAL); if ((-1 != error) || (EPIPE != errno)) tst_brkm(TBROK, tst_exit, "send to a CLOSED association " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "send to a CLOSED association"); error = 0; close(accept2_sk); /* Verify that auto-connect can be done on a TCP-style socket using * sendto/sendmsg. */ clt2_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP); test_bind(clt2_sk, &clt2_loop.sa, sizeof(clt2_loop)); /* Do a sendto() without a connect() */ test_sendto(clt2_sk, message, strlen(message), 0, &svr_loop.sa, sizeof(svr_loop)); accept2_sk = test_accept(listen_sk, &accept_loop.sa, &addrlen); test_recv(accept2_sk, msgbuf, 100, 0); tst_resm(TPASS, "auto-connect using sendto"); outmessage.msg_name = &svr_loop; outmessage.msg_namelen = sizeof(svr_loop); outmessage.msg_iov = NULL; outmessage.msg_iovlen = 0; outmessage.msg_control = outcmsg; outmessage.msg_controllen = sizeof(outcmsg); outmessage.msg_flags = 0; cmsg = CMSG_FIRSTHDR(&outmessage); cmsg->cmsg_level = IPPROTO_SCTP; cmsg->cmsg_type = SCTP_SNDRCV; cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo)); outmessage.msg_controllen = cmsg->cmsg_len; sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg); memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo)); /* Verify that SCTP_EOF cannot be used to shutdown an association * on a TCP-style socket. */ sinfo->sinfo_flags |= SCTP_EOF; error = sendmsg(clt2_sk, &outmessage, 0); if ((-1 != error) || (EINVAL != errno)) tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_EOF flag " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "sendmsg with SCTP_EOF flag"); /* Verify that SCTP_ABORT cannot be used to abort an association * on a TCP-style socket. */ sinfo->sinfo_flags |= SCTP_ABORT; error = sendmsg(clt2_sk, &outmessage, 0); if ((-1 != error) || (EINVAL != errno)) tst_brkm(TBROK, tst_exit, "sendmsg with SCTP_ABORT flag " "error:%d, errno:%d", error, errno); tst_resm(TPASS, "sendmsg with SCTP_ABORT flag"); /* Verify that a normal message can be sent using sendmsg. */ outmessage.msg_iov = &out_iov; outmessage.msg_iovlen = 1; out_iov.iov_base = message; out_iov.iov_len = strlen(message) + 1; sinfo->sinfo_flags = 0; test_sendmsg(clt2_sk, &outmessage, 0, strlen(message)+1); test_recv(accept2_sk, msgbuf, 100, 0); tst_resm(TPASS, "sendmsg with no flags"); close(clt2_sk); close(accept2_sk); close(listen_sk); /* Indicate successful completion. */ 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; }