/*
* Copyright (c) 2009, The Regents of the University of California, through
* Lawrence Berkeley National Laboratory (subject to receipt of any required
* approvals from the U.S. Dept. of Energy). All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "getopt.h"
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
/*#include <pthread.h>*/
#include "stdint.h"
#include <netinet/tcp.h>
#include <sys/time.h>
#include <sys/resource.h>
/*#include <sched.h>*/
#include <signal.h>
#include <setjmp.h>
#include "iperf.h"
#include "iperf_api.h"
#include "iperf_udp.h"
#include "iperf_tcp.h"
#include "timer.h"
#include "net.h"
#include "units.h"
#include "tcp_window_size.h"
#include "uuid.h"
#include "locale.h"
jmp_buf env; /* to handle longjmp on signal */
#ifndef socklen_t
typedef int socklen_t;
#endif
/*************************************************************/
/*
* check to see if client has sent the requested number of bytes to the
* server yet
*/
/*
* XXX: should probably just compute this as we go and store it in the
* iperf_test structure -blt
*/
int
all_data_sent(struct iperf_test * test)
{
if (test->default_settings->bytes == 0)
return 0;
else
{
uint64_t total_bytes = 0;
struct iperf_stream *sp;
sp = test->streams;
while (sp)
{
total_bytes += sp->result->bytes_sent;
sp = sp->next;
}
if (total_bytes >= (test->num_streams * test->default_settings->bytes))
{
return 1;
} else
return 0;
}
}
/*********************************************************/
/**
* exchange_parameters - handles the param_Exchange part for client
*
*/
void
exchange_parameters(struct iperf_test * test)
{
int result;
struct iperf_stream *sp;
struct param_exchange *param;
//printf("in exchange_parameters \n");
sp = test->streams;
sp->settings->state = PARAM_EXCHANGE;
param = (struct param_exchange *) sp->buffer;
get_uuid(test->default_settings->cookie);
strncpy(param->cookie, test->default_settings->cookie, COOKIE_SIZE);
//printf("client cookie: %s \n", param->cookie);
/* setting up exchange parameters */
param->state = PARAM_EXCHANGE;
param->blksize = test->default_settings->blksize;
param->recv_window = test->default_settings->socket_bufsize;
param->send_window = test->default_settings->socket_bufsize;
param->format = test->default_settings->unit_format;
//printf(" sending exchange params: size = %d \n", (int) sizeof(struct param_exchange));
result = sp->snd(sp);
if (result < 0)
perror("Error sending exchange params to server");
result = Nread(sp->socket, sp->buffer, sizeof(struct param_exchange), Ptcp);
if (result < 0)
perror("Error getting exchange params ack from server");
if (result > 0 && sp->buffer[0] == ACCESS_DENIED)
{
fprintf(stderr, "Busy server Detected. Try again later. Exiting.\n");
exit(-1);
}
return;
}
/*************************************************************/
/**
* add_to_interval_list -- adds new interval to the interval_list
*
*/
void
add_to_interval_list(struct iperf_stream_result * rp, struct iperf_interval_results * new)
{
struct iperf_interval_results *ip = NULL;
ip = (struct iperf_interval_results *) malloc(sizeof(struct iperf_interval_results));
memcpy(ip, new, sizeof(struct iperf_interval_results));
ip->next = NULL;
if (rp->interval_results == NULL) /* if 1st interval */
{
rp->interval_results = ip;
rp->last_interval_results = ip; /* pointer to last element in list */
} else
{
/* add to end of list */
rp->last_interval_results->next = ip;
rp->last_interval_results = ip;
}
}
/*************************************************************/
/* for debugging only */
void
display_interval_list(struct iperf_stream_result * rp, int tflag)
{
struct iperf_interval_results *n;
float gb = 0.;
n = rp->interval_results;
printf("----------------------------------------\n");
while (n!=NULL)
{
gb = (float)n->bytes_transferred / (1024. * 1024. * 1024.);
printf("Interval = %f\tGBytes transferred = %.3f\n", n->interval_duration, gb);
if (tflag)
print_tcpinfo(n);
n = n->next;
}
}
/************************************************************/
/**
* receive_result_from_server - Receives result from server
*/
void
receive_result_from_server(struct iperf_test * test)
{
int result;
struct iperf_stream *sp;
int size = 0;
char *buf = NULL;
printf("in receive_result_from_server \n");
sp = test->streams;
size = MAX_RESULT_STRING;
buf = (char *) malloc(size);
printf("receive_result_from_server: send ALL_STREAMS_END to server \n");
sp->settings->state = ALL_STREAMS_END;
sp->snd(sp); /* send message to server */
printf("receive_result_from_server: send RESULT_REQUEST to server \n");
sp->settings->state = RESULT_REQUEST;
sp->snd(sp); /* send message to server */
/* receive from server */
printf("reading results (size=%d) back from server \n", size);
do
{
result = recv(sp->socket, buf, size, 0);
} while (result == -1 && errno == EINTR);
printf("Got size of results from server: %d \n", result);
printf(server_reporting, sp->socket);
puts(buf); /* prints results */
free(buf);
}
/*************************************************************/
/**
* connect_msg -- displays connection message
* denoting sender/receiver details
*
*/
void
connect_msg(struct iperf_stream * sp)
{
char ipl[512], ipr[512];
#if 0
inet_ntop(AF_INET, (void *) (&((struct sockaddr_in *) & sp->local_addr)->sin_addr), (void *) ipl, sizeof(ipl));
inet_ntop(AF_INET, (void *) (&((struct sockaddr_in *) & sp->remote_addr)->sin_addr), (void *) ipr, sizeof(ipr));
printf("[%3d] local %s port %d connected to %s port %d\n",
sp->socket,
ipl, ntohs(((struct sockaddr_in *) & sp->local_addr)->sin_port),
ipr, ntohs(((struct sockaddr_in *) & sp->remote_addr)->sin_port));
#else
char *ip;
ip = inet_ntoa(sp->local_addr.sin_addr);
memcpy(ipl, ip, sizeof(ipl));
ip = inet_ntoa(sp->remote_addr.sin_addr);
memcpy(ipr, ip, sizeof(ipr));
/* XXX: sin_ports are not network byte order!? */
printf("[%3d] local %s port %d connected to %s port %d\n",
sp->socket,
ipl, ((struct sockaddr_in *) & sp->local_addr)->sin_port,
ipr, ((struct sockaddr_in *) & sp->remote_addr)->sin_port);
#endif
}
/*************************************************************/
/**
* Display -- Displays results for test
* Mainly for DEBUG purpose
*
*/
void
Display(struct iperf_test * test)
{
struct iperf_stream *n;
n = test->streams;
int count = 1;
printf("===============DISPLAY==================\n");
while (n != NULL)
{
if (test->role == 'c')
printf("position-%d\tsp=%d\tsocket=%d\tMbytes sent=%u\n", count++, (int) n, n->socket, (unsigned int) (n->result->bytes_sent / (float)MB));
else
printf("position-%d\tsp=%d\tsocket=%d\tMbytes received=%u\n", count++, (int) n, n->socket, (unsigned int) (n->result->bytes_received / (float)MB));
n = n->next;
}
printf("=================END====================\n");
fflush(stdout);
}
/**************************************************************************/
struct iperf_test *
iperf_new_test()
{
struct iperf_test *testp;
//printf("in iperf_new_test: reinit default settings \n");
testp = (struct iperf_test *) malloc(sizeof(struct iperf_test));
if (!testp)
{
perror("malloc");
return (NULL);
}
/* initialise everything to zero */
memset(testp, 0, sizeof(struct iperf_test));
testp->default_settings = (struct iperf_settings *) malloc(sizeof(struct iperf_settings));
memset(testp->default_settings, 0, sizeof(struct iperf_settings));
/* return an empty iperf_test* with memory alloted. */
return testp;
}
/**************************************************************************/
void
iperf_defaults(struct iperf_test * testp)
{
testp->protocol = Ptcp;
testp->role = 's';
testp->duration = DURATION;
testp->server_port = PORT;
testp->new_stream = iperf_new_tcp_stream;
testp->stats_callback = iperf_stats_callback;
testp->reporter_callback = iperf_reporter_callback;
testp->stats_interval = 0;
testp->reporter_interval = 0;
testp->num_streams = 1;
testp->default_settings->unit_format = 'a';
testp->default_settings->socket_bufsize = 0; /* use autotuning */
testp->default_settings->blksize = DEFAULT_TCP_BLKSIZE;
testp->default_settings->rate = RATE; /* UDP only */
testp->default_settings->state = TEST_START;
testp->default_settings->mss = 0;
testp->default_settings->bytes = 0;
memset(testp->default_settings->cookie, '\0', COOKIE_SIZE);
}
/**************************************************************************/
void
iperf_init_test(struct iperf_test * test)
{
char ubuf[UNIT_LEN];
struct iperf_stream *sp;
int i, s = 0;
//printf("in iperf_init_test \n");
if (test->role == 's')
{ /* server */
if (test->protocol == Pudp)
{
test->listener_sock_udp = netannounce(Pudp, NULL, test->server_port);
if (test->listener_sock_udp < 0)
exit(0);
}
/* always create TCP connection for control messages */
test->listener_sock_tcp = netannounce(Ptcp, NULL, test->server_port);
if (test->listener_sock_tcp < 0)
exit(0);
if (test->protocol == Ptcp)
{
if (set_tcp_windowsize(test->listener_sock_tcp, test->default_settings->socket_bufsize, SO_RCVBUF) < 0)
perror("unable to set TCP window");
}
/* make sure that accept call does not block */
setnonblocking(test->listener_sock_tcp);
setnonblocking(test->listener_sock_udp);
printf("-----------------------------------------------------------\n");
printf("Server listening on %d\n", test->server_port);
int x;
/* make sure we got what we asked for */
if ((x = get_tcp_windowsize(test->listener_sock_tcp, SO_RCVBUF)) < 0)
perror("SO_RCVBUF");
if (test->protocol == Ptcp)
{
{
if (test->default_settings->socket_bufsize > 0)
{
unit_snprintf(ubuf, UNIT_LEN, (double) x, 'A');
printf("TCP window size: %s\n", ubuf);
} else
{
printf("Using TCP Autotuning \n");
}
}
}
printf("-----------------------------------------------------------\n");
} else if (test->role == 'c')
{ /* Client */
FD_ZERO(&test->write_set);
FD_SET(s, &test->write_set);
/*
* XXX: I think we need to create a TCP control socket here too for
* UDP mode -blt
*/
for (i = 0; i < test->num_streams; i++)
{
s = netdial(test->protocol, test->server_hostname, test->server_port);
if (s < 0)
{
fprintf(stderr, "netdial failed\n");
exit(0);
}
FD_SET(s, &test->write_set);
test->max_fd = (test->max_fd < s) ? s : test->max_fd;
sp = test->new_stream(test);
sp->socket = s;
iperf_init_stream(sp, test);
iperf_add_stream(test, sp);
connect_msg(sp); /* print connection established message */
}
}
}
/**************************************************************************/
void
iperf_free_test(struct iperf_test * test)
{
free(test->default_settings);
close(test->listener_sock_tcp);
close(test->listener_sock_udp);
test->streams = NULL;
test->accept = NULL;
test->stats_callback = NULL;
test->reporter_callback = NULL;
test->new_stream = NULL;
free(test);
}
/**************************************************************************/
/**
* iperf_stats_callback -- handles the statistic gathering for both the client and server
*
*returns void *
*
*/
void *
iperf_stats_callback(struct iperf_test * test)
{
struct iperf_stream *sp = test->streams;
struct iperf_stream_result *rp = NULL;
struct iperf_interval_results *ip = NULL, temp;
//printf("in stats_callback: num_streams = %d role = %c\n", test->num_streams, test->role);
while (sp != NULL)
{
rp = sp->result;
if (test->role == 'c')
temp.bytes_transferred = rp->bytes_sent_this_interval;
else
temp.bytes_transferred = rp->bytes_received_this_interval;
ip = sp->result->interval_results;
/* result->end_time contains timestamp of previous interval */
if ( ip != NULL ) /* not the 1st interval */
memcpy(&temp.interval_start_time, &sp->result->end_time, sizeof(struct timeval));
else /* or use timestamp from beginning */
memcpy(&temp.interval_start_time, &sp->result->start_time, sizeof(struct timeval));
/* now save time of end of this interval */
gettimeofday(&sp->result->end_time, NULL);
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);
if (test->tcp_info)
get_tcpinfo(test, &temp);
//printf(" iperf_stats_callback: adding to interval list: \n");
add_to_interval_list(rp, &temp);
rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0;
/* for debugging */
//display_interval_list(rp, test->tcp_info);
sp = sp->next;
} /* for each stream */
return 0;
}
/**************************************************************************/
/**
* iperf_reporter_callback -- handles the report printing
*
*returns report
*
*/
char *
iperf_reporter_callback(struct iperf_test * test)
{
int total_packets = 0, lost_packets = 0, curr_state = 0;
char *message = NULL;
char *message_final = NULL;
char ubuf[UNIT_LEN];
char nbuf[UNIT_LEN];
struct iperf_stream *sp = NULL;
iperf_size_t bytes = 0, total_bytes = 0;
double start_time, end_time;
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;
curr_state = sp->settings->state;
//printf("in iperf_reporter_callback: state = %d \n", curr_state);
if (curr_state == TEST_RUNNING || curr_state == STREAM_RUNNING)
{
/* print interval results for each stream */
while (sp)
{
message_final = print_interval_results(test, sp, message_final);
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 */
return NULL;
/* next build string with sum of all streams */
sp = test->streams; /* reset back to 1st stream */
if (test->num_streams > 1)
{
ip = test->streams->result->last_interval_results; /* use 1st stream for timing info */
unit_snprintf(ubuf, UNIT_LEN, (double) (bytes), 'A');
start_time = timeval_diff(&sp->result->start_time,&ip->interval_start_time);
end_time = timeval_diff(&sp->result->start_time,&ip->interval_end_time);
unit_snprintf(nbuf, UNIT_LEN, (double) (bytes / ip->interval_duration),
test->default_settings->unit_format);
sprintf(message, report_sum_bw_format, start_time, end_time, ubuf, nbuf);
//printf("iperf_reporter_callback 1: start_time: %.3f end_time: %.3f \n", start_time, end_time);
//printf("iperf_reporter_callback 1: message = %s \n", message);
safe_strcat(message_final, message);
#ifdef NOT_DONE /* is it usful to figure out a way so sum
* TCP_info acrross multiple streams? */
if (test->tcp_info)
{
build_tcpinfo_message(ip, message);
safe_strcat(message_final, message);
}
#endif
}
} else
{
/* print final summary for all intervals */
if (curr_state == ALL_STREAMS_END || curr_state == RESULT_REQUEST)
{
sp = test->streams;
start_time = 0.;
end_time = timeval_diff(&sp->result->start_time, &sp->result->end_time);
while (sp)
{
if (test->role == 'c')
bytes = sp->result->bytes_sent;
else
bytes = sp->result->bytes_received;
total_bytes += bytes;
if (test->protocol == Pudp)
{
total_packets += sp->packet_count;
lost_packets += sp->cnt_error;
}
if (bytes > 0 )
{
unit_snprintf(ubuf, UNIT_LEN, (double) (bytes), 'A');
unit_snprintf(nbuf, UNIT_LEN, (double) (bytes / end_time), test->default_settings->unit_format);
if (test->protocol == Ptcp)
{
sprintf(message, report_bw_format, sp->socket, start_time, end_time, ubuf, nbuf);
//printf("iperf_reporter_callback 2: message = %s \n", message);
safe_strcat(message_final, message);
#if defined(linux) || defined(__FreeBSD__)
if (test->tcp_info)
{
//printf("Final TCP_INFO results: \n");
ip = sp->result->last_interval_results;
build_tcpinfo_message(ip, message);
safe_strcat(message_final, message);
}
#endif
} else
{ /* UDP mode */
sprintf(message, report_bw_jitter_loss_format, sp->socket, start_time,
end_time, ubuf, nbuf, sp->jitter * 1000, sp->cnt_error,
sp->packet_count, (double) (100.0 * sp->cnt_error / sp->packet_count));
safe_strcat(message_final, message);
if (test->role == 'c')
{
sprintf(message, report_datagrams, sp->socket, sp->packet_count);
safe_strcat(message_final, message);
}
if (sp->outoforder_packets > 0)
printf(report_sum_outoforder, start_time, end_time, sp->cnt_error);
}
}
sp = sp->next;
}
} /* while (sp) */
unit_snprintf(ubuf, UNIT_LEN, (double) total_bytes, 'A');
unit_snprintf(nbuf, UNIT_LEN, (double) total_bytes / end_time, test->default_settings->unit_format);
if ((test->role == 'c' || (test->role == 's')) && test->num_streams > 1)
{
if (test->protocol == Ptcp)
{
sprintf(message, report_sum_bw_format, start_time, end_time, ubuf, nbuf);
safe_strcat(message_final, message);
} else
{
sprintf(message, 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));
safe_strcat(message_final, message);
}
if ((test->print_mss != 0) && (test->role == 'c'))
{
sprintf(message, "\nThe TCP maximum segment size mss = %d \n", getsock_tcp_mss(sp->socket));
safe_strcat(message_final, message);
}
}
}
free(message);
return message_final;
}
/**************************************************************************/
char *
print_interval_results(struct iperf_test * test, struct iperf_stream * sp, char *message_final)
{
static int first_stream = 1;
char ubuf[UNIT_LEN];
char nbuf[UNIT_LEN];
double st = 0., et = 0.;
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 */
if (ir == NULL)
{
printf("print_interval_results Error: interval_results = NULL \n");
return NULL;
}
if (first_stream) /* only print header for 1st stream */
{
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,
(double) (ir->bytes_transferred / ir->interval_duration), test->default_settings->unit_format);
st = timeval_diff(&sp->result->start_time,&ir->interval_start_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);
safe_strcat(message_final, message);
#if defined(linux) || defined(__FreeBSD__)
if (test->tcp_info)
{
build_tcpinfo_message(ir, message);
safe_strcat(message_final, message);
}
#endif
//printf("reporter_callback: built interval string: %s \n", message_final);
free(message);
return message_final;
}
/**************************************************************************/
void
safe_strcat(char *s1, char *s2)
{
//printf(" adding string %s to end of string %s \n", s1, s1);
if (strlen(s1) + strlen(s2) < MAX_RESULT_STRING)
strcat(s1, s2);
else
{
printf("Error: results string too long \n");
exit(-1); /* XXX: should return an error instead! */
/* but code that calls this needs to check for error first */
//return -1;
}
}
/**************************************************************************/
void
iperf_free_stream(struct iperf_stream * sp)
{
/* XXX: need to free interval list too! */
free(sp->buffer);
free(sp->settings);
free(sp->result);
free(sp->send_timer);
free(sp);
}
/**************************************************************************/
struct iperf_stream *
iperf_new_stream(struct iperf_test * testp)
{
int i = 0;
struct iperf_stream *sp;
//printf("in iperf_new_stream \n");
sp = (struct iperf_stream *) malloc(sizeof(struct iperf_stream));
if (!sp)
{
perror("malloc");
return (NULL);
}
memset(sp, 0, sizeof(struct iperf_stream));
//printf("iperf_new_stream: Allocating new stream buffer: size = %d \n", testp->default_settings->blksize);
sp->buffer = (char *) malloc(testp->default_settings->blksize);
sp->settings = (struct iperf_settings *) malloc(sizeof(struct iperf_settings));
/* make a per stream copy of default_settings in each stream structure */
memcpy(sp->settings, testp->default_settings, sizeof(struct iperf_settings));
sp->result = (struct iperf_stream_result *) malloc(sizeof(struct iperf_stream_result));
/* fill in buffer with random stuff */
srand(time(0));
for (i = 0; i < testp->default_settings->blksize; i++)
sp->buffer[i] = rand();
sp->socket = -1;
sp->packet_count = 0;
sp->stream_id = (int) sp;
sp->jitter = 0.0;
sp->prev_transit = 0.0;
sp->outoforder_packets = 0;
sp->cnt_error = 0;
sp->send_timer = NULL;
sp->next = NULL;
sp->result->interval_results = NULL;
sp->result->last_interval_results = NULL;
sp->result->bytes_received = 0;
sp->result->bytes_sent = 0;
sp->result->bytes_received_this_interval = 0;
sp->result->bytes_sent_this_interval = 0;
gettimeofday(&sp->result->start_time, NULL);
sp->settings->state = STREAM_BEGIN;
return sp;
}
/**************************************************************************/
void
iperf_init_stream(struct iperf_stream * sp, struct iperf_test * testp)
{
socklen_t len;
len = sizeof(struct sockaddr_in);
if (getsockname(sp->socket, (struct sockaddr *) & sp->local_addr, &len) < 0)
{
perror("getsockname");
}
if (getpeername(sp->socket, (struct sockaddr *) & sp->remote_addr, &len) < 0)
{
perror("getpeername");
}
//printf("in init_stream: calling set_tcp_windowsize: %d \n", testp->default_settings->socket_bufsize);
if (testp->protocol == Ptcp)
{
if (set_tcp_windowsize(sp->socket, testp->default_settings->socket_bufsize,
testp->role == 's' ? SO_RCVBUF : SO_SNDBUF) < 0)
fprintf(stderr, "unable to set window size\n");
/* set TCP_NODELAY and TCP_MAXSEG if requested */
set_tcp_options(sp->socket, testp->no_delay, testp->default_settings->mss);
}
}
/**************************************************************************/
int
iperf_add_stream(struct iperf_test * test, struct iperf_stream * sp)
{
struct iperf_stream *n;
if (!test->streams)
{
test->streams = sp;
return 1;
} else
{
n = test->streams;
while (n->next)
n = n->next;
n->next = sp;
return 1;
}
return 0;
}
/**************************************************************************/
void
catcher(int sig)
{
longjmp(env, sig);
}
/**************************************************************************/
void
iperf_run_client(struct iperf_test * test)
{
int i, result = 0;
struct iperf_stream *sp, *np;
struct timer *timer, *stats_interval, *reporter_interval;
char *result_string = NULL;
char *prot = NULL;
int64_t delayus, adjustus, dtargus;
struct timeval tv;
struct sigaction sact;
//printf("in iperf_run_client \n");
tv.tv_sec = 15; /* timeout interval in seconds */
tv.tv_usec = 0;
sigemptyset(&sact.sa_mask);
sact.sa_flags = 0;
sact.sa_handler = catcher;
sigaction(SIGINT, &sact, NULL);
if (test->protocol == Pudp)
{
dtargus = (int64_t) (test->default_settings->blksize) * SEC_TO_US * 8;
dtargus /= test->default_settings->rate;
assert(dtargus != 0);
delayus = dtargus;
adjustus = 0;
printf("iperf_run_client: adjustus: %lld, delayus: %lld \n", adjustus, delayus);
sp = test->streams;
for (i = 0; i < test->num_streams; i++)
{
sp->send_timer = new_timer(0, dtargus);
sp = sp->next;
}
}
/* if -n specified, set zero timer */
if (test->default_settings->bytes == 0)
timer = new_timer(test->duration, 0);
else
timer = new_timer(0, 0);
if (test->stats_interval != 0)
stats_interval = new_timer(test->stats_interval, 0);
if (test->reporter_interval != 0)
reporter_interval = new_timer(test->reporter_interval, 0);
if (test->protocol == Pudp)
prot = "UDP";
else
prot = "TCP";
if (test->default_settings->bytes == 0)
printf("Starting Test: protocol: %s, %d streams, %d byte blocks, %d second test \n",
prot, test->num_streams, test->default_settings->blksize, test->duration);
else
printf("Starting Test: protocol: %s, %d streams, %d byte blocks, %d bytes to send\n",
prot, test->num_streams, test->default_settings->blksize, (int) test->default_settings->bytes);
/* send data till the timer expires or bytes sent */
while (!all_data_sent(test) && !timer->expired(timer))
{
sp = test->streams;
for (i = 0; i < test->num_streams; i++)
{
//printf("sending data to stream %d \n", i);
result += sp->snd(sp);
if (sp->next == NULL)
break;
sp = sp->next;
}
if ((test->stats_interval != 0) && stats_interval->expired(stats_interval))
{
test->stats_callback(test);
update_timer(stats_interval, test->stats_interval, 0);
}
if ((test->reporter_interval != 0) && reporter_interval->expired(reporter_interval))
{
result_string = test->reporter_callback(test);
//printf("interval expired: printing results: \n");
puts(result_string);
update_timer(reporter_interval, test->reporter_interval, 0);
free(result_string);
}
/* detecting Ctrl+C */
if (setjmp(env))
break;
} /* while outer timer */
/* show last interval if necessary */
// I think this is un-necesary, but maybe needed with -n option?
//test->stats_callback(test); /* dont need this I think .. */
//result_string = test->reporter_callback(test);
//puts(result_string);
printf("Test Complete. Summary Results:\n");
/* send STREAM_END packets */
np = test->streams;
do
{ /* send STREAM_END to all sockets */
sp = np;
sp->settings->state = STREAM_END;
//printf("sending state = STREAM_END to stream %d \n", sp->socket);
result = sp->snd(sp);
if (result < 0)
break;
np = sp->next;
} while (np);
//printf("Done Sending STREAM_END. \n");
/* send ALL_STREAMS_END packet to 1st socket */
sp = test->streams;
sp->settings->state = ALL_STREAMS_END;
sp->snd(sp);
//printf("Done Sending ALL_STREAMS_END. \n");
/* show final summary */
/* XXX: check to make sure this is needed */
test->stats_callback(test);
result_string = test->reporter_callback(test);
puts(result_string);
free(result_string);
/* Requesting for result from Server */
test->default_settings->state = RESULT_REQUEST;
//receive_result_from_server(test); /* XXX: currently broken! */
//result_string = test->reporter_callback(test);
//printf("Summary results as measured by the server: \n");
//puts(result_string);
//printf("Done getting/printing results. \n");
//printf("send TEST_END to server \n");
sp->settings->state = TEST_END;
sp->snd(sp); /* send message to server */
/* Deleting all streams - CAN CHANGE FREE_STREAM FN */
sp = test->streams;
np = sp;
do
{
sp = np;
close(sp->socket);
np = sp->next;
iperf_free_stream(sp);
} while (np);
if (test->stats_interval != 0)
free_timer(stats_interval);
if (test->reporter_interval != 0)
free_timer(reporter_interval);
free_timer(timer);
}
|
