| Server IP : 172.67.216.182 / Your IP : 172.68.164.43 Web Server : Apache System : Linux krdc-ubuntu-s-2vcpu-4gb-amd-blr1-01.localdomain 5.15.0-142-generic #152-Ubuntu SMP Mon May 19 10:54:31 UTC 2025 x86_64 User : www ( 1000) PHP Version : 7.4.33 Disable Function : passthru,exec,system,putenv,chroot,chgrp,chown,shell_exec,popen,proc_open,pcntl_exec,ini_alter,ini_restore,dl,openlog,syslog,readlink,symlink,popepassthru,pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,imap_open,apache_setenv MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /usr/share/doc/libsctp-dev/examples/ |
Upload File : |
/* SCTP kernel Implementation
* (C) Copyright IBM Corp. 2001, 2003
* Copyright (c) 1999 Cisco
* Copyright (c) 1999, 2000, 2001 Motorola
* Copyright (c) 2001-2002 Nokia
* Copyright (c) 2001 La Monte H.P. Yarroll
*
* This is a userspace test application for the SCTP kernel
* implementation.
*
* This program 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.
*
* This program 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 <[email protected]>
*
* Or submit a bug report through the following website:
* http://www.sf.net/projects/lksctp
*
* Written or modified by:
* Hui Huang <[email protected]>
* Sridhar Samudrala <[email protected]>
* Jon Grimm <[email protected]>
* Daisy Chang <[email protected]>
* Ryan Layer <[email protected]>
*/
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <errno.h>
#include <netinet/sctp.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/param.h>
#include <fcntl.h>
#include <netdb.h>
#include <net/if.h>
#include <sys/resource.h>
#define REALLY_BIG 65536
#define SERVER 0
#define CLIENT 1
#define MIXED 2
#define NOT_DEFINED 666
#define REPEAT 10
#define BIG_REPEAT 1000000
#define MAX_BIND_RETRYS 10
#define BODYSIZE 10
#define MSG_CNT 10 /* If this is changed the msg_sizes array
needs to be modified accordingly. */
#define DEFAULT_MAX_WINDOW 32768
#define DEFAULT_MIN_WINDOW 1500
#define DEBUG_NONE 0
#define DEBUG_MIN 1
#define DEBUG_MAX 2
#define STREAM_PATTERN_SEQUENTIAL 0
#define STREAM_PATTERN_RANDOM 1
#define ORDER_PATTERN_UNORDERED 0
#define ORDER_PATTERN_ORDERED 1
#define ORDER_PATTERN_ALTERNATE 2
#define ORDER_PATTERN_RANDOM 3
#define ASSOC_PATTERN_SEQUENTIAL 0
#define ASSOC_PATTERN_RANDOM 1
#define NCASES 6
#define MAX_POLL_SKS 256
#define DEBUG_PRINT(level, print_this...) \
{ \
if (debug_level >= level) { \
fprintf(stdout, print_this); \
fflush(stdout); \
} \
} /* DEBUG_PRINT */
/* Convenience structure to determine space needed for cmsg. */
typedef union {
struct sctp_initmsg init;
struct sctp_sndrcvinfo sndrcvinfo;
} _sctp_cmsg_data_t;
#ifdef __FreeBSD__
typedef union {
int raw;
struct sctp_initmsg init;
struct sctp_sndrcvinfo sndrcv;
} sctp_cmsg_data_t;
#endif
#define CMSG_SPACE_INITMSG (CMSG_SPACE(sizeof(struct sctp_initmsg)))
#define CMSG_SPACE_SNDRCV (CMSG_SPACE(sizeof(struct sctp_sndrcvinfo)))
typedef struct {
int rem_port;
int order_state;
int stream_state;
int msg_cnt;
int msg_sent;
int cycle;
} _assoc_state;
typedef struct {
int sk;
int assoc_i;
_assoc_state *assoc_state;
} _poll_sks;
char *local_host = NULL;
int local_port = 0;
char *remote_host = NULL;
int remote_port = 0;
/* struct sockaddr_in s_rem, s_loc; */
struct sockaddr_storage s_rem, s_loc;
int r_len, l_len;
int test_case = 0;
int size_arg = 0;
int xflag = 0;
int debug_level = DEBUG_MAX;
int do_exit = 1;
int stream_pattern = STREAM_PATTERN_SEQUENTIAL;
int stream_state = 0;
int order_pattern = ORDER_PATTERN_UNORDERED;
int order_state = 0;
int max_stream = 0;
int seed = 0;
int max_msgsize = DEFAULT_MAX_WINDOW;
int timetolive = 0;
int assoc_pattern = ASSOC_PATTERN_SEQUENTIAL;
int socket_type = SOCK_SEQPACKET;
int repeat_count = 0;
int listeners = 0;
int tosend = 0;
_poll_sks poll_sks[MAX_POLL_SKS];
int repeat = REPEAT;
int msg_cnt = MSG_CNT;
int drain = 0;
int role = NOT_DEFINED;
struct sockaddr *bindx_add_addrs = NULL;
int bindx_add_count = 0;
struct sockaddr *connectx_addrs = NULL;
int connectx_count = 0;
int if_index = 0;
unsigned char msg[] = "012345678901234567890123456789012345678901234567890";
static int msg_sizes[NCASES][MSG_CNT] =
{{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1452, 2904, 4356, 1452, 2904, 4356, 1452, 2904, 4356, 1452},
{1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453, 1453},
{1, 1453, 32768, 1, 1453, 32768, 1, 1453, 32768, 1},
{1, 1000, 2000, 3000, 5000, 10000, 15000, 20000, 25000, 32768},
{32768, 32768, 32768, 32768, 32768, 32768, 32768, 32768, 32768, 32768},
};
static const char *sac_state_tbl[] = {
"COMMUNICATION_UP",
"COMMUNICATION_LOST",
"RESTART",
"SHUTDOWN_COMPLETE",
"CANT_START_ASSOCICATION"
};
void usage(char *argv0)
{
fprintf(stderr, "\nusage:\n");
fprintf(stderr, " server:\n");
fprintf(stderr, " %8s -H local-addr -P local-port -l [-d level] [-x]\n"
"\t [-L num-ports] [-S num-ports]\n"
"\t [-a assoc-pattern]\n"
"\t [-i interface]\n",
argv0);
fprintf(stderr, "\n");
fprintf(stderr, " client:\n");
fprintf(stderr, " %8s -H local-addr -P local-port -h remote-addr\n"
"\t -p remote-port -s [-c case ] [-d level]\n"
"\t [-x repeat] [-o order-pattern] [-t stream-pattern]\n"
"\t [-M max-stream] [-r rand-seed]\n"
"\t [-m max-msgsize]\n"
"\t [-L num-ports] [-S num-ports]\n"
"\t [-a assoc-pattern]\n"
"\t [-i interface]\n",
argv0);
fprintf(stderr, "\n");
fprintf(stderr, "\t-a assoc_pattern in the mixed mode\n");
fprintf(stderr, "\t 0 = sequential ascending(default)\n");
fprintf(stderr, "\t 1 = random\n");
fprintf(stderr, "\t-d debug\n");
fprintf(stderr, "\t 0 = none\n");
fprintf(stderr, "\t 1 = min(default)\n");
fprintf(stderr, "\t 2 = max\n");
fprintf(stderr, "\t-c testcase\n");
fprintf(stderr, "\t 0 = 1 byte packets.\n");
fprintf(stderr, "\t 1 = Sequence of multiples of 1452 byte packets.\n");
fprintf(stderr, "\t (1452 is fragmentation point for an i/f with ");
fprintf(stderr, "1500 as mtu.)\n");
fprintf(stderr, "\t 2 = 1453 byte packets.\n");
fprintf(stderr, "\t (min. size at which fragmentation occurs\n");
fprintf(stderr, "\t for an i/f with 1500 as mtu.)\n");
fprintf(stderr, "\t 3 = Sequence of 1, 1453, 32768 byte packets.\n");
fprintf(stderr, "\t 4 = Sequence of following size packets.\n");
fprintf(stderr, "\t (1, 1000, 2000, 3000, 5000, 10000,");
fprintf(stderr, "15000, 20000, 25000, 32768)\n");
fprintf(stderr, "\t 5 = 32768 byte packets.\n");
fprintf(stderr, "\t (default max receive window size.)\n");
fprintf(stderr, "\t 6 = random size packets.\n");
fprintf(stderr, "\t -ve value = Packets of specifed size.\n");
fprintf(stderr, "\t-m max msgsize for option -c 6 (1500-65515, default value 32768)\n");
fprintf(stderr, "\t-x number of repeats\n");
fprintf(stderr, "\t-o order-pattern\n");
fprintf(stderr, "\t 0 = all unordered(default) \n");
fprintf(stderr, "\t 1 = all ordered \n");
fprintf(stderr, "\t 2 = alternating \n");
fprintf(stderr, "\t 3 = random\n");
fprintf(stderr, "\t-t stream-pattern\n");
fprintf(stderr, "\t 0 = sequential ascending(default)\n");
fprintf(stderr, "\t 1 = random\n");
fprintf(stderr, "\t-M max-stream (default value 0)\n");
fprintf(stderr, "\t-r seed (default 0, use time())\n");
fprintf(stderr, "\t-L num-ports (default value 0). Run the mixed mode\n");
fprintf(stderr, "\t-S num-ports (default value 0). Run the mixed mode\n");
fprintf(stderr, "\t-D drain. If in client mode do a read following send.\n");
fprintf(stderr, "\t-T use SOCK_STREAM tcp-style sockets.\n");
fprintf(stderr, "\t-B add the specified address(es) as additional bind\n");
fprintf(stderr, "\t addresses of the local socket. Multiple addresses can\n");
fprintf(stderr, "\t be specified by using this argument multiple times.\n");
fprintf(stderr, "\t For example, '-B 10.0.0.1 -B 20.0.0.2'.\n");
fprintf(stderr, "\t In case of IPv6 linklocal address, interface name can be set in following way \n");
fprintf(stderr, "\t For example, '-B fe80::f8c3:b77f:698e:4506%%eth2'.\n");
fprintf(stderr, "\t-C use the specified address(es) for connection to the\n");
fprintf(stderr, "\t peer socket. Multiple addresses can be specified by\n");
fprintf(stderr, "\t using this argument multiple times.\n");
fprintf(stderr, "\t For example, '-C 10.0.0.1 -C 20.0.0.2'.\n");
fprintf(stderr, "\t This option is incompatible with the -h option.\n");
fprintf(stderr, "\t-O time to live (default value 0)\n");
fprintf(stderr, "\n");
fflush(stderr);
} /* usage() */
void *
build_msg(int len)
{
int i = len - 1;
int n;
char *msg_buf, *p;
msg_buf = malloc(len);
if (NULL == msg_buf) {
fprintf(stderr, "\n\t\t*** malloc not enough memory!!! ***\n");
exit(1);
}
p = msg_buf;
do {
n = ((i > 50)?50:i);
memcpy(p, msg, ((i > 50)?50:i));
p += n;
i -= n;
} while (i > 0);
msg_buf[len-1] = '\0';
return(msg_buf);
} /* build_msg() */
static int
print_cmsg(int type, sctp_cmsg_data_t *data)
{
switch(type) {
case SCTP_INIT:
DEBUG_PRINT(DEBUG_MAX, "\tINIT\n");
if (DEBUG_MAX == debug_level) {
printf("\t\tsinit_num_ostreams=%d ",
data->init.sinit_num_ostreams);
printf("sinit_max_instreams=%d ",
data->init.sinit_max_instreams);
printf("sinit_max_attempts=%d ",
data->init.sinit_max_attempts);
printf("sinit_max_init_timeo=%d\n",
data->init.sinit_max_init_timeo);
}
break;
case SCTP_SNDRCV:
DEBUG_PRINT(DEBUG_MAX, "\t SNDRCV");
if (DEBUG_MAX == debug_level) {
printf("(stream=%u ", data->sndrcv.sinfo_stream);
printf("ssn=%u ", data->sndrcv.sinfo_ssn);
printf("tsn=%u ", data->sndrcv.sinfo_tsn);
printf("flags=0x%x ", data->sndrcv.sinfo_flags);
printf("ppid=%u\n", data->sndrcv.sinfo_ppid);
printf("cumtsn=%u\n", data->sndrcv.sinfo_cumtsn);
}
break;
default:
DEBUG_PRINT(DEBUG_MIN, "\tUnknown type: %d\n", type);
break;
}
fflush(stdout);
return 0;
} /* print_cmsg() */
/* This function prints the message. */
static int
print_message(const int sk, struct msghdr *msg, size_t msg_len) {
struct cmsghdr *scmsg;
sctp_cmsg_data_t *data;
int i;
if (!(MSG_NOTIFICATION & msg->msg_flags)) {
int index = 0;
DEBUG_PRINT(DEBUG_MIN, "Data %zu bytes.", msg_len);
DEBUG_PRINT(DEBUG_MAX, " First %zu bytes: ",
(msg_len < BODYSIZE)?msg_len:BODYSIZE);
/* Make sure that everything is printable and that we
* are NUL terminated...
*/
while ( msg_len > 0 ) {
char *text, tmptext[BODYSIZE];
int len;
memset(tmptext, 0x0, BODYSIZE);
text = msg->msg_iov[index].iov_base;
len = msg->msg_iov[index].iov_len;
if (msg_len == 1 && text[0] == 0) {
DEBUG_PRINT(DEBUG_MIN, "<empty> text[0]=%d",
text[0]);
break;
}
if ( len > msg_len ) {
/* text[(len = msg_len) - 1] = '\0'; */
text[(len = msg_len)] = '\0';
}
if ( (msg_len -= len) > 0 ) { index++; }
for (i = 0; i < len - 1; ++i) {
if (!isprint(text[i])) text[i] = '.';
}
strncpy(tmptext, text, BODYSIZE);
tmptext[BODYSIZE-1] = '\0';
DEBUG_PRINT(DEBUG_MAX, "%s", tmptext);
}
DEBUG_PRINT(DEBUG_MIN, "\n");
fflush(stdout);
} else { /* if(we have notification) */
struct sctp_assoc_change *sac;
struct sctp_send_failed *ssf;
struct sctp_paddr_change *spc;
struct sctp_remote_error *sre;
union sctp_notification *snp;
char addrbuf[INET6_ADDRSTRLEN];
const char *ap;
struct sockaddr_in *sin;
struct sockaddr_in6 *sin6;
int index = 0;
snp = (union sctp_notification *)msg->msg_iov[index].iov_base;
DEBUG_PRINT(DEBUG_MIN, "Notification:");
switch (snp->sn_header.sn_type) {
case SCTP_ASSOC_CHANGE:
sac = &snp->sn_assoc_change;
DEBUG_PRINT(DEBUG_MIN,
" SCTP_ASSOC_CHANGE(%s)\n",
sac_state_tbl[sac->sac_state]);
DEBUG_PRINT(DEBUG_MAX,
"\t\t(assoc_change: state=%hu, "
"error=%hu, instr=%hu "
"outstr=%hu)\n",
sac->sac_state, sac->sac_error,
sac->sac_inbound_streams,
sac->sac_outbound_streams);
break;
case SCTP_PEER_ADDR_CHANGE:
spc = &snp->sn_paddr_change;
DEBUG_PRINT(DEBUG_MIN,
" SCTP_PEER_ADDR_CHANGE\n");
if (spc->spc_aaddr.ss_family == AF_INET) {
sin = (struct sockaddr_in *)
&spc->spc_aaddr;
ap = inet_ntop(AF_INET, &sin->sin_addr,
addrbuf,
INET6_ADDRSTRLEN);
} else {
sin6 = (struct sockaddr_in6 *)
&spc->spc_aaddr;
ap = inet_ntop(AF_INET6,
&sin6->sin6_addr,
addrbuf,
INET6_ADDRSTRLEN);
}
DEBUG_PRINT(DEBUG_MAX,
"\t\t(peer_addr_change: %s "
"state=%d, error=%d)\n",
ap, spc->spc_state,
spc->spc_error);
break;
case SCTP_SEND_FAILED:
ssf = &snp->sn_send_failed;
DEBUG_PRINT(DEBUG_MIN,
" SCTP_SEND_FAILED\n");
DEBUG_PRINT(DEBUG_MAX,
"\t\t(sendfailed: len=%hu "
"err=%d)\n",
ssf->ssf_length, ssf->ssf_error);
break;
case SCTP_REMOTE_ERROR:
sre = &snp->sn_remote_error;
DEBUG_PRINT(DEBUG_MIN,
" SCTP_REMOTE_ERROR\n");
DEBUG_PRINT(DEBUG_MAX,
"\t\t(remote_error: err=%hu)\n",
ntohs(sre->sre_error));
break;
case SCTP_SHUTDOWN_EVENT:
DEBUG_PRINT(DEBUG_MIN,
" SCTP_SHUTDOWN_EVENT\n");
break;
default:
DEBUG_PRINT(DEBUG_MIN,
" Unknown type: %hu\n",
snp->sn_header.sn_type);
break;
}
fflush(stdout);
return 1;
} /* notification received */
for (scmsg = CMSG_FIRSTHDR(msg);
scmsg != NULL;
scmsg = CMSG_NXTHDR(msg, scmsg)) {
data = (sctp_cmsg_data_t *)CMSG_DATA(scmsg);
if (debug_level) print_cmsg(scmsg->cmsg_type, data);
}
fflush(stdout);
return 0;
} /* print_message() */
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;
char *ipaddr = strdup(parm);
char *ifname;
int ifindex = 0;
/* check the interface. */
ifname = strchr(ipaddr,'%');
if (ifname) {
*ifname=0;
ifname++;
ifindex = if_nametoindex(ifname);
if (!ifindex) {
fprintf(stderr, "bad interface name: %s\n", ifname);
goto finally;
}
}
/* Get the entries for this host. */
hst4 = gethostbyname(ipaddr);
hst6 = gethostbyname2(ipaddr, AF_INET6);
if ((NULL == hst4 || hst4->h_length < 1)
&& (NULL == hst6 || hst6->h_length < 1)) {
fprintf(stderr, "bad hostname: %s\n", ipaddr);
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);
if (!ifindex) {
b6ap->sin6_scope_id = ifindex;
}
aptr += sizeof(struct sockaddr_in6);
} /* for (loop through the new v6 addresses) */
}
finally:
free(ipaddr);
*ret_count = count;
return new_addrs;
} /* append_addr() */
int socket_r(void)
{
struct sctp_event_subscribe subscribe;
int sk, error;
DEBUG_PRINT(DEBUG_MIN, "\tsocket(%s, IPPROTO_SCTP)",
(socket_type == SOCK_SEQPACKET) ? "SOCK_SEQPACKET" : "SOCK_STREAM");
if ((sk = socket(s_loc.ss_family, socket_type, IPPROTO_SCTP)) < 0 ) {
if (do_exit) {
fprintf(stderr, "\n\n\t\t*** socket: failed to create"
" socket: %s ***\n",
strerror(errno));
exit(1);
} else {
return -1;
}
}
DEBUG_PRINT(DEBUG_MIN, " -> sk=%d\n", sk);
memset(&subscribe, 0, sizeof(subscribe));
subscribe.sctp_data_io_event = 1;
subscribe.sctp_association_event = 1;
error = setsockopt(sk, SOL_SCTP, SCTP_EVENTS, (char *)&subscribe,
sizeof(subscribe));
if (error) {
fprintf(stderr, "SCTP_EVENTS: error: %d\n", error);
exit(1);
}
if (max_stream > 0) {
struct sctp_initmsg initmsg;
memset(&initmsg, 0, sizeof(struct sctp_initmsg));
initmsg.sinit_num_ostreams = max_stream;
error = setsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &initmsg, sizeof(struct sctp_initmsg));
if (error) {
fprintf(stderr, "SCTP_INITMSG: error: %d\n", error);
exit(1);
}
}
return sk;
} /* socket_r() */
int bind_r(int sk, struct sockaddr_storage *saddr)
{
int error = 0, i = 0;
char *host_s, *serv_s;
if ((host_s = malloc(NI_MAXHOST)) == NULL) {
fprintf(stderr, "\n\t\t*** host_s malloc failed!!! ***\n");
exit(1);
}
if ((serv_s = malloc(NI_MAXSERV)) == NULL) {
fprintf(stderr, "\n\t\t*** serv_s malloc failed!!! ***\n");
exit(1);
}
do {
if (i > 0) sleep(1); /* sleep a while before new try... */
error = getnameinfo((struct sockaddr *)saddr, l_len, host_s,
NI_MAXHOST, serv_s, NI_MAXSERV,
NI_NUMERICHOST);
if (error)
printf("%s\n", gai_strerror(error));
DEBUG_PRINT(DEBUG_MIN,
"\tbind(sk=%d, [a:%s,p:%s]) -- attempt %d/%d\n",
sk, host_s, serv_s, i+1, MAX_BIND_RETRYS);
error = bind(sk, (struct sockaddr *)saddr, l_len);
if (error != 0) {
if( errno != EADDRINUSE ) {
if (do_exit) {
fprintf(stderr, "\n\n\t\t***bind: can "
"not bind to %s:%s: %s ****\n",
host_s, serv_s,
strerror(errno));
exit(1);
} else {
return -1;
}
}
}
i++;
if (i >= MAX_BIND_RETRYS) {
fprintf(stderr, "Maximum bind() attempts. "
"Die now...\n\n");
exit(1);
}
} while (error < 0 && i < MAX_BIND_RETRYS);
free(host_s);
free(serv_s);
return 0;
} /* bind_r() */
int
bindx_r(int sk, struct sockaddr *addrs, int count, int flag)
{
int error;
int i;
struct sockaddr *sa_addr;
void *aptr;
/* 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(local_port);
aptr += sizeof(struct sockaddr_in);
break;
case AF_INET6:
((struct sockaddr_in6 *)sa_addr)->sin6_port =
htons(local_port);
aptr += sizeof(struct sockaddr_in6);
break;
default:
fprintf(stderr, "Invalid address family\n");
exit(1);
}
}
error = sctp_bindx(sk, addrs, count, flag);
if (error != 0) {
fprintf(stderr, "\n\n\t\t***bindx_r: error adding addrs:"
" %s. ***\n", strerror(errno));
exit(1);
}
return 0;
} /* bindx_r() */
int listen_r(int sk, int listen_count)
{
int error = 0;
DEBUG_PRINT(DEBUG_MIN, "\tlisten(sk=%d,backlog=%d)\n",
sk, listen_count);
/* Mark sk as being able to accept new associations */
error = listen(sk, listen_count);
if (error != 0) {
if (do_exit) {
fprintf(stderr, "\n\n\t\t*** listen: %s ***\n\n\n",
strerror(errno));
exit(1);
}
else return -1;
}
return 0;
} /* listen_r() */
int accept_r(int sk){
socklen_t len = 0;
int subsk;
DEBUG_PRINT(DEBUG_MIN, "\taccept(sk=%d)\n", sk);
subsk = accept(sk, NULL, &len);
if (subsk < 0) {
fprintf(stderr, "\n\n\t\t*** accept: %s ***\n\n\n", strerror(errno));
exit(1);
}
return subsk;
} /* accept_r() */
int connect_r(int sk, const struct sockaddr *serv_addr, socklen_t addrlen)
{
int error = 0;
DEBUG_PRINT(DEBUG_MIN, "\tconnect(sk=%d)\n", sk);
/* Mark sk as being able to accept new associations */
error = connect(sk, serv_addr, addrlen);
if (error != 0) {
if (do_exit) {
fprintf(stderr, "\n\n\t\t*** connect: %s ***\n\n\n",
strerror(errno));
exit(1);
}
else return -1;
}
return 0;
} /* connect_r() */
int connectx_r(int sk, struct sockaddr *addrs, int count)
{
int error;
int i;
struct sockaddr *sa_addr;
void *aptr;
/* 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");
exit(1);
}
}
error = sctp_connectx(sk, addrs, count, NULL);
if (error != 0) {
fprintf(stderr, "\n\n\t\t*** connectx_r: error connecting"
" to addrs: %s ***\n", strerror(errno));
exit(1);
}
return 0;
} /* connectx_r() */
int receive_r(int sk, int once)
{
int recvsk = sk, i = 0, error = 0;
char incmsg[CMSG_SPACE(sizeof(_sctp_cmsg_data_t))];
struct iovec iov;
struct msghdr inmessage;
/* Initialize inmessage with enough space for DATA... */
memset(&inmessage, 0, sizeof(inmessage));
if ((iov.iov_base = malloc(REALLY_BIG)) == NULL) {
fprintf(stderr, "\n\t\t*** malloc not enough memory!!! ***\n");
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);
/* Get the messages sent */
while (1) {
if (recvsk == sk && socket_type == SOCK_STREAM &&
role == SERVER)
recvsk = accept_r(sk);
DEBUG_PRINT(DEBUG_MIN, "\trecvmsg(sk=%d) ", sk);
error = recvmsg(recvsk, &inmessage, MSG_WAITALL);
if (error < 0 && errno != EAGAIN) {
if (errno == ENOTCONN && socket_type == SOCK_STREAM &&
role == SERVER) {
printf("No association is present now!!\n");
close(recvsk);
recvsk = sk;
continue;
}
fprintf(stderr, "\n\t\t*** recvmsg: %s ***\n\n",
strerror(errno));
fflush(stdout);
if (do_exit) exit(1);
else goto error_out;
}
else if (error == 0) {
if (socket_type == SOCK_STREAM && role == SERVER) {
printf("No association is present now!!\n");
close(recvsk);
recvsk = sk;
continue;
}
printf("\n\t\trecvmsg() returned 0 !!!!\n");
fflush(stdout);
}
if (print_message(recvsk, &inmessage, error) > 0)
continue; /* got a notification... */
inmessage.msg_control = incmsg;
inmessage.msg_controllen = sizeof(incmsg);
iov.iov_len = REALLY_BIG;
i++;
if (once)
break;
}
if (recvsk != sk)
close(recvsk);
free(iov.iov_base);
return 0;
error_out:
close(sk);
free(iov.iov_base);
return -1;
} /* receive_r () */
int next_order(int state, int pattern)
{
switch (pattern){
case ORDER_PATTERN_UNORDERED:
state = 0;
break;
case ORDER_PATTERN_ORDERED:
state = 1;
break;
case ORDER_PATTERN_ALTERNATE:
state = state ? 0 : 1;
break;
case ORDER_PATTERN_RANDOM:
state = rand() % 2;
break;
}
return state;
}
int next_stream(int state, int pattern)
{
switch (pattern){
case STREAM_PATTERN_RANDOM:
state = rand() % (max_stream == 0 ? 1 : max_stream);
break;
case STREAM_PATTERN_SEQUENTIAL:
state = state + 1;
if (state >= max_stream)
state = 0;
break;
}
return state;
}
int next_msg_size(int msg_cnt)
{
int msg_size;
if (size_arg) {
msg_size = size_arg;
} else if (test_case < NCASES) {
msg_size = msg_sizes[test_case][msg_cnt];
} else {
msg_size = (rand() % max_msgsize) + 1;
}
return msg_size;
} /* next_msg_size() */
int next_assoc(int i, int state, int pattern)
{
int j;
int found = 0;
_assoc_state *as;
switch (pattern){
case ASSOC_PATTERN_RANDOM:
state = rand() % tosend;
break;
case ASSOC_PATTERN_SEQUENTIAL:
state = state + 1;
if (state >= tosend)
state = 0;
break;
}
as = poll_sks[i].assoc_state;
j = state;
do {
if (as[j].msg_sent < repeat_count) {
found = 1;
break;
}
if (++j >= tosend) {
j = 0;
}
} while (j != state);
if (found) {
return j;
} else {
return -1;
}
} /* next_assoc() */
int send_r(int sk, int stream, int order, int send_size, int assoc_i)
{
int error = 0;
struct msghdr outmsg;
struct iovec iov;
char *message = NULL;
int msglen = 0;
char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
struct cmsghdr *cmsg;
struct sctp_sndrcvinfo *sinfo;
if (send_size > 0) {
message = build_msg(send_size);
msglen = strlen(message) + 1;
iov.iov_base = message;
iov.iov_len = msglen;
}
else {
if (do_exit) {
exit(1);
} else {
goto error_out;
}
}
outmsg.msg_name = &s_rem;
outmsg.msg_namelen = sizeof(struct sockaddr_storage);
outmsg.msg_iov = &iov;
outmsg.msg_iovlen = 1;
outmsg.msg_control = outcmsg;
outmsg.msg_controllen = sizeof(outcmsg);
outmsg.msg_flags = 0;
cmsg = CMSG_FIRSTHDR(&outmsg);
cmsg->cmsg_level = IPPROTO_SCTP;
cmsg->cmsg_type = SCTP_SNDRCV;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
outmsg.msg_controllen = cmsg->cmsg_len;
sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
memset(sinfo, 0, sizeof(struct sctp_sndrcvinfo));
sinfo->sinfo_ppid = rand();
sinfo->sinfo_stream = stream;
sinfo->sinfo_flags = 0;
if (!order)
sinfo->sinfo_flags = SCTP_UNORDERED;
if (timetolive)
sinfo->sinfo_timetolive = timetolive;
DEBUG_PRINT(DEBUG_MIN, "\tsendmsg(sk=%d, assoc=%d) %4d bytes.\n",
sk, assoc_i, send_size);
DEBUG_PRINT(DEBUG_MAX, "\t SNDRCV");
if (DEBUG_MAX == debug_level) {
printf("(stream=%u ", sinfo->sinfo_stream);
printf("flags=0x%x ", sinfo->sinfo_flags);
printf("ppid=%u\n", sinfo->sinfo_ppid);
}
/* Send to our neighbor. */
error = sendmsg(sk, &outmsg, MSG_WAITALL);
if (error != msglen) {
fprintf(stderr, "\n\t\t*** sendmsg: %s ***\n\n",
strerror(errno));
fflush(stdout);
if (do_exit) {
exit(1);
} else {
if (!drain)
goto error_out;
}
}
if (send_size > 0) free(message);
return 0;
error_out:
if (send_size > 0) free(message);
return -1;
} /* send_r() */
int close_r(int sk)
{
int error = 0;
DEBUG_PRINT(DEBUG_MIN, "\tclose(sk=%d)\n",sk);
error = close(sk);
if (error != 0) {
if (do_exit) {
fprintf(stderr, "\n\n\t\t*** close: %s ***\n\n",
strerror(errno));
exit(1);
} else {
return -1;
}
}
fflush(stdout);
return 0;
} /* close_r() */
void
server(int sk)
{
if (max_msgsize > DEFAULT_MAX_WINDOW) {
if (setsockopt(sk, SOL_SOCKET, SO_RCVBUF, &max_msgsize,
sizeof(max_msgsize)) < 0) {
perror("setsockopt(SO_RCVBUF)");
exit(1);
}
}
receive_r(sk, 0);
} /* server() */
void
client(int sk)
{
int msg_size;
int i;
for (i = 0; i < msg_cnt; i++) {
msg_size = next_msg_size(i);
order_state = next_order(order_state, order_pattern);
stream_state = next_stream(stream_state, stream_pattern);
if (send_r(sk, stream_state, order_state, msg_size, 0) < 0)
break;
/* The sender is echoing so do discard the echoed data. */
if (drain) {
receive_r(sk, 1);
}
}
} /* client() */
void
mixed_mode_test(void)
{
int error, i, j, max_fd, sks, size;
int assoc_i, n_msg_size, n_order, n_stream;
int done = 0;
fd_set *ibitsp = NULL, *obitsp = NULL, *xbitsp = NULL;
char incmsg[CMSG_SPACE(sizeof(_sctp_cmsg_data_t))];
struct iovec iov;
struct msghdr inmessage;
_assoc_state *as;
/* Set up the listeners. If listeners is 0, set up one socket for
* transmitting only.
*/
iov.iov_base = NULL;
max_fd = -1;
sks = (0 == listeners) ? 1 : listeners;
memset(poll_sks, 0, sks * sizeof(_poll_sks));
for (i = 0; i < sks; i++) {
poll_sks[i].sk = socket_r();
if (s_loc.ss_family == AF_INET6)
( (struct sockaddr_in6 *)&s_loc)->sin6_port =
htons(local_port + i);
else
( (struct sockaddr_in *)&s_loc)->sin_port =
htons(local_port + i);
bind_r(poll_sks[i].sk, &s_loc);
if (listeners) {
listen_r(poll_sks[i].sk, 100);
}
if (max_msgsize > DEFAULT_MAX_WINDOW) {
if (setsockopt(poll_sks[i].sk, SOL_SOCKET, SO_RCVBUF,
&max_msgsize, sizeof(max_msgsize)) < 0) {
perror("setsockopt(SO_RCVBUF)");
exit(1);
}
}
if (tosend) {
if ((poll_sks[i].assoc_state = (_assoc_state *)malloc(
sizeof(_assoc_state) * tosend)) == NULL) {
printf("Can't allocate memory.\n");
goto clean_up;
}
memset(poll_sks[i].assoc_state, 0,
sizeof(_assoc_state) * tosend);
}
if (poll_sks[i].sk > max_fd) {
max_fd = poll_sks[i].sk;
}
}
size = howmany(max_fd + 1, NFDBITS) * sizeof(fd_mask);
if ((ibitsp = (fd_set *)malloc(size)) == NULL) {
printf("Can't allocate memory.\n");
goto clean_up;
}
if ((obitsp = (fd_set *)malloc(size)) == NULL) {
printf("Can't allocate memory.\n");
goto clean_up;
}
if ((xbitsp = (fd_set *)malloc(size)) == NULL) {
printf("Can't allocate memory.\n");
goto clean_up;
}
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) {
fprintf(stderr, "\n\t\t*** malloc not enough memory!!! ***\n");
goto clean_up;
}
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);
/* Set up the remote port number per association for output. */
for (i = 0; i < sks; i++) {
as = poll_sks[i].assoc_state;
for (j = 0; j < tosend; j++) {
as[j].rem_port = remote_port + j;
}
}
while (!done) {
for (i = 0; i < sks; i++) {
FD_SET(poll_sks[i].sk, ibitsp);
FD_SET(poll_sks[i].sk, obitsp);
FD_SET(poll_sks[i].sk, xbitsp);
}
if ((error = select(max_fd + 1, ibitsp, obitsp, xbitsp,
(struct timeval *)0)) < 0) {
fprintf(stderr, "\n\t\t*** select() failed ");
fprintf(stderr, "with error: %s\n\n",
strerror(errno));
fflush(stdout);
goto clean_up;
}
for (i = 0; i < sks; i++) {
/* Is there anything to read from the socket? */
if (listeners && FD_ISSET(poll_sks[i].sk, ibitsp)) {
FD_CLR(poll_sks[i].sk, ibitsp);
error = recvmsg(poll_sks[i].sk, &inmessage,
MSG_WAITALL);
if (error < 0) {
fprintf(stderr,
"\n\t\t*** recvmsg: %s ***\n\n",
strerror(errno));
fflush(stdout);
goto clean_up;
}
else if (error == 0) {
printf("\n\t\trecvmsg() returned ");
printf("0 !!!!\n");
fflush(stdout);
}
print_message(poll_sks[i].sk, &inmessage,
error);
inmessage.msg_control = incmsg;
inmessage.msg_controllen = sizeof(incmsg);
iov.iov_len = REALLY_BIG;
}
/* Is this socket writeable? */
if (tosend && FD_ISSET(poll_sks[i].sk, obitsp)) {
FD_CLR(poll_sks[i].sk, obitsp);
/* Pick an association. */
assoc_i = next_assoc(i, poll_sks[i].assoc_i,
assoc_pattern);
if (assoc_i < 0) {
/* No work to do on any associations.
* We are probably done. */
if (!listeners) {
done = 1;
}
continue;
}
poll_sks[i].assoc_i = assoc_i;
as = poll_sks[i].assoc_state;
n_msg_size = next_msg_size(as[assoc_i].msg_cnt);
n_order = as[assoc_i].order_state =
next_order(as[assoc_i].order_state,
order_pattern);
n_stream = as[assoc_i].stream_state =
next_stream(as[assoc_i].stream_state,
stream_pattern);
/* Set the destination port. */
if (s_rem.ss_family == AF_INET6)
( (struct sockaddr_in6 *)&s_rem)->
sin6_port =
htons(as[assoc_i].rem_port);
else
( (struct sockaddr_in *)&s_rem)->
sin_port =
htons(as[assoc_i].rem_port);
/* Send a message thru the association. */
if (send_r(poll_sks[i].sk, n_stream, n_order,
n_msg_size, assoc_i) < 0) {
/* Don't increment counter if there
* is a problem of sending.
*/
continue;
}
/* Increment counters. */
if (++as[assoc_i].msg_cnt >= MSG_CNT) {
as[assoc_i].msg_cnt = 0;
}
if (++as[assoc_i].msg_sent >=
repeat_count) {
fprintf(stderr, "Association #%d in ",
assoc_i);
fprintf(stderr, "sk=%d has ",
poll_sks[i].sk);
fprintf(stderr, "completed %d msg as ",
as[assoc_i].msg_sent);
fprintf(stderr, "cycle %d.\n",
++as[assoc_i].cycle);
/* In the mixed mode, -x not only
* specify the longer repeat cycle,
* but it also mean to run the test
* forever.
*/
if (xflag) {
as[assoc_i].msg_sent = 0;
}
}
}
}
}
clean_up:
for (i = 0; i < sks; i++) {
close(poll_sks[i].sk);
if (poll_sks[i].assoc_state) {
free(poll_sks[i].assoc_state);
}
}
if (ibitsp) free(ibitsp);
if (obitsp) free(obitsp);
if (xbitsp) free(xbitsp);
if (iov.iov_base) free(iov.iov_base);
} /* mixed_mode_test() */
void start_test(int role)
{
int sk;
int i = 0;
DEBUG_PRINT(DEBUG_NONE, "\nStarting tests...\n");
repeat_count = repeat;
if (MIXED == role) {
repeat_count = repeat_count * msg_cnt; /* Repeat per assoc. */
mixed_mode_test();
return;
}
sk = socket_r();
if (sk < 0) {
DEBUG_PRINT(DEBUG_NONE, "\nSocket create err %d\n", errno);
return;
}
if (bind_r(sk, &s_loc) == -1) {
DEBUG_PRINT(DEBUG_NONE, "\nSocket bind err %d\n", errno);
return;
}
/* Do we need to do bindx() to add any additional addresses? */
if (bindx_add_addrs)
bindx_r(sk, bindx_add_addrs, bindx_add_count,
SCTP_BINDX_ADD_ADDR);
if (role == SERVER) {
listen_r(sk, 100);
} else {
if (socket_type == SOCK_STREAM && connectx_count == 0)
connect_r(sk, (struct sockaddr *)&s_rem, r_len);
if (connectx_count != 0)
connectx_r(sk, connectx_addrs, connectx_count);
}
if (!debug_level) {
printf(" ");
}
for(i = 0; i < repeat_count; i++) {
if (role == SERVER) {
DEBUG_PRINT(DEBUG_NONE,
"Server: Receiving packets.\n");
server(sk);
} else {
DEBUG_PRINT(DEBUG_NONE,
"Client: Sending packets.(%d/%d)\n",
i+1, repeat_count);
client(sk);
}
fflush(stdout);
}
close_r(sk);
} /* start_test() */
int
main(int argc, char *argv[])
{
int c;
char *interface = NULL;
struct sockaddr_in *t_addr;
struct sockaddr_in6 *t_addr6;
struct sockaddr *tmp_addrs = NULL;
/* Parse the arguments. */
while ((c = getopt(argc, argv, ":H:L:P:S:a:h:p:c:d:lm:sx:X:o:t:M:r:w:Di:TB:C:O:")) >= 0 ) {
switch (c) {
case 'H':
local_host = optarg;
break;
case 'L':
role = MIXED;
listeners = atoi(optarg);
if (listeners > MAX_POLL_SKS) {
usage(argv[0]);
exit(1);
}
break;
case 'P':
local_port = atoi(optarg);
break;
case 'S':
role = MIXED;
tosend = atoi(optarg);
if (tosend > MAX_POLL_SKS) {
usage(argv[0]);
exit(1);
}
break;
case 'a':
assoc_pattern = atoi(optarg);
if (assoc_pattern < ASSOC_PATTERN_SEQUENTIAL
|| assoc_pattern > ASSOC_PATTERN_RANDOM ) {
usage(argv[0]);
exit(1);
}
break;
case 'h':
remote_host = optarg;
break;
case 'D':
drain = 1;
do_exit = 0;
break;
case 'p':
remote_port = atoi(optarg);
break;
case 's':
if (role != NOT_DEFINED) {
printf("%s: only -s or -l\n", argv[0]);
usage(argv[0]);
exit(1);
}
role = CLIENT;
break;
case 'l':
if (role != NOT_DEFINED) {
printf("%s: only -s or -l\n", argv[0]);
usage(argv[0]);
exit(1);
}
role = SERVER;
break;
case 'd':
debug_level = atoi(optarg);
if (debug_level < DEBUG_NONE
|| debug_level > DEBUG_MAX) {
usage(argv[0]);
exit(1);
}
break;
case 'x':
repeat = atoi(optarg);
if (!repeat) {
xflag = 1;
repeat = BIG_REPEAT;
}
break;
case 'X':
msg_cnt = atoi(optarg);
if ((msg_cnt <= 0) || (msg_cnt > MSG_CNT)) {
usage(argv[0]);
exit(1);
}
break;
case 'c':
test_case = atoi(optarg);
if (test_case > NCASES) {
usage(argv[0]);
exit(1);
}
if (test_case < 0) {
size_arg = -test_case;
}
break;
case 'o':
order_pattern = atoi(optarg);
if (order_pattern < ORDER_PATTERN_UNORDERED
|| order_pattern > ORDER_PATTERN_RANDOM ) {
usage(argv[0]);
exit(1);
}
break;
case 'O':
timetolive = atoi(optarg);
if (timetolive < 0) {
usage(argv[0]);
exit(1);
}
break;
case 't':
stream_pattern = atoi(optarg);
if (stream_pattern < STREAM_PATTERN_SEQUENTIAL
|| stream_pattern > STREAM_PATTERN_RANDOM ) {
usage(argv[0]);
exit(1);
}
break;
case 'M':
max_stream = atoi(optarg);
if (max_stream < 0
|| max_stream >= (1<<16)) {
usage(argv[0]);
exit(1);
}
break;
case 'r':
seed = atoi(optarg);
break;
case 'm':
max_msgsize = atoi(optarg);
#if 0
if ((max_msgsize < DEFAULT_MIN_WINDOW) ||
(max_msgsize > 65515)) {
usage(argv[0]);
exit(1);
}
#endif
break;
case 'i':
interface = optarg;
if_index = if_nametoindex(interface);
if (!if_index) {
printf("Interface %s unknown\n", interface);
exit(1);
}
break;
case 'T':
socket_type = SOCK_STREAM;
break;
case 'B':
tmp_addrs = append_addr(optarg, bindx_add_addrs,
&bindx_add_count);
if (NULL == tmp_addrs) {
fprintf(stderr, "No memory to add ");
fprintf(stderr, "%s\n", optarg);
exit(1);
}
bindx_add_addrs = tmp_addrs;
break;
case 'C':
tmp_addrs = append_addr(optarg, connectx_addrs,
&connectx_count);
if (NULL == tmp_addrs) {
fprintf(stderr, "No memory to add ");
fprintf(stderr, "%s\n", optarg);
exit(1);
}
connectx_addrs = tmp_addrs;
break;
case '?':
default:
usage(argv[0]);
exit(0);
}
} /* while() */
if (NOT_DEFINED == role) {
usage(argv[0]);
exit(1);
}
if (SERVER == role && NULL == local_host && remote_host != NULL) {
fprintf (stderr, "%s: Server needs local address, "
"not remote address\n", argv[0]);
usage(argv[0]);
exit(1);
}
if (CLIENT == role && NULL == remote_host && connectx_count == 0) {
fprintf (stderr, "%s: Client needs at least remote address "
"& port\n", argv[0]);
usage(argv[0]);
exit(1);
}
if (MIXED == role) {
if (listeners && NULL == local_host) {
fprintf (stderr, "%s: Servers need local address\n",
argv[0]);
usage(argv[0]);
exit(1);
}
if (tosend && NULL == remote_host) {
fprintf (stderr, "%s: Clients need remote address ",
argv[0]);
fprintf (stderr, "& port\n");
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 (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);
}
if (remote_host != NULL && remote_port != 0) {
struct addrinfo *res;
int error;
char *host_s, *serv_s;
if ((host_s = malloc(NI_MAXHOST)) == NULL) {
fprintf(stderr, "\n*** host_s malloc failed!!! ***\n");
exit(1);
}
if ((serv_s = malloc(NI_MAXSERV)) == NULL) {
fprintf(stderr, "\n*** serv_s malloc failed!!! ***\n");
exit(1);
}
error = getaddrinfo(remote_host, 0, NULL, &res);
if (error) {
printf("%s.\n", gai_strerror(error));
usage(argv[0]);
exit(1);
}
switch (res->ai_family) {
case AF_INET:
t_addr = (struct sockaddr_in *)&s_rem;
memcpy(t_addr, res->ai_addr,
res->ai_addrlen);
t_addr->sin_family = res->ai_family;
t_addr->sin_port = htons(remote_port);
r_len = res->ai_addrlen;
#ifdef __FreeBSD__
t_addr->sin_len = r_len;
#endif
break;
case AF_INET6:
t_addr6 = (struct sockaddr_in6 *)&s_rem;
memcpy(t_addr6, res->ai_addr,
res->ai_addrlen);
t_addr6->sin6_family = res->ai_family;
t_addr6->sin6_port = htons(remote_port);
if (interface)
t_addr6->sin6_scope_id =
if_nametoindex(interface);
r_len = res->ai_addrlen;
#ifdef __FreeBSD__
t_addr6->sin6_len = r_len;
#endif
break;
}
getnameinfo((struct sockaddr *)&s_rem, r_len, host_s,
NI_MAXHOST, serv_s, NI_MAXSERV, NI_NUMERICHOST);
DEBUG_PRINT(DEBUG_MAX, "remote:addr=%s, port=%s, family=%d\n",
host_s, serv_s, res->ai_family);
freeaddrinfo(res);
}
if (connectx_count != 0) {
switch (connectx_addrs->sa_family) {
case AF_INET:
t_addr = (struct sockaddr_in *)&s_rem;
r_len = sizeof(struct sockaddr_in);
memcpy(t_addr, connectx_addrs, r_len);
t_addr->sin_port = htons(remote_port);
break;
case AF_INET6:
t_addr6 = (struct sockaddr_in6 *)&s_rem;
r_len = sizeof(struct sockaddr_in6);
memcpy(t_addr6, connectx_addrs, r_len);
t_addr6->sin6_port = htons(remote_port);
break;
}
}
if (local_host != NULL) {
struct addrinfo *res;
int error;
char *host_s, *serv_s;
struct sockaddr_in *t_addr;
struct sockaddr_in6 *t_addr6;
if ((host_s = malloc(NI_MAXHOST)) == NULL) {
fprintf(stderr, "\n*** host_s malloc failed!!! ***\n");
exit(1);
}
if ((serv_s = malloc(NI_MAXSERV)) == NULL) {
fprintf(stderr, "\n*** serv_s malloc failed!!! ***\n");
exit(1);
}
if (strcmp(local_host, "0") == 0)
local_host = "0.0.0.0";
error = getaddrinfo(local_host, 0, NULL, &res);
if (error) {
printf("%s.\n", gai_strerror(error));
usage(argv[0]);
exit(1);
}
switch (res->ai_family) {
case AF_INET:
t_addr = (struct sockaddr_in *)&s_loc;
memcpy(t_addr, res->ai_addr,
res->ai_addrlen);
t_addr->sin_family = res->ai_family;
t_addr->sin_port = htons(local_port);
l_len = res->ai_addrlen;
#ifdef __FreeBSD__
t_addr->sin_len = l_len;
#endif
break;
case AF_INET6:
t_addr6 = (struct sockaddr_in6 *)&s_loc;
memcpy(t_addr6, res->ai_addr,
res->ai_addrlen);
t_addr6->sin6_family = res->ai_family;
t_addr6->sin6_port = htons(local_port);
if (interface)
t_addr6->sin6_scope_id =
if_nametoindex(interface);
l_len = res->ai_addrlen;
#ifdef __FreeBSD__
t_addr6->sin6_len = l_len;
#endif
break;
}
error = getnameinfo((struct sockaddr *)&s_loc, l_len, host_s,
NI_MAXHOST, serv_s, NI_MAXSERV, NI_NUMERICHOST);
if (error)
printf("%s..\n", gai_strerror(error));
DEBUG_PRINT(DEBUG_MAX, "local:addr=%s, port=%s, family=%d\n",
host_s, serv_s, res->ai_family);
freeaddrinfo(res);
}
/* A half-hearted attempt to seed rand() */
if (seed == 0 ) {
seed = time(0);
DEBUG_PRINT(DEBUG_NONE, "seed = %d\n", seed);
}
srand(seed);
/* Let the testing begin. */
start_test(role);
return 0;
} /* main() */