/* SCTP kernel Implementation * (C) Copyright IBM Corp. 2001, 2003 * Copyright (c) 1999 Cisco * Copyright (c) 1999, 2000, 2001 Motorola * Copyright (c) 2001 Nokia * Copyright (c) 2001 La Monte H.P. Yarroll * * The SCTP implementation is free software; * you can redistribute it and/or modify it under the terms of * the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * The SCTP implementation is distributed in the hope that it * will be useful, but WITHOUT ANY WARRANTY; without even the implied * ************************ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GNU CC; see the file COPYING. If not, write to * the Free Software Foundation, 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * * Please send any bug reports or fixes you make to the * email address(es): * lksctp developers * * Or submit a bug report through the following website: * http://www.sf.net/projects/lksctp * * Any bugs reported to us we will try to fix... any fixes shared will * be incorporated into the next SCTP release. * * Written or modified by: * La Monte H.P. Yarroll * Karl Knutson * Hui Huang * Daisy Chang * Sridhar Samudrala */ /* This is a userspace test application for the SCTP kernel * implementation state machine. It is vaguely inspired by Stevens' * program "sock". * * It has the limited ability to send messages and to listen for messages * sent via SCTP. */ #include #include #include //#define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "sctp_darn.h" char *TCID = __FILE__; int TST_TOTAL = 1; int TST_CNT = 0; #define GEN_DATA_FIRST 0x21 #define GEN_DATA_LAST 0x7e /* Display an IPv4 address in readable format. */ #define NIPQUAD(addr) \ ((unsigned char *)&addr)[0], \ ((unsigned char *)&addr)[1], \ ((unsigned char *)&addr)[2], \ ((unsigned char *)&addr)[3] /* Display an IPv6 address in readable format. */ #define NIP6(addr) \ ntohs((addr).s6_addr16[0]), \ ntohs((addr).s6_addr16[1]), \ ntohs((addr).s6_addr16[2]), \ ntohs((addr).s6_addr16[3]), \ ntohs((addr).s6_addr16[4]), \ ntohs((addr).s6_addr16[5]), \ ntohs((addr).s6_addr16[6]), \ ntohs((addr).s6_addr16[7]) /* These are the global options. */ char *local_host = NULL; int local_port = 0; char *remote_host = NULL; int remote_port = 0; command_t command = COMMAND_NONE; struct sockaddr *bindx_add_addrs = NULL; int bindx_add_count = 0; struct sockaddr *bindx_rem_addrs = NULL; int bindx_rem_count = 0; struct sockaddr *connectx_addrs = NULL; int connectx_count = 0; int interactive_mode = 0; int poll_skn = 0; int nonblocking = 0; int opt_space = 0; char gen_data = GEN_DATA_FIRST; char *inter_outbuf = NULL; int inter_outlen = 0; int inter_sk = 0; int poll_snd_size = 0; int use_poll = 0; int socket_type = SOCK_SEQPACKET; sctp_assoc_t associd = 0; int echo = 0; char *interface = "eth0"; int if_index = 0; sockaddr_storage_t remote_addr; sa_family_t ra_family; /* What family is remote_addr? */ int ra_len = 0; /* How long is remote_addr? */ void *ra_raw; /* This is the addr part of remote_addr. */ int new_connection = 1; enum inter_cmd_num { INTER_SND = 0, INTER_RCV, INTER_SNDBUF, INTER_RCVBUF, INTER_BINDX_ADD, INTER_BINDX_REM, INTER_SET_PRIM, INTER_SET_PEER_PRIM, INTER_SHUTDOWN, INTER_ABORT, INTER_NODELAY, INTER_MAXSEG, INTER_HEARTBEAT, INTER_GET_STATS }; enum shutdown_type { SHUTDOWN_ABORT = 0, SHUTDOWN_SHUTDOWN }; struct inter_entry { char *cmd; int cmd_num; }; struct inter_entry inter_commands[] = { {"snd", INTER_SND}, {"rcv", INTER_RCV}, {"sndbuf", INTER_SNDBUF}, {"rcvbuf", INTER_RCVBUF}, {"bindx-add", INTER_BINDX_ADD}, {"bindx-rem", INTER_BINDX_REM}, {"primary", INTER_SET_PRIM}, {"peer_primary", INTER_SET_PEER_PRIM}, {"shutdown", INTER_SHUTDOWN}, {"abort", INTER_ABORT}, {"nodelay", INTER_NODELAY}, {"maxseg", INTER_MAXSEG}, {"heartbeat", INTER_HEARTBEAT}, {"stats", INTER_GET_STATS}, {NULL, -1}, }; #define POLL_SK_MAX 256 /* The max number of sockets to select/poll. */ int poll_sks[POLL_SK_MAX]; /* The array for using select(). */ struct pollfd poll_fds[POLL_SK_MAX]; /* The array for using poll(). */ #define POLL_SND_SIZE 16384 /* Default message size in the poll mode. */ struct sockaddr *append_addr(const char *parm, struct sockaddr *addrs, int *ret_count) ; int build_endpoint(char *argv0, int portnum); static int parse_inter_commands(char *, char *, int); static void snd_func(char *); static void sndbuf_func(char *, int, int, int); static void rcvbuf_func(char *, int, int, int); static struct sockaddr *get_bindx_addr(char *, int *); static int bindx_func(char *, int, struct sockaddr *, int, int, int); static int connectx_func(char *, int, struct sockaddr *, int); static void primary_func(char *, int, char *, int); static void peer_primary_func(char *, int, char *, int); static void spp_hb_demand_func(char *, int, char *, int); static int nodelay_func(char *, int, int val, int set); static int maxseg_func(char *, int, int val, int set); static int shutdown_func(char *argv0, int *skp, int shutdown_type); static int get_assocstats_func(int, sctp_assoc_t); static int test_sk_for_assoc(int sk, sctp_assoc_t assoc_id); static char * gen_message(int); static sctp_assoc_t test_recv_assoc_change(int); static sctp_assoc_t test_verify_assoc_change(struct msghdr *); void print_addr_buf(void * laddrs, int n_laddrs); int print_sockaddr(struct sockaddr *sa_addr); int main(int argc, char *argv[]) { int sk = -1; int error = 0; int i; signal(SIGPIPE, SIG_IGN); parse_arguments(argc, argv); switch(command) { case COMMAND_NONE: fprintf(stderr, "%s: Please specify a command.\n", argv[0]); exit(1); break; case COMMAND_LISTEN: sk = build_endpoint(argv[0], local_port); error = command_listen(argv[0], sk); break; case COMMAND_SEND: sk = build_endpoint(argv[0], local_port); error = command_send(argv[0], &sk); break; case COMMAND_POLL: if (use_poll) { for (i = 0; i < poll_skn; i++) { poll_fds[i].fd = build_endpoint(argv[0], local_port + i); } } else { for (i = 0; i < poll_skn; i++) { poll_sks[i] = build_endpoint(argv[0], local_port + i); } } error = command_poll(argv[0]); break; default: fprintf(stderr, "%s: illegal command %d\n", argv[0], command); exit(1); } /* Shut down the link. */ if (COMMAND_POLL != command) { close(sk); } else { /* Shutdown all links. */ if (use_poll) { for (i = 0; i < poll_skn; i++) { close(poll_fds[i].fd); } } else { for (i = 0; i < poll_skn; i++) { close(poll_sks[i]); } } } exit(error); } /******************************************************************** * 2nd Level Abstractions ********************************************************************/ void parse_arguments(int argc, char *argv[]) { int option_index = 0; int c; struct sockaddr *tmp_addrs = NULL; static struct option long_options[] = { {"local", 1, 0, 1}, {"local-port", 1, 0, 2}, {"remote", 1, 0, 3}, {"remote-port", 1, 0, 4}, {"listen", 0, 0, 10}, {"send", 0, 0, 11}, {"bindx-add", 1, 0, 15}, {"bindx-rem", 1, 0, 16}, {"use-poll", 0, 0, 20}, {"echo", 0, 0, 'e'}, {"interface", optional_argument, 0, 5,}, {"connectx", 1, 0, 17}, {0, 0, 0, 0} }; /* Parse the arguments. */ while (1) { c = getopt_long (argc, argv, "B:H:IP:b:h:i:p:lm:nstz:ec:", long_options, &option_index); if (c == -1) break; switch (c) { case 0: printf("option %s", long_options[option_index].name); if (optarg) { printf(" with arg %s", optarg); } printf("\n"); break; case 1: /* local host */ case 'H': local_host = optarg; break; case 2: /* local port */ case 'P': local_port = atoi(optarg); break; case 3: /* remote host */ case 'h': remote_host = optarg; break; case 4: /* remote port */ case 'p': remote_port = atoi(optarg); break; case 5: /* interface for sin6_scope_id */ if (optarg) interface = optarg; if_index = if_nametoindex(interface); if (!if_index) { printf("Interface %s unknown\n", interface); exit(1); } break; /* COMMANDS */ case 10: /* listen */ case 'l': if (command) { fprintf(stderr, "%s: pick ONE of listen or send\n", argv[0]); exit(1); } else { command = COMMAND_LISTEN; } break; case 11: /* send */ case 's': if (command) { fprintf(stderr, "%s: pick ONE of listen or send\n", argv[0]); exit(1); } else { command = COMMAND_SEND; } break; case 15: /* bindx_add */ case 'B': tmp_addrs = append_addr(optarg, bindx_add_addrs, &bindx_add_count); if (NULL == tmp_addrs) { /* We have no memory, so keep fprintf() * from trying to allocate more. */ fprintf(stderr, "No memory to add "); fprintf(stderr, "%s\n", optarg); exit(2); } bindx_add_addrs = tmp_addrs; break; case 16: /* bindx_rem */ case 'b': tmp_addrs = append_addr(optarg, bindx_rem_addrs, &bindx_rem_count); if (NULL == tmp_addrs) { /* We have no memory, so keep fprintf() * from trying to allocate more. */ fprintf(stderr, "No memory to add "); fprintf(stderr, "%s\n", optarg); exit(2); } bindx_rem_addrs = tmp_addrs; break; case 17: /* connectx */ case 'c': tmp_addrs = append_addr(optarg, connectx_addrs, &connectx_count); if (NULL == tmp_addrs) { /* We have no memory, so keep fprintf() * from trying to allocate more. */ fprintf(stderr, "No memory to add "); fprintf(stderr, "%s\n", optarg); exit(2); } connectx_addrs = tmp_addrs; break; case 20: /* use-poll */ use_poll = 1; break; case 'I': interactive_mode = 1; break; case 'i': command = COMMAND_POLL; poll_skn = atoi(optarg); if (poll_skn <= 0 || poll_skn > POLL_SK_MAX) { fprintf(stderr, "Too many sockets for "); fprintf(stderr, "for polling\n"); exit(2); } break; case 'm': opt_space = atoi(optarg); break; case 'n': nonblocking = 1; break; case 't': socket_type = SOCK_STREAM; break; case 'z': poll_snd_size = atoi(optarg); if (poll_snd_size <= 0) { fprintf(stderr, "Bad message size.\n"); exit(2); } break; case 'e': echo = 1; break; case '?': usage(argv[0]); exit(1); default: printf ("%s: unrecognized option 0%c\n", argv[0], c); usage(argv[0]); exit(1); } } if (optind < argc) { fprintf(stderr, "%s: non-option arguments are illegal: ", argv[0]); while (optind < argc) fprintf(stderr, "%s ", argv[optind++]); fprintf (stderr, "\n"); usage(argv[0]); exit(1); } if (NULL == local_host) { fprintf(stderr, "%s: You MUST provide a local host.\n", argv[0]); usage(argv[0]); exit(1); } if (command == COMMAND_SEND && NULL == remote_host && connectx_count == 0) { fprintf(stderr, "%s: You MUST provide a remote host for sending.\n", argv[0]); usage(argv[0]); exit(1); } if (remote_host != NULL && connectx_count != 0) { fprintf(stderr, "%s: You can not provide both -h and -c options.\n", argv[0]); usage(argv[0]); exit(1); } } /* parse_arguments() */ /* Set up the local endpoint. */ int build_endpoint(char *argv0, int portnum) { int retval; struct hostent *hst; sockaddr_storage_t local_addr; sa_family_t la_family; /* What family is local_addr? */ int la_len; /* How long is local_addr? */ void *la_raw; /* This is the addr part of local_addr. */ int error; struct sctp_event_subscribe subscribe; /* Get the transport address for the local host name. */ hst = gethostbyname(local_host); if (hst == NULL) { hst = gethostbyname2(local_host, AF_INET6); } if (hst == NULL || hst->h_length < 1) { fprintf(stderr, "%s: bad hostname: %s\n", argv0, local_host); exit(1); } la_family = hst->h_addrtype; switch (la_family) { case AF_INET: la_len = sizeof(local_addr.v4); la_raw = &local_addr.v4.sin_addr; local_addr.v4.sin_port = htons(portnum); local_addr.v4.sin_family = AF_INET; break; case AF_INET6: la_len = sizeof(local_addr.v6); la_raw = &local_addr.v6.sin6_addr; local_addr.v6.sin6_port = htons(portnum); local_addr.v6.sin6_family = AF_INET6; local_addr.v6.sin6_scope_id = if_index; break; default: fprintf(stderr, "Invalid address type.\n"); exit(1); break; } memcpy(la_raw, hst->h_addr_list[0], hst->h_length); /* Create the local endpoint. */ retval = socket(la_family, socket_type, IPPROTO_SCTP); if (retval < 0) { fprintf(stderr, "%s: failed to create socket: %s.\n", argv0, strerror(errno)); exit(1); } if (SOCK_SEQPACKET == socket_type) { memset(&subscribe, 0, sizeof(subscribe)); subscribe.sctp_data_io_event = 1; subscribe.sctp_association_event = 1; error = setsockopt(retval, SOL_SCTP, SCTP_EVENTS, (char *)&subscribe, sizeof(subscribe)); if (error) { fprintf(stderr, "SCTP_EVENTS: error: %d\n", error); exit(1); } } /* Bind this socket to the test port. */ error = bind(retval, &local_addr.sa, la_len); if (error != 0) { fprintf(stderr, "%s: can not bind to %s:%d: %s.\n", argv0, local_host, portnum, strerror(errno)); exit(1); } /* Do we need to do bindx() to add any additional addresses? */ if (bindx_add_addrs) { if (0 != bindx_func(argv0, retval, bindx_add_addrs, bindx_add_count, SCTP_BINDX_ADD_ADDR, portnum)) { fprintf(stderr, "bindx_func (add) failed.\n"); exit(1); } } /* if (bindx_add_addrs) */ /* Do we need to do bindx() to remove any bound addresses? */ if (bindx_rem_addrs) { if (0 != bindx_func(argv0, retval, bindx_rem_addrs, bindx_rem_count, SCTP_BINDX_REM_ADDR, portnum)) { fprintf(stderr, "bindx_func (remove) failed.\n"); exit(1); } } /* if (bindx_rem_addrs) */ /* Do we want to run in the non-blocking mode? */ if (nonblocking) { error = fcntl(retval, F_SETFL, O_NONBLOCK); if (error != 0) { fprintf(stderr, "%s: error fcntl: %s.\n", argv0, strerror(errno)); exit(1); } } if (opt_space) { sndbuf_func(argv0, retval, opt_space, 1); rcvbuf_func(argv0, retval, opt_space, 1); } return retval; } /* build_endpoint() */ /* Convenience structure to determine space needed for cmsg. */ typedef union { struct sctp_initmsg init; struct sctp_sndrcvinfo sndrcvinfo; } _sctp_cmsg_data_t; /* Listen on the socket, printing out anything that arrives. */ int command_listen(char *argv0, int sk) { char incmsg[CMSG_SPACE(sizeof(_sctp_cmsg_data_t))]; struct iovec iov; struct msghdr inmessage; sockaddr_storage_t msgname; char message[REALLY_BIG]; int done = 0; int error; int c; int recvsk = 0; /* Mark sk as being able to accept new associations */ error = listen(sk, 5); if (error != 0) { printf("\n\n\t\tlisten Failure: %s.\n\n\n", strerror(errno)); exit(1); } if (nonblocking) { if (!interactive_mode) { printf("Use -I for interactive mode with"); printf(" -n nonblocking\n"); exit(1); } } /* Initialize the global value for interactive mode functions. */ if (interactive_mode) { inter_sk = sk; } /* Initialize inmessage with enough space for DATA... */ memset(&inmessage, 0, sizeof(inmessage)); if ((iov.iov_base = malloc(REALLY_BIG)) == NULL) { printf("%s: Can't allocate memory.\n", argv0); exit(1); } iov.iov_len = REALLY_BIG; inmessage.msg_iov = &iov; inmessage.msg_iovlen = 1; /* or a control message. */ inmessage.msg_control = incmsg; inmessage.msg_controllen = sizeof(incmsg); inmessage.msg_name = &msgname; inmessage.msg_namelen = sizeof(msgname); printf("%s listening...\n", argv0); /* Get the messages sent */ done = 0; while (!done) { if (interactive_mode) { /* Read from the user. */ if (remote_host) { printf("%s:%d-%s:%d Interactive mode> ", local_host, local_port, remote_host, remote_port); } else { printf("%s:%d-", local_host, local_port); if (associd) { print_sockaddr(&remote_addr.sa); } else { printf("?:%d", remote_port); } printf(" Interactive mode> "); } fflush(stdout); if (NULL == fgets(message, REALLY_BIG, stdin)) { done = 1; continue; } if (0 <= (c = parse_inter_commands(argv0, message, 0))) { if (INTER_RCV != c) { continue; } } else { continue; } } if (socket_type == SOCK_STREAM) { socklen_t len = 0; if (!recvsk) { if ((recvsk = accept(sk, NULL, &len)) < 0) { fprintf(stderr, "%s: error: %s.\n", argv0, strerror(errno)); exit(1); } } } else { recvsk = sk; } error = recvmsg(recvsk, &inmessage, MSG_WAITALL); if (error < 0) { if (nonblocking && (EAGAIN == errno)) { error = 0; continue; } if (socket_type == SOCK_STREAM) { if (ENOTCONN != errno) break; printf("No association is present now!!\n"); close(recvsk); recvsk = 0; continue; } break; } /* Update the associd when a notification is received on a * UDP-style socket. */ if (inmessage.msg_flags & MSG_NOTIFICATION) associd = test_verify_assoc_change(&inmessage); if (echo) { if( !(MSG_NOTIFICATION & inmessage.msg_flags)) { if (sendto(recvsk, inmessage.msg_iov->iov_base, error, 0, (struct sockaddr *)&msgname, sizeof(msgname)) == -1) { fprintf(stderr, "%s: error: %s.\n", argv0, strerror(errno)); exit(1); } } } test_print_message(sk, &inmessage, error); inmessage.msg_control = incmsg; inmessage.msg_controllen = sizeof(incmsg); inmessage.msg_name = &msgname; inmessage.msg_namelen = sizeof(msgname); iov.iov_len = REALLY_BIG; /* Verify that the association is no longer present. */ if (0 != test_sk_for_assoc(recvsk, associd)) { printf("No association is present now!!\n"); if (socket_type == SOCK_STREAM) { close(recvsk); recvsk = 0; } } } if (error < 0) { fprintf(stderr, "%s: error: %s.\n", argv0, strerror(errno)); exit(1); } return error; } /* command_listen() */ /* Read lines from stdin and send them to the socket. */ int command_send(char *argv0, int *skp) { struct msghdr outmsg; struct iovec iov; int done = 0; char message[REALLY_BIG]; struct hostent *hst; int c; struct sockaddr *addrs; int msglen; int error = 0; int sk = *skp; /* Set up the destination. */ if (remote_host != NULL) { hst = gethostbyname(remote_host); if (hst == NULL) { hst = gethostbyname2(remote_host, AF_INET6); } if (hst == NULL || hst->h_length < 1) { fprintf(stderr, "%s: bad hostname: %s\n", argv0, remote_host); exit(1); } ra_family = hst->h_addrtype; switch (ra_family) { case AF_INET: ra_len = sizeof(remote_addr.v4); ra_raw = &remote_addr.v4.sin_addr; remote_addr.v4.sin_port = htons(remote_port); remote_addr.v4.sin_family = AF_INET; break; case AF_INET6: ra_len = sizeof(remote_addr.v6); ra_raw = &remote_addr.v6.sin6_addr; remote_addr.v6.sin6_port = htons(remote_port); remote_addr.v6.sin6_family = AF_INET6; remote_addr.v6.sin6_scope_id = if_index; break; default: fprintf(stderr, "Invalid address type.\n"); exit(1); break; } memcpy(ra_raw, hst->h_addr_list[0], hst->h_length); } /* Initialize the global value for interactive mode functions. */ if (interactive_mode) { inter_sk = sk; } printf("%s ready to send...\n", argv0); while (!done) { /* Read from the user. */ if (remote_host) { if (interactive_mode) { printf("%s:%d-%s:%d Interactive mode> ", local_host, local_port, remote_host, remote_port); } else { printf("%s:%d-%s:%d> ", local_host, local_port, remote_host, remote_port); } } else { printf("%s:%d-", local_host, local_port); if (associd) { print_sockaddr(&remote_addr.sa); } else { printf("XXXXXX:%d", remote_port); } if (interactive_mode) { printf(" Interactive mode> "); } else { printf("> "); } } fflush(stdout); if (NULL == fgets(message, REALLY_BIG, stdin)) { done = 1; continue; } if (interactive_mode) { /* This is the send only agent. */ if (0 <= (c = parse_inter_commands(argv0, message, 1))) { if (INTER_SND == c) { iov.iov_base = inter_outbuf; msglen = inter_outlen; iov.iov_len = msglen; } else { continue; } } else { continue; } } else { /* Send to our neighbor. */ msglen = strlen(message) + 1; iov.iov_len = msglen; } /* For a UDP-style socket, verify if an existing association * has gone. If so, receive the pending SCTP_ASSOC_CHANGE * notification. */ if ((SOCK_SEQPACKET == socket_type) && associd && (0 != test_sk_for_assoc(sk, associd))) { associd = test_recv_assoc_change(sk); printf("Old association gone, Starting a new one!\n"); new_connection = 1; } if (new_connection && connectx_count != 0) { /* Do a sctp_connectx() to establish a connection. */ error = connectx_func(argv0, sk, connectx_addrs, connectx_count); if (0 != error) { if (error == -2) { printf("Connection refused\n"); if (SOCK_SEQPACKET == socket_type) { associd = test_recv_assoc_change(sk); } continue; } fprintf(stderr, "connectx failed.\n"); exit(1); } if (SOCK_SEQPACKET == socket_type) { associd = test_recv_assoc_change(sk); } else { associd = 1; } int rc = sctp_getpaddrs(sk, associd, &addrs); if (0 >= rc) { if (rc == 0) { fprintf(stderr, "sctp_getpaddrs failed, no peers.\n"); } else { fprintf(stderr, "sctp_getpaddrs failed %s(%d).\n", strerror(errno), errno); } exit(1); } printf("New connection, peer addresses\n"); print_addr_buf(addrs, rc); ra_family = addrs[0].sa_family; switch (ra_family) { case AF_INET: ra_len = sizeof(remote_addr.v4); break; case AF_INET6: ra_len = sizeof(remote_addr.v6); break; default: fprintf(stderr, "Invalid address type.\n"); exit(1); } memcpy(&remote_addr, &addrs[0], ra_len); sctp_freepaddrs(addrs); new_connection = 0; } do { if (SOCK_SEQPACKET == socket_type || (connectx_count == 0 && new_connection)) { /* Initialize the message struct we use to pass * messages to the remote socket. */ if (!interactive_mode) { iov.iov_base = message; iov.iov_len = msglen; } outmsg.msg_iov = &iov; outmsg.msg_iovlen = 1; outmsg.msg_control = NULL; outmsg.msg_controllen = 0; outmsg.msg_name = &remote_addr; outmsg.msg_namelen = ra_len; outmsg.msg_flags = 0; error = sendmsg(sk, &outmsg, 0); } else { error = send(sk, message, msglen, 0); if (error == -1 && errno == EPIPE) { error = close(sk); if (error != 0) { fprintf(stderr, "close failed %s\n", strerror(errno)); exit(1); } *skp = sk = build_endpoint(argv0, local_port); break; } } if (error != msglen) { fprintf(stderr, "%s: error: %s.\n", argv0, strerror(errno)); if (nonblocking && EAGAIN == errno) { if (interactive_mode) { break; } continue; } exit(1); } else { break; } } while (error != msglen); /* If this is the first message sent over a UDP-style socket, * get the associd from the SCTP_ASSOC_CHANGE notification. */ if ((SOCK_SEQPACKET == socket_type) && (0 == associd)) associd = test_recv_assoc_change(sk); /* Verify there is no association. */ if (0 != test_sk_for_assoc(sk, associd)) { printf("No association is present now!!\n"); new_connection = 1; } else { if (new_connection) { int rc = sctp_getpaddrs(sk, associd, &addrs); if (0 >= rc) { if (rc == 0) { fprintf(stderr, "sctp_getpaddrs failed, no peers.\n"); } else { fprintf(stderr, "sctp_getpaddrs failed %s(%d).\n", strerror(errno), errno); } exit(1); } printf("New connection, peer addresses\n"); print_addr_buf(addrs, rc); sctp_freepaddrs(addrs); new_connection = 0; } } /* Clean up. */ if (interactive_mode) { free(inter_outbuf); inter_outbuf = NULL; } } /* while(!done) */ return error; } /* command_send() */ /* Listen on the array of sockets, printing out anything that arrives. */ int command_poll(char *argv0) { char incmsg[CMSG_SPACE(sizeof(_sctp_cmsg_data_t))]; struct iovec iov; struct msghdr inmessage; int done = 0; int error = 0; int max_fd, i, ret; int size; fd_set *ibitsp = NULL; fd_set *obitsp = NULL; fd_set *xbitsp = NULL; struct msghdr outmsg; struct hostent *hst; int msglen; int temp_fd, temp_set; /* If a remote host is specified, initialize the destination. */ if (remote_host) { /* Set up the destination. */ hst = gethostbyname(remote_host); if (hst == NULL) { hst = gethostbyname2(remote_host, AF_INET6); } if (hst == NULL || hst->h_length < 1) { fprintf(stderr, "%s: bad hostname: %s\n", argv0, remote_host); exit(1); } ra_family = hst->h_addrtype; switch (ra_family) { case AF_INET: ra_len = sizeof(remote_addr.v4); ra_raw = &remote_addr.v4.sin_addr; remote_addr.v4.sin_port = htons(remote_port); remote_addr.v4.sin_family = AF_INET; break; case AF_INET6: ra_len = sizeof(remote_addr.v6); ra_raw = &remote_addr.v6.sin6_addr; remote_addr.v6.sin6_port = htons(remote_port); remote_addr.v6.sin6_family = AF_INET6; remote_addr.v6.sin6_scope_id = if_index; break; default: fprintf(stderr, "Invalid address type.\n"); exit(1); break; } memcpy(ra_raw, hst->h_addr_list[0], hst->h_length); /* Initialize the message struct we use to pass messages to * the remote socket. */ outmsg.msg_iov = &iov; outmsg.msg_iovlen = 1; outmsg.msg_control = NULL; outmsg.msg_controllen = 0; outmsg.msg_name = &remote_addr; outmsg.msg_namelen = ra_len; outmsg.msg_flags = 0; } max_fd = -1; /* Set all of the sockets to be ready for listening. */ if (use_poll) { for (i = 0; i < poll_skn; i++) { error = listen(poll_fds[i].fd, 1); if (error != 0) { printf("%s: Listen failed on socket number ", argv0); printf("%d: %s.\n", i, strerror(errno)); exit(1); } } printf("%s listening...\n", argv0); } else { for (i = 0; i < poll_skn; i++) { error = listen(poll_sks[i], 1); if (error != 0) { printf("%s: Listen failed on socket number ", argv0); printf("%d: %s.\n", i, strerror(errno)); exit(1); } if (poll_sks[i] > max_fd) { max_fd = poll_sks[i]; } } printf("%s listening...\n", argv0); size = howmany(max_fd + 1, NFDBITS) * sizeof(fd_mask); if ((ibitsp = (fd_set *)malloc(size)) == NULL) { printf("%s: Can't allocate memory.\n", argv0); exit(1); } if ((obitsp = (fd_set *)malloc(size)) == NULL) { printf("%s: Can't allocate memory.\n", argv0); exit(1); } if ((xbitsp = (fd_set *)malloc(size)) == NULL) { printf("%s: Can't allocate memory.\n", argv0); exit(1); } memset(ibitsp, 0, size); memset(obitsp, 0, size); memset(xbitsp, 0, size); } /* Initialize inmessage with enough space for DATA... */ memset(&inmessage, 0, sizeof(inmessage)); if ((iov.iov_base = malloc(REALLY_BIG)) == NULL) { printf("%s: Can't allocate memory.\n", argv0); exit(1); } iov.iov_len = REALLY_BIG; inmessage.msg_iov = &iov; inmessage.msg_iovlen = 1; /* or a control message. */ inmessage.msg_control = incmsg; inmessage.msg_controllen = sizeof(incmsg); done = 0; /* Set the default send message size. */ if (!poll_snd_size) { poll_snd_size = POLL_SND_SIZE; } while (!done) { if (use_poll) { for (i = 0; i < poll_skn; i++) { poll_fds[i].events = POLLIN; } if (remote_host) { /* Poll output on the first socket. */ poll_fds[0].events |= POLLOUT; } if ((ret = poll(poll_fds, poll_skn, -1))) { if (ret == -1) { break; } } } else { for (i = 0; i < poll_skn; i++) { FD_SET(poll_sks[i], ibitsp); FD_SET(poll_sks[i], xbitsp); } if (remote_host) { /* Only select output on the first socket. */ FD_SET(poll_sks[0], obitsp); } if ((ret = select(max_fd + 1, ibitsp, obitsp, xbitsp, (struct timeval *)0)) < 0) { if (ret == -1) { break; } } } if (remote_host) { if (use_poll) { temp_set = poll_fds[0].revents & POLLOUT; temp_fd = poll_fds[0].fd; } else { temp_set = FD_ISSET(poll_sks[0], obitsp); temp_fd = poll_sks[0]; } if (temp_set) { inter_outbuf = gen_message(poll_snd_size); if (!inter_outbuf) { fprintf(stderr, "Cannot allocate out message.\n"); exit(1); } iov.iov_base = inter_outbuf; msglen = poll_snd_size; iov.iov_len = msglen; error = sendmsg(temp_fd, &outmsg, 0); fprintf(stderr, "sent a message, msglen = %d\n", msglen); if (error != msglen) { fprintf(stderr, "%s: error: %s.\n", argv0, strerror(errno)); if ((!nonblocking) || (EAGAIN != errno)) { exit(1); } } /* Clean up. */ free(inter_outbuf); inter_outbuf = NULL; } } /* while(!done) */ for (i = 0; !done && (i < poll_skn); i++) { if (use_poll) { temp_set = poll_fds[i].revents & POLLIN; temp_fd = poll_fds[i].fd; } else { temp_set = FD_ISSET(poll_sks[i], ibitsp); temp_fd = poll_sks[i]; } if (temp_set) { error = recvmsg(temp_fd, &inmessage, MSG_WAITALL); if (error < 0) { if ((EAGAIN == errno)) { error = 0; continue; } else { fprintf(stderr, "%s: error: %s.\n", argv0, strerror(errno)); exit(1); } } test_print_message(temp_fd, &inmessage, error); inmessage.msg_control = incmsg; inmessage.msg_controllen = sizeof(incmsg); iov.iov_len = REALLY_BIG; } /* Update the associd when a notification is received * on a UDP-style socket. */ if (inmessage.msg_flags & MSG_NOTIFICATION) associd = test_verify_assoc_change(&inmessage); /* Verify there is no association. */ if (0 != test_sk_for_assoc(poll_sks[i], associd)) { printf("No association is present in sk " "No.%d now!!\n",i); } } } if (!use_poll) { free(ibitsp); free(obitsp); free(xbitsp); } return error; } /* command_poll() */ /******************************************************************** * 3rd Level Abstractions ********************************************************************/ #define FPS(arg) fprintf(stderr, arg) void usage(char *argv0) { /* * The bindx options, --bindx-add and --bindx-rem, are added to * * 1. provide first testcases for the new bindx system call * * 2. continue to grow sctp_darn with more functions and * features so it will be equivalent to the "sock" tool for * TCP as for SCTP. * * FIXME - * * It is not very effective to use these two options in the * current command line mode of sctp_darn. For example, the * --bindx-rem option can only be used in conjunction with the * --bindx-add simply to test the function in the kernel * path. Ideally, bindx needs to be tested by a tool which * provides an interactive mode for users to change parameters * and configuration dynamically with existing endpoints and * associations. */ fprintf(stderr, "Usage: %s -H -P " "[-h ] [-p ] -l|s\n" " -H, --local\t\tspecify one of the local addresses,\n" " -P, --local-port\tspecify the port number for local addresses,\n" " -h, --remote\t\tspecify the peer address,\n" " -p, --remote-port\tspecify the port number for the peer address,\n" " -l, --listen\t\tprint messages received from the peer,\n" " -s, --send\t\tsend messages to the peer,\n" " -B, --bindx-add" "\tadd the specified address(es) as additional bind\n" "\t\t\taddresses to the local socket. Multiple addresses can\n" "\t\t\tbe specified by using this argument multiple times.\n" "\t\t\tFor example, '-B 10.0.0.1 -B 20.0.0.2'.\n" " -b, --bindx-rem" "\tremove the specified address(es) from the bind\n" "\t\t\taddresses of the local socket. Multiple addresses can\n" "\t\t\tbe specified by using this argument multiple times.\n" "\t\t\tFor example, '-b 10.0.0.1 -b 20.0.0.2'.\n" " -c, --connectx" "\t\tuse the specified address(es) for connection to the\n" "\t\t\tpeer socket. Multiple addresses can be specified by\n" "\t\t\tusing this argument multiple times.\n" "\t\t\tFor example, '-c 10.0.0.1 -c 20.0.0.2'.\n" "\t\t\tThis option is incompatible with the -h option.\n" " -I\t\t\tuse the interactive mode.\n" " -i\t\t\tsetup the specified number of endpoints by using the\n" "\t\t\tspecified local host (-H) and local port (-P). The port\n" "\t\t\tnumber will be incremented by one for each additional\n" "\t\t\tendpoint. All of these endpoints will be listening.\n" "\t\t\tIf a remote host (-h) and a remote port are also\n" "\t\t\tspecified, the first endpoint will start sending fixed\n" "\t\t\tsized messages to the remote host.\n" " -m\t\t\tspecify the sockopt sndbuf/rcvbuf size.\n" " -n\t\t\tset the socket(s) to be in the non-blocking mode.\n" "\t\t\tcollect messages from stdin and deliver them to the\n" "\t\t\tpeer,\n" "--use-poll\t\tuse system call poll() for polling among the\n" "\t\t\tnumber of endpoints specified by the -i option. Without\n" "\t\t\tthis option, select() would be used as default.\n" " -t\t\t\tuse SOCK_STREAM tcp-style sockets.\n" " -z\t\t\tspecify the message size to be sent. The default\n" "\t\t\tmessage size generated would be 16K.\n" " --interface=\"ifname\"\tselect interface for sin6_scope_id.\n", argv0); } /* This function checks messages to see if they are of type 'event' * and if they are well-formed. */ int user_test_check_message(struct msghdr *msg, int controllen, sctp_cmsg_t event) { if (msg->msg_controllen != controllen) { fprintf(stderr, "Got control structure of length %zu, not %d\n", msg->msg_controllen, controllen); exit(1); } if (controllen > 0 && event != CMSG_FIRSTHDR(msg)->cmsg_type) { fprintf(stderr, "Wrong kind of event: %d, not %d\n", CMSG_FIRSTHDR(msg)->cmsg_type, event); exit(1); } return 1; } /* user_test_check_message() */ /* Add another address represented as the string 'parm' to the list * addrs. The argument count is the number of addrs on input and is * adjusted for output. */ struct sockaddr * append_addr(const char *parm, struct sockaddr *addrs, int *ret_count) { struct sockaddr *new_addrs = NULL; void *aptr; struct sockaddr *sa_addr; struct sockaddr_in *b4ap; struct sockaddr_in6 *b6ap; struct hostent *hst4 = NULL; struct hostent *hst6 = NULL; int i4 = 0; int i6 = 0; int j; int orig_count = *ret_count; int count = orig_count; if (!parm) return NULL; /* Get the entries for this host. */ hst4 = gethostbyname(parm); hst6 = gethostbyname2(parm, AF_INET6); if ((NULL == hst4 || hst4->h_length < 1) && (NULL == hst6 || hst6->h_length < 1)) { fprintf(stderr, "bad hostname: %s\n", parm); goto finally; } /* Figure out the number of addresses. */ if (NULL != hst4) { for (i4 = 0; NULL != hst4->h_addr_list[i4]; ++i4) { count++; } } if (NULL != hst6) { for (i6 = 0; NULL != hst6->h_addr_list[i6]; ++i6) { count++; } } /* Expand memory for the new addresses. Assume all the addresses * are v6 addresses. */ new_addrs = (struct sockaddr *) realloc(addrs, sizeof(struct sockaddr_in6) * count); if (NULL == new_addrs) { count = *ret_count; goto finally; } /* Skip the existing addresses. */ aptr = new_addrs; for (j = 0; j < orig_count; j++) { sa_addr = (struct sockaddr *)aptr; switch(sa_addr->sa_family) { case AF_INET: aptr += sizeof(struct sockaddr_in); break; case AF_INET6: aptr += sizeof(struct sockaddr_in6); break; default: count = orig_count; goto finally; } } /* Put the new addresses away. */ if (NULL != hst4) { for (j = 0; j < i4; ++j) { b4ap = (struct sockaddr_in *)aptr; memset(b4ap, 0x00, sizeof(*b4ap)); b4ap->sin_family = AF_INET; b4ap->sin_port = htons(local_port); bcopy(hst4->h_addr_list[j], &b4ap->sin_addr, hst4->h_length); aptr += sizeof(struct sockaddr_in); } /* for (loop through the new v4 addresses) */ } if (NULL != hst6) { for (j = 0; j < i6; ++j) { b6ap = (struct sockaddr_in6 *)aptr; memset(b6ap, 0x00, sizeof(*b6ap)); b6ap->sin6_family = AF_INET6; b6ap->sin6_port = htons(local_port); b6ap->sin6_scope_id = if_index; bcopy(hst6->h_addr_list[j], &b6ap->sin6_addr, hst6->h_length); aptr += sizeof(struct sockaddr_in6); } /* for (loop through the new v6 addresses) */ } finally: *ret_count = count; return new_addrs; } /* append_addr() */ static int parse_inter_commands(char *argv0, char *input, int snd_only) { int i; char *p; int len; int set = 0; int val; struct sockaddr *tmp_addrs = NULL; p = input; if (*p == '?' || *p == '\n') { printf("Interactive commands:\n"); printf("snd= - Do a sendmsg with the specified"); printf(" length.\n"); printf("rcv= - Do a recvmsg."); printf("The length is ignored for now.\n"); printf("bindx-add= - Add a local address"); printf(" with bindx. \n"); printf("bindx-rem= - Remove a local address"); printf(" with bindx. \n"); printf("rcvbuf= - Get/Set receive buffer size\n"); printf("sndbuf= - Get/Set send buffer size.\n"); printf("primary= - Get/Set association's primary\n"); printf("peer_primary=addr- Set association's peer_primary\n"); printf("heartbeat= - Request a user initiated heartbeat\n"); printf("maxseg= - Get/Set Maximum fragment size.\n"); printf("nodelay=<0|1> - Get/Set NODELAY option.\n"); printf("shutdown - Shutdown the association.\n"); printf("abort - Abort the association.\n"); printf("stats - Print GET_ASSOC_STATS (if available in kernel).\n"); printf("? - Help. Display this message.\n"); return -1; } for (i = 0; i < REALLY_BIG; i++) { if (('=' == *p) || ('?' == *p) || ('\n' == *p)) { if ('=' == *p) { set = 1; } *p++ = '\0'; break; } p++; } if (i >= REALLY_BIG) { printf("Invalid input.\n"); return -1; } i = 0; while (NULL != inter_commands[i].cmd) { if (!strcmp(input, inter_commands[i].cmd)) { switch (i) { case INTER_SND: if (snd_only) { if (*p < '0' || *p > '9') { goto err_input; } snd_func(p); } else { goto err_input; } break; case INTER_RCV: if (snd_only) { goto err_input; } break; case INTER_SNDBUF: if (set) { if (*p < '0' || *p > '9') { goto err_input; } } len = (set) ? atoi(p) : 0; sndbuf_func(argv0, inter_sk, len, set); break; case INTER_RCVBUF: if (set) { if (*p < '0' || *p > '9') { goto err_input; } } len = (set) ? atoi(p) : 0; rcvbuf_func(argv0, inter_sk, len, set); break; case INTER_BINDX_ADD: tmp_addrs = get_bindx_addr(p, &len); bindx_func(argv0, inter_sk, tmp_addrs, len, SCTP_BINDX_ADD_ADDR, local_port); free(tmp_addrs); break; case INTER_BINDX_REM: tmp_addrs = get_bindx_addr(p, &len); bindx_func(argv0, inter_sk, tmp_addrs, len, SCTP_BINDX_REM_ADDR, local_port); free(tmp_addrs); break; case INTER_SET_PRIM: primary_func(argv0, inter_sk, p, set); break; case INTER_SET_PEER_PRIM: peer_primary_func(argv0, inter_sk, p, set); break; case INTER_HEARTBEAT: spp_hb_demand_func(argv0, inter_sk, p, set); break; case INTER_SHUTDOWN: shutdown_func(argv0, &inter_sk, SHUTDOWN_SHUTDOWN); break; case INTER_ABORT: shutdown_func(argv0, &inter_sk, SHUTDOWN_ABORT); break; case INTER_NODELAY: if (set) { if (*p < '0' || *p > '9') { goto err_input; } } val = (set) ? atoi(p) : 0; nodelay_func(argv0, inter_sk, val, set); break; case INTER_MAXSEG: if (set) { if (*p < '0' || *p > '9') { goto err_input; } } val = (set) ? atoi(p) : 0; maxseg_func(argv0, inter_sk, val, set); break; case INTER_GET_STATS: get_assocstats_func(inter_sk, associd); break; default: goto err_input; break; } return i; } i++; } err_input: printf("Invalid input.\n"); return -1; } /* parse_inter_commands() */ static char * gen_message(int len) { char *buf; char *p; int i; buf = malloc(len); if (NULL != buf) { for (i = 0, p = buf; i < len; i++, p++) { if (gen_data > GEN_DATA_LAST) { gen_data = GEN_DATA_FIRST; } *p = gen_data++; } } return(buf); } /* gen_message() */ static void snd_func(char *input) { int len; len = atoi(input); if (!(inter_outbuf = gen_message(len))) { fprintf(stderr, "Cannot allocate out message.\n"); exit(1); } inter_outlen = len; } /* snd_func() */ static void sndbuf_func(char *argv0, int sk, int len, int set) { int error; socklen_t optlen; if (set) { error = setsockopt(sk, SOL_SOCKET, SO_SNDBUF, (char *)&len, sizeof(len)); } else { optlen = sizeof(len); error = getsockopt(sk, SOL_SOCKET, SO_SNDBUF, (char *)&len, &optlen); } if (error != 0) { fprintf(stderr, "%s: Error setting/getting sndbuf: %s.\n", argv0, strerror(errno)); exit(1); } if (!set) { printf("sndbuf is %d.\n", len); } } /* sndbuf_func() */ static void rcvbuf_func(char *argv0, int sk, int len, int set) { int error; socklen_t optlen; if (set) { error = setsockopt(sk, SOL_SOCKET, SO_RCVBUF, (char *)&len, sizeof(len)); } else { optlen = sizeof(len); error = getsockopt(sk, SOL_SOCKET, SO_RCVBUF, (char *)&len, &optlen); } if (error != 0) { fprintf(stderr, "%s: Error setting/getting rcvbuf: %s.\n", argv0, strerror(errno)); exit(1); } if (!set) { printf("rcvbuf is %d.\n", len); } } /* rcvbuf_func() */ static struct sockaddr * get_bindx_addr(char *in, int *count) { struct sockaddr *tmp_addrs = NULL; char *p = in; /* Set the buffer for address parsing. */ while ('\n' != *p) { p++; } *p = '\0'; *count = 0; tmp_addrs = append_addr(in, tmp_addrs, count); if (NULL == tmp_addrs) { /* We have no memory, so keep fprintf() * from trying to allocate more. */ fprintf(stderr, "No memory to add "); fprintf(stderr, "%s\n", in); exit(2); } return tmp_addrs; } /* get_bindx_addr() */ static int bindx_func(char *argv0, int sk, struct sockaddr *addrs, int count, int flag, int portnum) { int error; int i; struct sockaddr *sa_addr; void *aptr; if (0 == portnum) { fprintf(stderr, "%s: A non-0 local port number is ", argv0); fprintf(stderr, "required for bindx to work!\n"); return -1 ; } /* Set the port in every address. */ aptr = addrs; for (i = 0; i < count; i++) { sa_addr = (struct sockaddr *)aptr; switch(sa_addr->sa_family) { case AF_INET: ((struct sockaddr_in *)sa_addr)->sin_port = htons(portnum); aptr += sizeof(struct sockaddr_in); break; case AF_INET6: ((struct sockaddr_in6 *)sa_addr)->sin6_port = htons(portnum); aptr += sizeof(struct sockaddr_in6); break; default: fprintf(stderr, "Invalid address family\n"); return -1; } } error = sctp_bindx(sk, addrs, count, flag); if (error != 0) { if (flag == SCTP_BINDX_ADD_ADDR) { fprintf(stderr, "%s: error adding addrs: %s.\n", argv0, strerror(errno)); return -1; } else { fprintf(stderr, "%s: error removing addrs: %s.\n", argv0, strerror(errno)); return -1; } } return 0; } /* bindx_func() */ static int connectx_func(char *argv0, int sk, struct sockaddr *addrs, int count) { int error; int i; struct sockaddr *sa_addr; void *aptr; if (0 == remote_port) { fprintf(stderr, "%s: A non-0 remote port number is ", argv0); fprintf(stderr, "required for connectx to work!\n"); return -1 ; } /* Set the port in every address. */ aptr = addrs; for (i = 0; i < count; i++) { sa_addr = (struct sockaddr *)aptr; switch(sa_addr->sa_family) { case AF_INET: ((struct sockaddr_in *)sa_addr)->sin_port = htons(remote_port); aptr += sizeof(struct sockaddr_in); break; case AF_INET6: ((struct sockaddr_in6 *)sa_addr)->sin6_port = htons(remote_port); aptr += sizeof(struct sockaddr_in6); break; default: fprintf(stderr, "Invalid address family\n"); return -1; } } error = sctp_connectx(sk, addrs, count, NULL); if (error != 0) { if (errno == ECONNREFUSED) return -2; fprintf(stderr, "%s: error connecting to addrs: %s.\n", argv0, strerror(errno)); return -1; } return 0; } /* connectx_func() */ static void primary_func(char *argv0, int sk, char *cp, int set) { struct sctp_prim prim; struct sockaddr_in *in_addr; struct sockaddr_in6 *in6_addr; struct sockaddr *saddr; socklen_t prim_len; int ret; char *p = cp; char addr_buf[INET6_ADDRSTRLEN]; const char *ap = NULL; prim_len = sizeof(struct sctp_prim); if (!set) { prim.ssp_assoc_id = associd; ret = getsockopt(sk, IPPROTO_SCTP, SCTP_PRIMARY_ADDR, &prim, &prim_len); if (ret < 0) goto err; saddr = (struct sockaddr *)&prim.ssp_addr; if (AF_INET == saddr->sa_family) { in_addr = (struct sockaddr_in *)&prim.ssp_addr; ap = inet_ntop(AF_INET, &in_addr->sin_addr, addr_buf, INET6_ADDRSTRLEN); } else if (AF_INET6 == saddr->sa_family) { in6_addr = (struct sockaddr_in6 *)&prim.ssp_addr; ap = inet_ntop(AF_INET6, &in6_addr->sin6_addr, addr_buf, INET6_ADDRSTRLEN); } if (!ap) goto err; printf("%s\n", ap); return; } /* Set the buffer for address parsing. */ while ('\n' != *p) p++; *p = '\0'; prim.ssp_assoc_id = associd; if (strchr(cp, '.')) { in_addr = (struct sockaddr_in *)&prim.ssp_addr; in_addr->sin_port = htons(remote_port); in_addr->sin_family = AF_INET; ret = inet_pton (AF_INET, cp, &in_addr->sin_addr); if (ret <= 0) goto err; } else if (strchr(cp, ':')) { in6_addr = (struct sockaddr_in6 *)&prim.ssp_addr; in6_addr->sin6_port = htons(remote_port); in6_addr->sin6_family = AF_INET6; ret = inet_pton(AF_INET6, cp, &in6_addr->sin6_addr); if (ret <= 0) goto err; } else goto err; ret = setsockopt(sk, IPPROTO_SCTP, SCTP_PRIMARY_ADDR, &prim, sizeof(struct sctp_prim)); if (ret < 0) goto err; return; err: if (!errno) errno = EINVAL; fprintf(stderr, "%s: error %s primary: %s.\n", argv0, (set)?"setting":"getting", strerror(errno)); } static void peer_primary_func(char *argv0, int sk, char *cp, int set) { struct sctp_setpeerprim setpeerprim; struct sockaddr_in *in_addr; struct sockaddr_in6 *in6_addr; int ret; char *p = cp; if (!set) { goto err; } /* Set the buffer for address parsing. */ while ('\n' != *p) p++; *p = '\0'; setpeerprim.sspp_assoc_id = associd; if (strchr(cp, '.')) { in_addr = (struct sockaddr_in *)&setpeerprim.sspp_addr; in_addr->sin_port = htons(local_port); in_addr->sin_family = AF_INET; ret = inet_pton (AF_INET, cp, &in_addr->sin_addr); if (ret <= 0) goto err; } else if (strchr(cp, ':')) { in6_addr = (struct sockaddr_in6 *)&setpeerprim.sspp_addr; in6_addr->sin6_port = htons(local_port); in6_addr->sin6_family = AF_INET6; ret = inet_pton(AF_INET6, cp, &in6_addr->sin6_addr); if (ret <= 0) goto err; } else goto err; ret = setsockopt(sk, IPPROTO_SCTP, SCTP_SET_PEER_PRIMARY_ADDR, &setpeerprim, sizeof(struct sctp_setpeerprim)); if (ret < 0) goto err; return; err: if (!errno) errno = EINVAL; fprintf(stderr, "%s: error %s peer_primary: %s.\n", argv0, (set)?"setting":"getting", strerror(errno)); } static void spp_hb_demand_func(char *argv0, int sk, char *cp, int set) { struct sctp_paddrparams params; struct sockaddr_in *in_addr; struct sockaddr_in6 *in6_addr; int ret; char *p = cp; memset(¶ms, 0, sizeof(struct sctp_paddrparams)); params.spp_assoc_id = associd; params.spp_flags = SPP_HB_DEMAND; if (set) { /* Set the buffer for address parsing. */ while ('\n' != *p) p++; *p = '\0'; if (strchr(cp, '.')) { in_addr = (struct sockaddr_in *)¶ms.spp_address; in_addr->sin_port = htons(remote_port); in_addr->sin_family = AF_INET; ret = inet_pton(AF_INET, cp, &in_addr->sin_addr); if (ret <= 0) goto err; } else if (strchr(cp, ':')) { in6_addr = (struct sockaddr_in6 *)¶ms.spp_address; in6_addr->sin6_port = htons(remote_port); in6_addr->sin6_family = AF_INET6; ret = inet_pton(AF_INET6, cp, &in6_addr->sin6_addr); if (ret <= 0) goto err; } else goto err; } ret = setsockopt(sk, IPPROTO_SCTP, SCTP_PEER_ADDR_PARAMS, ¶ms, sizeof(struct sctp_paddrparams)); if (ret < 0) goto err; return; err: if (!errno) errno = EINVAL; fprintf(stderr, "%s: error %s peer_addr_params: %s.\n", argv0, (set)?"setting":"getting", strerror(errno)); } static int nodelay_func(char *argv0, int sk, int val, int set) { socklen_t optlen; int error; if (set) { error = setsockopt(sk, SOL_SCTP, SCTP_NODELAY, (char *)&val, sizeof(val)); } else { optlen = sizeof(val); error = getsockopt(sk, SOL_SCTP, SCTP_NODELAY, (char *)&val, &optlen); } if (error != 0) { fprintf(stderr, "%s: Error setting/getting nodelay: %s.\n", argv0, strerror(errno)); exit(1); } if (!set) { printf("nodelay is %d.\n", val); } return error; } static int maxseg_func(char *argv0, int sk, int val, int set) { socklen_t optlen; int error; if (set) { error = setsockopt(sk, SOL_SCTP, SCTP_MAXSEG, (char *)&val, sizeof(val)); } else { optlen = sizeof(val); error = getsockopt(sk, SOL_SCTP, SCTP_MAXSEG, (char *)&val, &optlen); } if (error != 0) { fprintf(stderr, "%s: Error setting/getting maxseg: %s.\n", argv0, strerror(errno)); exit(1); } if (!set) { printf("maxseg is %d.\n", val); } return error; } static int shutdown_func(char *argv0, int *skp, int shutdown_type) { struct msghdr outmessage; char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))]; struct cmsghdr *cmsg; int error=0, bytes_sent; struct sctp_sndrcvinfo *sinfo; struct hostent *hst; char *sd_type; int sk = *skp; if (shutdown_type == SHUTDOWN_ABORT) sd_type = "ABORT"; else sd_type = "SHUTDOWN"; /* Verify that the association is present. */ error = test_sk_for_assoc(sk, associd); if (error != 0) { printf("The association isn't present yet! Cannot %s!\n", sd_type); return -1; } if (socket_type == SOCK_SEQPACKET) { /* Set up the destination. */ if (remote_host) { hst = gethostbyname(remote_host); if (hst == NULL) { hst = gethostbyname2(remote_host, AF_INET6); } if (hst == NULL || hst->h_length < 1) { fprintf(stderr, "%s: bad hostname: %s\n", argv0, remote_host); exit(1); } ra_family = hst->h_addrtype; switch (ra_family) { case AF_INET: ra_len = sizeof(remote_addr.v4); ra_raw = &remote_addr.v4.sin_addr; remote_addr.v4.sin_port = htons(remote_port); remote_addr.v4.sin_family = AF_INET; break; case AF_INET6: ra_len = sizeof(remote_addr.v6); ra_raw = &remote_addr.v6.sin6_addr; remote_addr.v6.sin6_port = htons(remote_port); remote_addr.v6.sin6_family = AF_INET6; break; default: fprintf(stderr, "Invalid address type.\n"); exit(1); break; } memcpy(ra_raw, hst->h_addr_list[0], hst->h_length); } /* Initialize the message struct we use to pass messages to * the remote socket. */ outmessage.msg_name = &remote_addr; outmessage.msg_namelen = ra_len; 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)); if (shutdown_type == SHUTDOWN_ABORT) sinfo->sinfo_flags |= SCTP_ABORT; else sinfo->sinfo_flags |= SCTP_EOF; sinfo->sinfo_assoc_id = associd; bytes_sent = sendmsg(sk, &outmessage, 0); if (bytes_sent != 0) { printf("Failure: %s.\n", strerror(errno)); return -1; } /* Receive the COMM_LOST or SHUTDOWN_COMP event. */ test_recv_assoc_change(sk); } else { if (shutdown_type == SHUTDOWN_ABORT) { struct linger { int l_onoff; int l_linger; } data = {1, 0}; error = setsockopt(sk, SOL_SOCKET, SO_LINGER, (char *)&data, sizeof(data)); if (error != 0) { printf("setsockopt failed %s\n", strerror(errno)); exit(1); } } error = close(sk); if (error != 0) { printf("close failed %s\n", strerror(errno)); exit(1); } *skp = sk = build_endpoint(argv0, local_port); } /* Verify that the association is no longer present. */ error = test_sk_for_assoc(sk, associd); if (error != 0) { printf("Successfully %s the original association\n", sd_type); associd = 0; new_connection = 1; } else { printf("%s failed\n", sd_type); exit(1); } return 0; } static int get_assocstats_func(int sk, sctp_assoc_t assoc_id) { int error = 0; struct sctp_assoc_stats stats; socklen_t len; if (assoc_id == 0) { printf("No association present yet\n"); return -1; } memset(&stats, 0, sizeof(struct sctp_assoc_stats)); stats.sas_assoc_id = assoc_id; len = sizeof(struct sctp_assoc_stats); error = getsockopt(sk, SOL_SCTP, SCTP_GET_ASSOC_STATS, (char *)&stats, &len); if (error != 0) { printf("get_assoc_stats() failed %s\n", strerror(errno)); return error; } printf("Retransmitted Chunks: %" PRIu64 "\n", (uint64_t) stats.sas_rtxchunks); printf("Gap Acknowledgements Received: %" PRIu64 "\n", (uint64_t) stats.sas_gapcnt); printf("TSN received > next expected: %" PRIu64 "\n", (uint64_t) stats.sas_outofseqtsns); printf("SACKs sent: %" PRIu64 "\n", (uint64_t) stats.sas_osacks); printf("SACKs received: %" PRIu64 "\n", (uint64_t) stats.sas_isacks); printf("Control chunks sent: %" PRIu64 "\n", (uint64_t) stats.sas_octrlchunks); printf("Control chunks received: %" PRIu64 "\n", (uint64_t) stats.sas_ictrlchunks); printf("Ordered data chunks sent: %" PRIu64 "\n", (uint64_t) stats.sas_oodchunks); printf("Ordered data chunks received: %" PRIu64 "\n", (uint64_t) stats.sas_iodchunks); printf("Unordered data chunks sent: %" PRIu64 "\n", (uint64_t) stats.sas_ouodchunks); printf("Unordered data chunks received: %" PRIu64 "\n", (uint64_t) stats.sas_iuodchunks); printf("Dups received (ordered+unordered): %" PRIu64 "\n", (uint64_t) stats.sas_idupchunks); printf("Packets sent: %" PRIu64 "\n", (uint64_t) stats.sas_opackets); printf("Packets received: %" PRIu64 "\n", (uint64_t) stats.sas_ipackets); printf("Maximum Observed RTO this period: %" PRIu64 " - Transport: ", (uint64_t) stats.sas_maxrto); print_sockaddr((struct sockaddr *)&stats.sas_obs_rto_ipaddr); printf("\n"); return 0; } static int test_sk_for_assoc(int sk, sctp_assoc_t assoc_id) { int error = 0; struct sctp_status status; socklen_t status_len; memset(&status, 0, sizeof(status)); if (assoc_id) status.sstat_assoc_id = assoc_id; status_len = sizeof(struct sctp_status); error = getsockopt(sk, SOL_SCTP, SCTP_STATUS, (char *)&status, &status_len); return error; } /* Receive a notification and return the corresponding associd if the event is * SCTP_COMM_UP. Return 0 for any other event. */ static sctp_assoc_t test_recv_assoc_change(int sk) { struct msghdr inmessage; struct iovec iov; char incmsg[CMSG_SPACE(sizeof(_sctp_cmsg_data_t))]; int error; /* Initialize inmessage with enough space for DATA... */ memset(&inmessage, 0, sizeof(inmessage)); if ((iov.iov_base = malloc(REALLY_BIG)) == NULL) { printf("%s: Can't allocate memory.\n", __FUNCTION__); exit(1); } iov.iov_len = REALLY_BIG; inmessage.msg_iov = &iov; inmessage.msg_iovlen = 1; /* or a control message. */ inmessage.msg_control = incmsg; inmessage.msg_controllen = sizeof(incmsg); error = recvmsg(sk, &inmessage, MSG_WAITALL); if (error < 0) { printf("%s: recvmsg: %s\n", __FUNCTION__, strerror(errno)); exit(1); } return test_verify_assoc_change(&inmessage); } /* Verify a notification and return the corresponding associd if the event is * SCTP_COMM_UP. Return 0 for any other event. */ static sctp_assoc_t test_verify_assoc_change(struct msghdr *msg) { union sctp_notification *sn; if (!(msg->msg_flags & MSG_NOTIFICATION)) { fprintf(stderr, "%s: Received data when notification is expected\n", __FUNCTION__); exit(1); } sn = (union sctp_notification *)msg->msg_iov->iov_base; if (SCTP_ASSOC_CHANGE != sn->sn_header.sn_type) { fprintf(stderr, "%s: Received unexpected notification: %d", __FUNCTION__, sn->sn_header.sn_type); exit(1); } switch(sn->sn_assoc_change.sac_state) { case SCTP_COMM_UP: printf("Received SCTP_COMM_UP\n"); break; case SCTP_COMM_LOST: printf("Received SCTP_COMM_LOST\n"); break; case SCTP_RESTART: printf("Received SCTP_RESTART\n"); break; case SCTP_SHUTDOWN_COMP: printf("Received SCTP_SHUTDOWN_COMP\n"); break; case SCTP_CANT_STR_ASSOC: printf("Received SCTP_CANT_STR_ASSOC\n"); break; } if (SCTP_COMM_UP == sn->sn_assoc_change.sac_state) return sn->sn_assoc_change.sac_assoc_id; else return 0; } void print_addr_buf(void * laddrs, int n_laddrs) { void *addr_buf = laddrs; int i; for (i = 0; i < n_laddrs; i++) { addr_buf += print_sockaddr((struct sockaddr *)addr_buf); printf("\n"); } } int print_sockaddr(struct sockaddr *sa_addr) { struct sockaddr_in *in_addr; struct sockaddr_in6 *in6_addr; if (AF_INET == sa_addr->sa_family) { in_addr = (struct sockaddr_in *)sa_addr; printf("%d.%d.%d.%d:%d", NIPQUAD(in_addr->sin_addr), ntohs(in_addr->sin_port)); return sizeof(struct sockaddr_in); } else { in6_addr = (struct sockaddr_in6 *)sa_addr; printf("%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x:%d", NIP6(in6_addr->sin6_addr), ntohs(in6_addr->sin6_port)); return sizeof(struct sockaddr_in6); } }