blob: bcfb822ae8d78710d62dc25d50cf1e9785479222 [file] [log] [blame]
/* 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 <lksctp-developers@lists.sourceforge.net>
*
* 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 <piggy@acm.org>
* Karl Knutson <karl@athena.chicago.il.us>
* Hui Huang <hui.huang@nokia.com>
* Daisy Chang <daisyc@us.ibm.com>
* Sridhar Samudrala <sri@us.ibm.com>
*/
/* 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 <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
//#define _GNU_SOURCE
#include <getopt.h>
#include <netdb.h>
#include <inttypes.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <sys/param.h>
#include <sys/poll.h>
#include <arpa/inet.h>
#include <errno.h>
#include <net/if.h>
#include <netinet/sctp.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#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 <localhost> -P <localport> "
"[-h <remotehost>] [-p <remoteport>] -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=<int> - Do a sendmsg with the specified");
printf(" length.\n");
printf("rcv=<int> - Do a recvmsg.");
printf("The length is ignored for now.\n");
printf("bindx-add=<addr> - Add a local address");
printf(" with bindx. \n");
printf("bindx-rem=<addr> - Remove a local address");
printf(" with bindx. \n");
printf("rcvbuf=<int> - Get/Set receive buffer size\n");
printf("sndbuf=<int> - Get/Set send buffer size.\n");
printf("primary=<addr> - Get/Set association's primary\n");
printf("peer_primary=addr- Set association's peer_primary\n");
printf("heartbeat=<addr> - Request a user initiated heartbeat\n");
printf("maxseg=<int> - 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(&params, 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 *)&params.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 *)&params.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,
&params, 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);
}
}