d/iperf3-tls
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Updated reporter callback, interval report, and the tcp info report to print out its message rather than allocating memory.

Browse Source
This commit is contained in:
sethdelliott 2010-06-16 20:32:01 +00:00
parent ccb086576f
commit 3e402adeb7
4 changed files with 199 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/iperf.h
View File

@ -1,5 +1,3 @@
/* /*
Copyright (c) 2009, The Regents of the University of California, through Copyright (c) 2009, The Regents of the University of California, through
Lawrence Berkeley National Laboratory (subject to receipt of any required Lawrence Berkeley National Laboratory (subject to receipt of any required

165
src/iperf_api.c
View File

@ -410,6 +410,8 @@ iperf_connect(struct iperf_test *test)
struct iperf_stream *sp; struct iperf_stream *sp;
int i, s = 0; int i, s = 0;
printf("Connecting to host %s, port %d\n", test->server_hostname, test->server_port);
/* For Select: Set the test->write_set select set to zero, then set the s fd */ /* For Select: Set the test->write_set select set to zero, then set the s fd */
FD_ZERO(&test->write_set); FD_ZERO(&test->write_set);
@ -473,35 +475,34 @@ iperf_stats_callback(struct iperf_test * test)
//printf("in stats_callback: num_streams = %d role = %c\n", test->num_streams, test->role); //printf("in stats_callback: num_streams = %d role = %c\n", test->num_streams, test->role);
while (sp != NULL) while (sp != NULL) {
{ rp = sp->result;
rp = sp->result;
if (test->role == 'c') if (test->role == 'c')
temp.bytes_transferred = rp->bytes_sent_this_interval; temp.bytes_transferred = rp->bytes_sent_this_interval;
else else
temp.bytes_transferred = rp->bytes_received_this_interval; temp.bytes_transferred = rp->bytes_received_this_interval;
ip = sp->result->interval_results; ip = sp->result->interval_results;
/* result->end_time contains timestamp of previous interval */ /* result->end_time contains timestamp of previous interval */
if ( ip != NULL ) /* not the 1st interval */ if ( ip != NULL ) /* not the 1st interval */
memcpy(&temp.interval_start_time, &sp->result->end_time, sizeof(struct timeval)); memcpy(&temp.interval_start_time, &sp->result->end_time, sizeof(struct timeval));
else /* or use timestamp from beginning */ else /* or use timestamp from beginning */
memcpy(&temp.interval_start_time, &sp->result->start_time, sizeof(struct timeval)); memcpy(&temp.interval_start_time, &sp->result->start_time, sizeof(struct timeval));
/* now save time of end of this interval */ /* now save time of end of this interval */
gettimeofday(&sp->result->end_time, NULL); gettimeofday(&sp->result->end_time, NULL);
memcpy(&temp.interval_end_time, &sp->result->end_time, sizeof(struct timeval)); memcpy(&temp.interval_end_time, &sp->result->end_time, sizeof(struct timeval));
temp.interval_duration = timeval_diff(&temp.interval_start_time, &temp.interval_end_time); temp.interval_duration = timeval_diff(&temp.interval_start_time, &temp.interval_end_time);
//temp.interval_duration = timeval_diff(&temp.interval_start_time, &temp.interval_end_time); //temp.interval_duration = timeval_diff(&temp.interval_start_time, &temp.interval_end_time);
if (test->tcp_info) if (test->tcp_info)
get_tcpinfo(test, &temp); get_tcpinfo(test, &temp);
//printf(" iperf_stats_callback: adding to interval list: \n"); //printf(" iperf_stats_callback: adding to interval list: \n");
add_to_interval_list(rp, &temp); add_to_interval_list(rp, &temp);
rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0; rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0;
/* for debugging */ /* for debugging */
//display_interval_list(rp, test->tcp_info); //display_interval_list(rp, test->tcp_info);
sp = sp->next; sp = sp->next;
} /* for each stream */ } /* for each stream */
return 0; return 0;
@ -519,9 +520,7 @@ iperf_stats_callback(struct iperf_test * test)
void void
iperf_reporter_callback(struct iperf_test * test) iperf_reporter_callback(struct iperf_test * test)
{ {
int total_packets = 0, lost_packets = 0, curr_state = 0; int total_packets = 0, lost_packets = 0, iperf_state;
char *message = NULL;
char *message_final = NULL;
char ubuf[UNIT_LEN]; char ubuf[UNIT_LEN];
char nbuf[UNIT_LEN]; char nbuf[UNIT_LEN];
struct iperf_stream *sp = NULL; struct iperf_stream *sp = NULL;
@ -529,53 +528,47 @@ iperf_reporter_callback(struct iperf_test * test)
double start_time, end_time; double start_time, end_time;
struct iperf_interval_results *ip = NULL; struct iperf_interval_results *ip = NULL;
message = (char *)calloc(MAX_RESULT_STRING, sizeof(char));
message_final = (char *)calloc(MAX_RESULT_STRING, sizeof(char));
sp = test->streams; sp = test->streams;
curr_state = sp->settings->state; iperf_state = sp->settings->state;
switch (curr_state) {
switch (iperf_state) {
case TEST_RUNNING: case TEST_RUNNING:
case STREAM_RUNNING: case STREAM_RUNNING:
/* print interval results for each stream */ /* print interval results for each stream */
while (sp) { for (sp = test->streams; sp != NULL; sp = sp->next) {
message_final = print_interval_results(test, sp, message_final); print_interval_results(test, sp);
bytes += sp->result->interval_results->bytes_transferred; /* sum up all streams */ bytes += sp->result->interval_results->bytes_transferred; /* sum up all streams */
sp = sp->next;
} }
if (bytes <=0 ) { /* this can happen if timer goes off just when client exits */ if (bytes <=0 ) { /* this can happen if timer goes off just when client exits */
fprintf(stderr, "error: bytes <= 0!\n"); fprintf(stderr, "error: bytes <= 0!\n");
break; break;
} }
/* next build string with sum of all streams */ /* next build string with sum of all streams */
sp = test->streams; /* reset back to 1st stream */
if (test->num_streams > 1) { if (test->num_streams > 1) {
sp = test->streams; /* reset back to 1st stream */
ip = test->streams->result->last_interval_results; /* use 1st stream for timing info */ ip = test->streams->result->last_interval_results; /* use 1st stream for timing info */
unit_snprintf(ubuf, UNIT_LEN, (double) (bytes), 'A'); unit_snprintf(ubuf, UNIT_LEN, (double) (bytes), 'A');
unit_snprintf(nbuf, UNIT_LEN, (double) (bytes / ip->interval_duration),
test->default_settings->unit_format);
start_time = timeval_diff(&sp->result->start_time,&ip->interval_start_time); start_time = timeval_diff(&sp->result->start_time,&ip->interval_start_time);
end_time = timeval_diff(&sp->result->start_time,&ip->interval_end_time); end_time = timeval_diff(&sp->result->start_time,&ip->interval_end_time);
unit_snprintf(nbuf, UNIT_LEN, (double) (bytes / ip->interval_duration), printf(report_sum_bw_format, start_time, end_time, ubuf, nbuf);
test->default_settings->unit_format);
sprintf(message, report_sum_bw_format, start_time, end_time, ubuf, nbuf);
safe_strcat(message_final, message);
#ifdef NOT_DONE /* is it usful to figure out a way so sum * TCP_info acrross multiple streams? */ #if defined(linux) || defined(__FreeBSD__) /* is it usful to figure out a way so sum * TCP_info acrross multiple streams? */
if (test->tcp_info) { if (test->tcp_info)
build_tcpinfo_message(ip, message); print_tcpinfo(ip);
safe_strcat(message_final, message);
}
#endif #endif
} }
break; break;
case ALL_STREAMS_END: case ALL_STREAMS_END:
case RESULT_REQUEST: case RESULT_REQUEST:
/* print final summary for all intervals */ /* print final summary for all intervals */
sp = test->streams;
start_time = 0.; start_time = 0.;
end_time = timeval_diff(&sp->result->start_time, &sp->result->end_time); end_time = timeval_diff(&sp->result->start_time, &sp->result->end_time);
while (sp) { for (sp = test->streams; sp != NULL; sp = sp->next) {
if (test->role == 'c') if (test->role == 'c')
bytes = sp->result->bytes_sent; bytes = sp->result->bytes_sent;
else else
@ -588,101 +581,79 @@ iperf_reporter_callback(struct iperf_test * test)
if (bytes > 0 ) { if (bytes > 0 ) {
unit_snprintf(ubuf, UNIT_LEN, (double) (bytes), 'A'); unit_snprintf(ubuf, UNIT_LEN, (double) (bytes), 'A');
unit_snprintf(nbuf, UNIT_LEN, (double) (bytes / end_time), test->default_settings->unit_format); unit_snprintf(nbuf, UNIT_LEN, (double) (bytes / end_time), test->default_settings->unit_format);
if (test->protocol == Ptcp) { // TCP mode if (test->protocol == Ptcp) {
sprintf(message, report_bw_format, sp->socket, start_time, end_time, ubuf, nbuf); printf(report_bw_format, sp->socket, start_time, end_time, ubuf, nbuf);
safe_strcat(message_final, message);
#if defined(linux) || defined(__FreeBSD__) #if defined(linux) || defined(__FreeBSD__)
if (test->tcp_info) { if (test->tcp_info) {
ip = sp->result->last_interval_results; ip = sp->result->last_interval_results;
build_tcpinfo_message(ip, message); print_tcpinfo(ip);
safe_strcat(message_final, message);
} }
#endif #endif
} else { // UDP mode } else {
sprintf(message, report_bw_jitter_loss_format, sp->socket, start_time, printf(report_bw_jitter_loss_format, sp->socket, start_time,
end_time, ubuf, nbuf, sp->jitter * 1000, sp->cnt_error, end_time, ubuf, nbuf, sp->jitter * 1000, sp->cnt_error,
sp->packet_count, (double) (100.0 * sp->cnt_error / sp->packet_count)); sp->packet_count, (double) (100.0 * sp->cnt_error / sp->packet_count));
safe_strcat(message_final, message);
if (test->role == 'c') { if (test->role == 'c') {
sprintf(message, report_datagrams, sp->socket, sp->packet_count); printf(report_datagrams, sp->socket, sp->packet_count);
safe_strcat(message_final, message);
} }
if (sp->outoforder_packets > 0) if (sp->outoforder_packets > 0)
printf(report_sum_outoforder, start_time, end_time, sp->cnt_error); printf(report_sum_outoforder, start_time, end_time, sp->cnt_error);
} }
} }
sp = sp->next;
} }
unit_snprintf(ubuf, UNIT_LEN, (double) total_bytes, 'A'); unit_snprintf(ubuf, UNIT_LEN, (double) total_bytes, 'A');
unit_snprintf(nbuf, UNIT_LEN, (double) total_bytes / end_time, test->default_settings->unit_format); unit_snprintf(nbuf, UNIT_LEN, (double) total_bytes / end_time, test->default_settings->unit_format);
if (test->num_streams > 1) { if (test->num_streams > 1) {
if (test->protocol == Ptcp) { if (test->protocol == Ptcp) {
sprintf(message, report_sum_bw_format, start_time, end_time, ubuf, nbuf); printf(report_sum_bw_format, start_time, end_time, ubuf, nbuf);
safe_strcat(message_final, message);
} else { } else {
sprintf(message, report_sum_bw_jitter_loss_format, start_time, end_time, ubuf, nbuf, sp->jitter, printf(report_sum_bw_jitter_loss_format, start_time, end_time, ubuf, nbuf, sp->jitter,
lost_packets, total_packets, (double) (100.0 * lost_packets / total_packets)); lost_packets, total_packets, (double) (100.0 * lost_packets / total_packets));
safe_strcat(message_final, message);
} }
if ((test->print_mss != 0) && (test->role == 'c')) { if ((test->print_mss != 0) && (test->role == 'c')) {
sprintf(message, "\nThe TCP maximum segment size mss = %d \n", getsock_tcp_mss(sp->socket)); printf("The TCP maximum segment size mss = %d\n", getsock_tcp_mss(sp->socket));
safe_strcat(message_final, message);
} }
} }
break; break;
} // end switch }
free(message);
printf("%s\n", message_final);
free(message_final);
} }
/**************************************************************************/ /**************************************************************************/
char * void
print_interval_results(struct iperf_test * test, struct iperf_stream * sp, char *message_final) print_interval_results(struct iperf_test * test, struct iperf_stream * sp)
{ {
static int first_stream = 1; char ubuf[UNIT_LEN];
char ubuf[UNIT_LEN]; char nbuf[UNIT_LEN];
char nbuf[UNIT_LEN]; double st = 0., et = 0.;
double st = 0., et = 0.;
struct iperf_interval_results *ir = NULL; struct iperf_interval_results *ir = NULL;
char *message = (char *) malloc(MAX_RESULT_STRING);
//printf("in print_interval_results for stream %d \n", sp->socket);
ir = sp->result->last_interval_results; /* get last entry in linked list */ ir = sp->result->last_interval_results; /* get last entry in linked list */
if (ir == NULL) if (ir == NULL) {
{ printf("print_interval_results Error: interval_results = NULL \n");
printf("print_interval_results Error: interval_results = NULL \n"); return;
return NULL;
} }
if (first_stream) /* only print header for 1st stream */ if (sp == test->streams) {
{ printf(report_bw_header);
sprintf(message, report_bw_header);
safe_strcat(message_final, message);
first_stream = 0;
} }
unit_snprintf(ubuf, UNIT_LEN, (double) (ir->bytes_transferred), 'A');
unit_snprintf(nbuf, UNIT_LEN, unit_snprintf(ubuf, UNIT_LEN, (double) (ir->bytes_transferred), 'A');
(double) (ir->bytes_transferred / ir->interval_duration), test->default_settings->unit_format); unit_snprintf(nbuf, UNIT_LEN, (double) (ir->bytes_transferred / ir->interval_duration),
test->default_settings->unit_format);
st = timeval_diff(&sp->result->start_time,&ir->interval_start_time); st = timeval_diff(&sp->result->start_time,&ir->interval_start_time);
et = timeval_diff(&sp->result->start_time,&ir->interval_end_time); et = timeval_diff(&sp->result->start_time,&ir->interval_end_time);
sprintf(message, report_bw_format, sp->socket, st, et, ubuf, nbuf);
//printf("print_interval_results 1: message = %s \n", message); printf(report_bw_format, sp->socket, st, et, ubuf, nbuf);
safe_strcat(message_final, message);
#if defined(linux) || defined(__FreeBSD__) #if defined(linux) || defined(__FreeBSD__)
if (test->tcp_info) if (test->tcp_info)
{ print_tcpinfo(ir);
build_tcpinfo_message(ir, message);
safe_strcat(message_final, message);
}
#endif #endif
//printf("reporter_callback: built interval string: %s \n", message_final);
free(message);
return message_final;
} }
/**************************************************************************/ /**************************************************************************/

2
src/iperf_api.h
View File

@ -139,7 +139,7 @@ void get_tcpinfo(struct iperf_test *test, struct iperf_interval_results *rp);
void print_tcpinfo(struct iperf_interval_results *); void print_tcpinfo(struct iperf_interval_results *);
void build_tcpinfo_message(struct iperf_interval_results *r, char *message); void build_tcpinfo_message(struct iperf_interval_results *r, char *message);
void safe_strcat(char *s1, char *s2); void safe_strcat(char *s1, char *s2);
char * print_interval_results(struct iperf_test * test, struct iperf_stream *sp, char *m); void print_interval_results(struct iperf_test * test, struct iperf_stream *sp);
int iperf_connect(struct iperf_test *); int iperf_connect(struct iperf_test *);
int iperf_client_start(struct iperf_test *); int iperf_client_start(struct iperf_test *);
int iperf_client_end(struct iperf_test *); int iperf_client_end(struct iperf_test *);

277
src/main.c
View File

@ -29,7 +29,7 @@
#include "locale.h" #include "locale.h"
int iperf_run(struct iperf_test * test); int iperf_run(struct iperf_test *);
/**************************************************************************/ /**************************************************************************/
@ -72,15 +72,9 @@ static struct option longopts[] =
int int
main(int argc, char **argv) main(int argc, char **argv)
{ {
char ch, role;
char ch, role;
struct iperf_test *test; struct iperf_test *test;
int port = PORT; int port = PORT;
// The following lines need to be removed and moved to somewhere else!!!
const char *usage_long1 = "this is usage_long1";
const char *usage_long2 = "this is usage_long2";
#ifdef TEST_PROC_AFFINITY #ifdef TEST_PROC_AFFINITY
/* didnt seem to work.... */ /* didnt seem to work.... */
@ -88,167 +82,155 @@ main(int argc, char **argv)
* increasing the priority of the process to minimise packet generation * increasing the priority of the process to minimise packet generation
* delay * delay
*/ */
int rc = setpriority(PRIO_PROCESS, 0, -15); int rc = setpriority(PRIO_PROCESS, 0, -15);
if (rc < 0) if (rc < 0) {
{ perror("setpriority:");
perror("setpriority:"); printf("setting priority to valid level\n");
printf("setting priority to valid level\n"); rc = setpriority(PRIO_PROCESS, 0, 0);
rc = setpriority(PRIO_PROCESS, 0, 0);
} }
/* setting the affinity of the process */ /* setting the affinity of the process */
cpu_set_t cpu_set; cpu_set_t cpu_set;
int affinity = -1; int affinity = -1;
int ncores = 1; int ncores = 1;
sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set); sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set);
if (errno) if (errno)
perror("couldn't get affinity:"); perror("couldn't get affinity:");
if ((ncores = sysconf(_SC_NPROCESSORS_CONF)) <= 0) if ((ncores = sysconf(_SC_NPROCESSORS_CONF)) <= 0)
err("sysconf: couldn't get _SC_NPROCESSORS_CONF"); err("sysconf: couldn't get _SC_NPROCESSORS_CONF");
CPU_ZERO(&cpu_set); CPU_ZERO(&cpu_set);
CPU_SET(affinity, &cpu_set); CPU_SET(affinity, &cpu_set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0) if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0)
err("couldn't change CPU affinity"); err("couldn't change CPU affinity");
#endif #endif
test = iperf_new_test(); test = iperf_new_test();
iperf_defaults(test); /* sets defaults */ iperf_defaults(test); /* sets defaults */
while ((ch = getopt_long(argc, argv, "c:p:st:uP:b:l:w:i:n:mNTvhVdM:f:", longopts, NULL)) != -1) while ((ch = getopt_long(argc, argv, "c:p:st:uP:b:l:w:i:n:mNTvhVdM:f:", longopts, NULL)) != -1) {
{ switch (ch) {
switch (ch) case 'c':
{ test->role = 'c';
case 'c': role = test->role;
test->role = 'c'; test->server_hostname = (char *) malloc(strlen(optarg)+1);
role = test->role; strncpy(test->server_hostname, optarg, strlen(optarg));
test->server_hostname = (char *) malloc(strlen(optarg)+1); break;
strncpy(test->server_hostname, optarg, strlen(optarg)); case 'p':
break; test->server_port = atoi(optarg);
case 'p': port = test->server_port;
test->server_port = atoi(optarg); break;
port = test->server_port; case 's':
break; test->role = 's';
case 's': role = test->role;
test->role = 's'; break;
role = test->role; case 't':
break; test->duration = atoi(optarg);
case 't': if (test->duration > MAX_TIME) {
test->duration = atoi(optarg); fprintf(stderr, "\n Error: test duration too long. Maximum value = %d \n\n", (int)MAX_TIME);
if (test->duration > MAX_TIME) fprintf(stderr, usage_long1);
{ fprintf(stderr, usage_long2);
fprintf(stderr, "\n Error: test duration too long. Maximum value = %d \n\n", (int)MAX_TIME); exit(1);
fprintf(stderr, usage_long1); }
fprintf(stderr, usage_long2); break;
exit(1); case 'u':
} test->protocol = Pudp;
break; test->default_settings->blksize = DEFAULT_UDP_BLKSIZE;
case 'u': test->new_stream = iperf_new_udp_stream;
test->protocol = Pudp; break;
test->default_settings->blksize = DEFAULT_UDP_BLKSIZE; case 'P':
test->new_stream = iperf_new_udp_stream; test->num_streams = atoi(optarg);
break; if (test->num_streams > MAX_STREAMS) {
case 'P': fprintf(stderr, "\n Error: Number of parallel streams too large. Maximum value = %d \n\n", MAX_STREAMS);
test->num_streams = atoi(optarg); fprintf(stderr, usage_long1);
if (test->num_streams > MAX_STREAMS) fprintf(stderr, usage_long2);
{ exit(1);
fprintf(stderr, "\n Error: Number of parallel streams too large. Maximum value = %d \n\n", MAX_STREAMS); }
fprintf(stderr, usage_long1); break;
fprintf(stderr, usage_long2); case 'b':
exit(1); test->default_settings->rate = unit_atof(optarg);
} break;
break; case 'l':
case 'b': test->default_settings->blksize = unit_atoi(optarg);
test->default_settings->rate = unit_atof(optarg); if (test->default_settings->blksize > MAX_BLOCKSIZE) {
break; fprintf(stderr, "\n Error: Block size too large. Maximum value = %d \n\n", MAX_BLOCKSIZE);
case 'l': fprintf(stderr, usage_long1);
test->default_settings->blksize = unit_atoi(optarg); fprintf(stderr, usage_long2);
if (test->default_settings->blksize > MAX_BLOCKSIZE) exit(1);
{ }
fprintf(stderr, "\n Error: Block size too large. Maximum value = %d \n\n", MAX_BLOCKSIZE); break;
fprintf(stderr, usage_long1); case 'w':
fprintf(stderr, usage_long2); test->default_settings->socket_bufsize = unit_atof(optarg);
exit(1); if (test->default_settings->socket_bufsize > MAX_TCP_BUFFER) {
} fprintf(stderr, "\n Error: TCP buffer too large. Maximum value = %d \n\n", MAX_TCP_BUFFER);
break; fprintf(stderr, usage_long1);
case 'w': fprintf(stderr, usage_long2);
test->default_settings->socket_bufsize = unit_atof(optarg); exit(1);
if (test->default_settings->socket_bufsize > MAX_TCP_BUFFER) }
{ break;
fprintf(stderr, "\n Error: TCP buffer too large. Maximum value = %d \n\n", MAX_TCP_BUFFER); case 'i':
fprintf(stderr, usage_long1); /* could potentially want separate stat collection and reporting intervals,
fprintf(stderr, usage_long2); but just set them to be the same for now */
exit(1); test->stats_interval = atoi(optarg);
} test->reporter_interval = atoi(optarg);
break; if (test->stats_interval > MAX_INTERVAL) {
case 'i': fprintf(stderr, "\n Error: Report interval too large. Maximum value = %d \n\n", MAX_INTERVAL);
/* could potentially want separate stat collection and reporting intervals, fprintf(stderr, usage_long1);
but just set them to be the same for now */ fprintf(stderr, usage_long2);
test->stats_interval = atoi(optarg); exit(1);
test->reporter_interval = atoi(optarg); }
if (test->stats_interval > MAX_INTERVAL) break;
{ case 'n':
fprintf(stderr, "\n Error: Report interval too large. Maximum value = %d \n\n", MAX_INTERVAL); test->default_settings->bytes = unit_atoi(optarg);
fprintf(stderr, usage_long1); printf("total bytes to be transferred = %llu\n", test->default_settings->bytes);
fprintf(stderr, usage_long2); break;
exit(1); case 'm':
} test->print_mss = 1;
break; break;
case 'n': case 'N':
test->default_settings->bytes = unit_atoi(optarg); test->no_delay = 1;
printf("total bytes to be transferred = %llu\n", test->default_settings->bytes); break;
break; case 'M':
case 'm': test->default_settings->mss = atoi(optarg);
test->print_mss = 1; if (test->default_settings->mss > MAX_MSS) {
break; fprintf(stderr, "\n Error: MSS too large. Maximum value = %d \n\n", MAX_MSS);
case 'N': fprintf(stderr, usage_long1);
test->no_delay = 1; fprintf(stderr, usage_long2);
break; exit(1);
case 'M': }
test->default_settings->mss = atoi(optarg); break;
if (test->default_settings->mss > MAX_MSS) case 'f':
{ test->default_settings->unit_format = *optarg;
fprintf(stderr, "\n Error: MSS too large. Maximum value = %d \n\n", MAX_MSS); break;
fprintf(stderr, usage_long1); case 'T':
fprintf(stderr, usage_long2); test->tcp_info = 1;
exit(1); break;
} case 'V':
break; test->verbose = 1;
case 'f': break;
test->default_settings->unit_format = *optarg; case 'd':
break; test->debug = 1;
case 'T': break;
test->tcp_info = 1; case 'v': // print version and exit
break; fprintf( stderr, version );
case 'V': exit(1);
test->verbose = 1; case 'h':
break; default:
case 'd': fprintf(stderr, usage_long1);
test->debug = 1; fprintf(stderr, usage_long2);
break; exit(1);
case 'v': // print version and exit }
fprintf( stderr, version );
exit(1);
case 'h':
default:
fprintf(stderr, usage_long1);
fprintf(stderr, usage_long2);
exit(1);
}
} }
/* exit until this is done.... */ /* exit until this is done.... */
if (test->protocol == Pudp) { if (test->protocol == Pudp) {
printf("UDP mode not yet supported. Exiting. \n"); printf("UDP mode not yet supported. Exiting. \n");
exit(0); exit(0);
} }
//printf("in main: calling iperf_init_test \n");
if (test->role == 'c')
printf("Connecting to port %d on host %s \n", test->server_port, test->server_hostname);
iperf_init_test(test); iperf_init_test(test);
//printf("in main: calling iperf_run \n"); //printf("in main: calling iperf_run \n");
@ -256,7 +238,8 @@ main(int argc, char **argv)
iperf_free_test(test); iperf_free_test(test);
printf("\niperf Done.\n"); printf("\niperf Done.\n");
exit(0);
return 0;
} }
/**************************************************************************/ /**************************************************************************/