/*
* iperf, Copyright (c) 2014-2022, 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.
*
* If you have questions about your rights to use or distribute this
* software, please contact Berkeley Lab's Technology Transfer
* Department at TTD@lbl.gov.
*
* NOTICE. This software is owned by the U.S. Department of Energy.
* As such, the U.S. Government has been granted for itself and others
* acting on its behalf a paid-up, nonexclusive, irrevocable,
* worldwide license in the Software to reproduce, prepare derivative
* works, and perform publicly and display publicly. Beginning five
* (5) years after the date permission to assert copyright is obtained
* from the U.S. Department of Energy, and subject to any subsequent
* five (5) year renewals, the U.S. Government is granted for itself
* and others acting on its behalf a paid-up, nonexclusive,
* irrevocable, worldwide license in the Software to reproduce,
* prepare derivative works, distribute copies to the public, perform
* publicly and display publicly, and to permit others to do so.
*
* This code is distributed under a BSD style license, see the LICENSE file
* for complete information.
*/
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#define __USE_GNU
#include "iperf_config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.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>
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sched.h>
#include <setjmp.h>
#include <stdarg.h>
#include <math.h>
#if defined(HAVE_CPUSET_SETAFFINITY)
#include <sys/param.h>
#include <sys/cpuset.h>
#endif /* HAVE_CPUSET_SETAFFINITY */
#if defined(__CYGWIN__) || defined(_WIN32) || defined(_WIN64) || defined(__WINDOWS__)
#define CPU_SETSIZE __CPU_SETSIZE
#endif /* __CYGWIN__, _WIN32, _WIN64, __WINDOWS__ */
#if defined(HAVE_SETPROCESSAFFINITYMASK)
#include <Windows.h>
#endif /* HAVE_SETPROCESSAFFINITYMASK */
#include "net.h"
#include "iperf.h"
#include "iperf_api.h"
#include "iperf_udp.h"
#include "iperf_tcp.h"
#if defined(HAVE_SCTP_H)
#include "iperf_sctp.h"
#endif /* HAVE_SCTP_H */
#include "timer.h"
#include "cjson.h"
#include "units.h"
#include "iperf_util.h"
#include "iperf_locale.h"
#include "version.h"
#if defined(HAVE_SSL)
#include <openssl/bio.h>
#include <openssl/err.h>
#include "iperf_auth.h"
#endif /* HAVE_SSL */
/* Forwards. */
static int send_parameters(struct iperf_test *test);
static int get_parameters(struct iperf_test *test);
static int send_results(struct iperf_test *test);
static int get_results(struct iperf_test *test);
static int diskfile_send(struct iperf_stream *sp);
static int diskfile_recv(struct iperf_stream *sp);
static int JSON_write(int fd, cJSON *json);
static void print_interval_results(struct iperf_test *test, struct iperf_stream *sp, cJSON *json_interval_streams);
static cJSON *JSON_read(int fd);
/*************************** Print usage functions ****************************/
void
usage()
{
fputs(usage_shortstr, stderr);
}
void
usage_long(FILE *f)
{
fprintf(f, usage_longstr, DEFAULT_NO_MSG_RCVD_TIMEOUT, UDP_RATE / (1024*1024), DEFAULT_PACING_TIMER, DURATION, DEFAULT_TCP_BLKSIZE / 1024, DEFAULT_UDP_BLKSIZE);
}
void warning(const char *str)
{
fprintf(stderr, "warning: %s\n", str);
}
/************** Getter routines for some fields inside iperf_test *************/
int
iperf_get_verbose(struct iperf_test *ipt)
{
return ipt->verbose;
}
int
iperf_get_control_socket(struct iperf_test *ipt)
{
return ipt->ctrl_sck;
}
int
iperf_get_control_socket_mss(struct iperf_test *ipt)
{
return ipt->ctrl_sck_mss;
}
int
iperf_get_test_omit(struct iperf_test *ipt)
{
return ipt->omit;
}
int
iperf_get_test_duration(struct iperf_test *ipt)
{
return ipt->duration;
}
uint64_t
iperf_get_test_rate(struct iperf_test *ipt)
{
return ipt->settings->rate;
}
uint64_t
iperf_get_test_bitrate_limit(struct iperf_test *ipt)
{
return ipt->settings->bitrate_limit;
}
double
iperf_get_test_bitrate_limit_interval(struct iperf_test *ipt)
{
return ipt->settings->bitrate_limit_interval;
}
int
iperf_get_test_bitrate_limit_stats_per_interval(struct iperf_test *ipt)
{
return ipt->settings->bitrate_limit_stats_per_interval;
}
uint64_t
iperf_get_test_fqrate(struct iperf_test *ipt)
{
return ipt->settings->fqrate;
}
int
iperf_get_test_pacing_timer(struct iperf_test *ipt)
{
return ipt->settings->pacing_timer;
}
uint64_t
iperf_get_test_bytes(struct iperf_test *ipt)
{
return (uint64_t) ipt->settings->bytes;
}
uint64_t
iperf_get_test_blocks(struct iperf_test *ipt)
{
return (uint64_t) ipt->settings->blocks;
}
int
iperf_get_test_burst(struct iperf_test *ipt)
{
return ipt->settings->burst;
}
char
iperf_get_test_role(struct iperf_test *ipt)
{
return ipt->role;
}
int
iperf_get_test_reverse(struct iperf_test *ipt)
{
return ipt->reverse;
}
int
iperf_get_test_bidirectional(struct iperf_test *ipt)
{
return ipt->bidirectional;
}
int
iperf_get_test_blksize(struct iperf_test *ipt)
{
return ipt->settings->blksize;
}
FILE *
iperf_get_test_outfile (struct iperf_test *ipt)
{
return ipt->outfile;
}
int
iperf_get_test_socket_bufsize(struct iperf_test *ipt)
{
return ipt->settings->socket_bufsize;
}
double
iperf_get_test_reporter_interval(struct iperf_test *ipt)
{
return ipt->reporter_interval;
}
double
iperf_get_test_stats_interval(struct iperf_test *ipt)
{
return ipt->stats_interval;
}
int
iperf_get_test_num_streams(struct iperf_test *ipt)
{
return ipt->num_streams;
}
int
iperf_get_test_timestamps(struct iperf_test *ipt)
{
return ipt->timestamps;
}
const char *
iperf_get_test_timestamp_format(struct iperf_test *ipt)
{
return ipt->timestamp_format;
}
int
iperf_get_test_repeating_payload(struct iperf_test *ipt)
{
return ipt->repeating_payload;
}
int
iperf_get_test_bind_port(struct iperf_test *ipt)
{
return ipt->bind_port;
}
int
iperf_get_test_server_port(struct iperf_test *ipt)
{
return ipt->server_port;
}
char*
iperf_get_test_server_hostname(struct iperf_test *ipt)
{
return ipt->server_hostname;
}
char*
iperf_get_test_template(struct iperf_test *ipt)
{
return ipt->tmp_template;
}
int
iperf_get_test_protocol_id(struct iperf_test *ipt)
{
return ipt->protocol->id;
}
int
iperf_get_test_json_output(struct iperf_test *ipt)
{
return ipt->json_output;
}
char *
iperf_get_test_json_output_string(struct iperf_test *ipt)
{
return ipt->json_output_string;
}
int
iperf_get_test_zerocopy(struct iperf_test *ipt)
{
return ipt->zerocopy;
}
int
iperf_get_test_get_server_output(struct iperf_test *ipt)
{
return ipt->get_server_output;
}
char
iperf_get_test_unit_format(struct iperf_test *ipt)
{
return ipt->settings->unit_format;
}
char *
iperf_get_test_bind_address(struct iperf_test *ipt)
{
return ipt->bind_address;
}
char *
iperf_get_test_bind_dev(struct iperf_test *ipt)
{
return ipt->bind_dev;
}
int
iperf_get_test_udp_counters_64bit(struct iperf_test *ipt)
{
return ipt->udp_counters_64bit;
}
int
iperf_get_test_one_off(struct iperf_test *ipt)
{
return ipt->one_off;
}
int
iperf_get_test_tos(struct iperf_test *ipt)
{
return ipt->settings->tos;
}
char *
iperf_get_test_extra_data(struct iperf_test *ipt)
{
return ipt->extra_data;
}
static const char iperf_version[] = IPERF_VERSION;
char *
iperf_get_iperf_version(void)
{
return (char*)iperf_version;
}
int
iperf_get_test_no_delay(struct iperf_test *ipt)
{
return ipt->no_delay;
}
int
iperf_get_test_connect_timeout(struct iperf_test *ipt)
{
return ipt->settings->connect_timeout;
}
int
iperf_get_test_idle_timeout(struct iperf_test *ipt)
{
return ipt->settings->idle_timeout;
}
int
iperf_get_dont_fragment(struct iperf_test *ipt)
{
return ipt->settings->dont_fragment;
}
struct iperf_time*
iperf_get_test_rcv_timeout(struct iperf_test *ipt)
{
return &ipt->settings->rcv_timeout;
}
char*
iperf_get_test_congestion_control(struct iperf_test* ipt)
{
return ipt->congestion;
}
int
iperf_get_test_mss(struct iperf_test *ipt)
{
return ipt->settings->mss;
}
int
iperf_get_mapped_v4(struct iperf_test* ipt)
{
return ipt->mapped_v4;
}
/************** Setter routines for some fields inside iperf_test *************/
void
iperf_set_verbose(struct iperf_test *ipt, int verbose)
{
ipt->verbose = verbose;
}
void
iperf_set_control_socket(struct iperf_test *ipt, int ctrl_sck)
{
ipt->ctrl_sck = ctrl_sck;
}
void
iperf_set_test_omit(struct iperf_test *ipt, int omit)
{
ipt->omit = omit;
}
void
iperf_set_test_duration(struct iperf_test *ipt, int duration)
{
ipt->duration = duration;
}
void
iperf_set_test_reporter_interval(struct iperf_test *ipt, double reporter_interval)
{
ipt->reporter_interval = reporter_interval;
}
void
iperf_set_test_stats_interval(struct iperf_test *ipt, double stats_interval)
{
ipt->stats_interval = stats_interval;
}
void
iperf_set_test_state(struct iperf_test *ipt, signed char state)
{
ipt->state = state;
}
void
iperf_set_test_blksize(struct iperf_test *ipt, int blksize)
{
ipt->settings->blksize = blksize;
}
void
iperf_set_test_logfile(struct iperf_test *ipt, const char *logfile)
{
ipt->logfile = strdup(logfile);
}
void
iperf_set_test_rate(struct iperf_test *ipt, uint64_t rate)
{
ipt->settings->rate = rate;
}
void
iperf_set_test_bitrate_limit_maximum(struct iperf_test *ipt, uint64_t total_rate)
{
ipt->settings->bitrate_limit = total_rate;
}
void
iperf_set_test_bitrate_limit_interval(struct iperf_test *ipt, uint64_t bitrate_limit_interval)
{
ipt->settings->bitrate_limit_interval = bitrate_limit_interval;
}
void
iperf_set_test_bitrate_limit_stats_per_interval(struct iperf_test *ipt, uint64_t bitrate_limit_stats_per_interval)
{
ipt->settings->bitrate_limit_stats_per_interval = bitrate_limit_stats_per_interval;
}
void
iperf_set_test_fqrate(struct iperf_test *ipt, uint64_t fqrate)
{
ipt->settings->fqrate = fqrate;
}
void
iperf_set_test_pacing_timer(struct iperf_test *ipt, int pacing_timer)
{
ipt->settings->pacing_timer = pacing_timer;
}
void
iperf_set_test_bytes(struct iperf_test *ipt, uint64_t bytes)
{
ipt->settings->bytes = (iperf_size_t) bytes;
}
void
iperf_set_test_blocks(struct iperf_test *ipt, uint64_t blocks)
{
ipt->settings->blocks = (iperf_size_t) blocks;
}
void
iperf_set_test_burst(struct iperf_test *ipt, int burst)
{
ipt->settings->burst = burst;
}
void
iperf_set_test_bind_port(struct iperf_test *ipt, int bind_port)
{
ipt->bind_port = bind_port;
}
void
iperf_set_test_server_port(struct iperf_test *ipt, int srv_port)
{
ipt->server_port = srv_port;
}
void
iperf_set_test_socket_bufsize(struct iperf_test *ipt, int socket_bufsize)
{
ipt->settings->socket_bufsize = socket_bufsize;
}
void
iperf_set_test_num_streams(struct iperf_test *ipt, int num_streams)
{
ipt->num_streams = num_streams;
}
void
iperf_set_test_repeating_payload(struct iperf_test *ipt, int repeating_payload)
{
ipt->repeating_payload = repeating_payload;
}
void
iperf_set_test_timestamps(struct iperf_test *ipt, int timestamps)
{
ipt->timestamps = timestamps;
}
void
iperf_set_test_timestamp_format(struct iperf_test *ipt, const char *tf)
{
ipt->timestamp_format = strdup(tf);
}
void
iperf_set_mapped_v4(struct iperf_test *ipt, const int val)
{
ipt->mapped_v4 = val;
}
void
iperf_set_on_new_stream_callback(struct iperf_test* ipt, void (*callback)())
{
ipt->on_new_stream = callback;
}
void
iperf_set_on_test_start_callback(struct iperf_test* ipt, void (*callback)())
{
ipt->on_test_start = callback;
}
void
iperf_set_on_test_connect_callback(struct iperf_test* ipt, void (*callback)())
{
ipt->on_connect = callback;
}
void
iperf_set_on_test_finish_callback(struct iperf_test* ipt, void (*callback)())
{
ipt->on_test_finish = callback;
}
static void
check_sender_has_retransmits(struct iperf_test *ipt)
{
if (ipt->mode != RECEIVER && ipt->protocol->id == Ptcp && has_tcpinfo_retransmits())
ipt->sender_has_retransmits = 1;
else
ipt->sender_has_retransmits = 0;
}
void
iperf_set_test_role(struct iperf_test *ipt, char role)
{
ipt->role = role;
if (!ipt->reverse) {
if (ipt->bidirectional)
ipt->mode = BIDIRECTIONAL;
else if (role == 'c')
ipt->mode = SENDER;
else if (role == 's')
ipt->mode = RECEIVER;
} else {
if (role == 'c')
ipt->mode = RECEIVER;
else if (role == 's')
ipt->mode = SENDER;
}
check_sender_has_retransmits(ipt);
}
void
iperf_set_test_server_hostname(struct iperf_test *ipt, const char *server_hostname)
{
ipt->server_hostname = strdup(server_hostname);
}
void
iperf_set_test_template(struct iperf_test *ipt, const char *tmp_template)
{
ipt->tmp_template = strdup(tmp_template);
}
void
iperf_set_test_reverse(struct iperf_test *ipt, int reverse)
{
ipt->reverse = reverse;
if (!ipt->reverse) {
if (ipt->role == 'c')
ipt->mode = SENDER;
else if (ipt->role == 's')
ipt->mode = RECEIVER;
} else {
if (ipt->role == 'c')
ipt->mode = RECEIVER;
else if (ipt->role == 's')
ipt->mode = SENDER;
}
check_sender_has_retransmits(ipt);
}
void
iperf_set_test_json_output(struct iperf_test *ipt, int json_output)
{
ipt->json_output = json_output;
}
int
iperf_has_zerocopy( void )
{
return has_sendfile();
}
void
iperf_set_test_zerocopy(struct iperf_test *ipt, int zerocopy)
{
ipt->zerocopy = (zerocopy && has_sendfile());
}
void
iperf_set_test_get_server_output(struct iperf_test *ipt, int get_server_output)
{
ipt->get_server_output = get_server_output;
}
void
iperf_set_test_unit_format(struct iperf_test *ipt, char unit_format)
{
ipt->settings->unit_format = unit_format;
}
#if defined(HAVE_SSL)
void
iperf_set_test_client_username(struct iperf_test *ipt, const char *client_username)
{
ipt->settings->client_username = strdup(client_username);
}
void
iperf_set_test_client_password(struct iperf_test *ipt, const char *client_password)
{
ipt->settings->client_password = strdup(client_password);
}
void
iperf_set_test_client_rsa_pubkey(struct iperf_test *ipt, const char *client_rsa_pubkey_base64)
{
ipt->settings->client_rsa_pubkey = load_pubkey_from_base64(client_rsa_pubkey_base64);
}
void
iperf_set_test_server_authorized_users(struct iperf_test *ipt, const char *server_authorized_users)
{
ipt->server_authorized_users = strdup(server_authorized_users);
}
void
iperf_set_test_server_skew_threshold(struct iperf_test *ipt, int server_skew_threshold)
{
ipt->server_skew_threshold = server_skew_threshold;
}
void
iperf_set_test_server_rsa_privkey(struct iperf_test *ipt, const char *server_rsa_privkey_base64)
{
ipt->server_rsa_private_key = load_privkey_from_base64(server_rsa_privkey_base64);
}
#endif // HAVE_SSL
void
iperf_set_test_bind_address(struct iperf_test *ipt, const char *bnd_address)
{
ipt->bind_address = strdup(bnd_address);
}
void
iperf_set_test_bind_dev(struct iperf_test *ipt, const char *bnd_dev)
{
ipt->bind_dev = strdup(bnd_dev);
}
void
iperf_set_test_udp_counters_64bit(struct iperf_test *ipt, int udp_counters_64bit)
{
ipt->udp_counters_64bit = udp_counters_64bit;
}
void
iperf_set_test_one_off(struct iperf_test *ipt, int one_off)
{
ipt->one_off = one_off;
}
void
iperf_set_test_tos(struct iperf_test *ipt, int tos)
{
ipt->settings->tos = tos;
}
void
iperf_set_test_extra_data(struct iperf_test *ipt, const char *dat)
{
ipt->extra_data = strdup(dat);
}
void
iperf_set_test_bidirectional(struct iperf_test* ipt, int bidirectional)
{
ipt->bidirectional = bidirectional;
if (bidirectional)
ipt->mode = BIDIRECTIONAL;
else
iperf_set_test_reverse(ipt, ipt->reverse);
}
void
iperf_set_test_no_delay(struct iperf_test* ipt, int no_delay)
{
ipt->no_delay = no_delay;
}
void
iperf_set_test_connect_timeout(struct iperf_test* ipt, int ct)
{
ipt->settings->connect_timeout = ct;
}
void
iperf_set_test_idle_timeout(struct iperf_test* ipt, int to)
{
ipt->settings->idle_timeout = to;
}
void
iperf_set_dont_fragment(struct iperf_test* ipt, int dnf)
{
ipt->settings->dont_fragment = dnf;
}
void
iperf_set_test_rcv_timeout(struct iperf_test* ipt, struct iperf_time* to)
{
ipt->settings->rcv_timeout.secs = to->secs;
ipt->settings->rcv_timeout.usecs = to->usecs;
}
void
iperf_set_test_congestion_control(struct iperf_test* ipt, char* cc)
{
ipt->congestion = strdup(cc);
}
void
iperf_set_test_mss(struct iperf_test *ipt, int mss)
{
ipt->settings->mss = mss;
}
/********************** Get/set test protocol structure ***********************/
struct protocol *
get_protocol(struct iperf_test *test, int prot_id)
{
struct protocol *prot;
SLIST_FOREACH(prot, &test->protocols, protocols) {
if (prot->id == prot_id)
break;
}
if (prot == NULL)
i_errno = IEPROTOCOL;
return prot;
}
int
set_protocol(struct iperf_test *test, int prot_id)
{
struct protocol *prot = NULL;
SLIST_FOREACH(prot, &test->protocols, protocols) {
if (prot->id == prot_id) {
test->protocol = prot;
check_sender_has_retransmits(test);
return 0;
}
}
i_errno = IEPROTOCOL;
return -1;
}
/************************** Iperf callback functions **************************/
void
iperf_on_new_stream(struct iperf_stream *sp)
{
connect_msg(sp);
}
void
iperf_on_test_start(struct iperf_test *test)
{
if (test->json_output) {
cJSON_AddItemToObject(test->json_start, "test_start", iperf_json_printf("protocol: %s num_streams: %d blksize: %d omit: %d duration: %d bytes: %d blocks: %d reverse: %d tos: %d target_bitrate: %d bidir: %d fqrate: %d", test->protocol->name, (int64_t) test->num_streams, (int64_t) test->settings->blksize, (int64_t) test->omit, (int64_t) test->duration, (int64_t) test->settings->bytes, (int64_t) test->settings->blocks, test->reverse?(int64_t)1:(int64_t)0, (int64_t) test->settings->tos, (int64_t) test->settings->rate, (int64_t) test->bidirectional, (uint64_t) test->settings->fqrate));
} else {
if (test->verbose) {
if (test->settings->bytes)
iperf_printf(test, test_start_bytes, test->protocol->name, test->num_streams, test->settings->blksize, test->omit, test->settings->bytes, test->settings->tos);
else if (test->settings->blocks)
iperf_printf(test, test_start_blocks, test->protocol->name, test->num_streams, test->settings->blksize, test->omit, test->settings->blocks, test->settings->tos);
else
iperf_printf(test, test_start_time, test->protocol->name, test->num_streams, test->settings->blksize, test->omit, test->duration, test->settings->tos);
}
}
}
/* This converts an IPv6 string address from IPv4-mapped format into regular
** old IPv4 format, which is easier on the eyes of network veterans.
**
** If the v6 address is not v4-mapped it is left alone.
**
** Returns 1 if the v6 address is v4-mapped, 0 otherwise.
*/
static int
mapped_v4_to_regular_v4(char *str)
{
char *prefix = "::ffff:";
int prefix_len;
prefix_len = strlen(prefix);
if (strncmp(str, prefix, prefix_len) == 0) {
int str_len = strlen(str);
memmove(str, str + prefix_len, str_len - prefix_len + 1);
return 1;
}
return 0;
}
void
iperf_on_connect(struct iperf_test *test)
{
time_t now_secs;
const char* rfc1123_fmt = "%a, %d %b %Y %H:%M:%S %Z";
char now_str[100];
char ipr[INET6_ADDRSTRLEN];
int port;
struct sockaddr_storage sa;
struct sockaddr_in *sa_inP;
struct sockaddr_in6 *sa_in6P;
socklen_t len;
now_secs = time((time_t*) 0);
(void) strftime(now_str, sizeof(now_str), rfc1123_fmt, gmtime(&now_secs));
if (test->json_output)
cJSON_AddItemToObject(test->json_start, "timestamp", iperf_json_printf("time: %s timesecs: %d", now_str, (int64_t) now_secs));
else if (test->verbose)
iperf_printf(test, report_time, now_str);
if (test->role == 'c') {
if (test->json_output)
cJSON_AddItemToObject(test->json_start, "connecting_to", iperf_json_printf("host: %s port: %d", test->server_hostname, (int64_t) test->server_port));
else {
iperf_printf(test, report_connecting, test->server_hostname, test->server_port);
if (test->reverse)
iperf_printf(test, report_reverse, test->server_hostname);
}
} else {
len = sizeof(sa);
getpeername(test->ctrl_sck, (struct sockaddr *) &sa, &len);
if (getsockdomain(test->ctrl_sck) == AF_INET) {
sa_inP = (struct sockaddr_in *) &sa;
inet_ntop(AF_INET, &sa_inP->sin_addr, ipr, sizeof(ipr));
port = ntohs(sa_inP->sin_port);
} else {
sa_in6P = (struct sockaddr_in6 *) &sa;
inet_ntop(AF_INET6, &sa_in6P->sin6_addr, ipr, sizeof(ipr));
port = ntohs(sa_in6P->sin6_port);
}
if (mapped_v4_to_regular_v4(ipr)) {
iperf_set_mapped_v4(test, 1);
}
if (test->json_output)
cJSON_AddItemToObject(test->json_start, "accepted_connection", iperf_json_printf("host: %s port: %d", ipr, (int64_t) port));
else
iperf_printf(test, report_accepted, ipr, port);
}
if (test->json_output) {
cJSON_AddStringToObject(test->json_start, "cookie", test->cookie);
if (test->protocol->id == SOCK_STREAM) {
if (test->settings->mss)
cJSON_AddNumberToObject(test->json_start, "tcp_mss", test->settings->mss);
else {
cJSON_AddNumberToObject(test->json_start, "tcp_mss_default", test->ctrl_sck_mss);
}
}
// Duplicate to make sure it appears on all output
cJSON_AddNumberToObject(test->json_start, "target_bitrate", test->settings->rate);
cJSON_AddNumberToObject(test->json_start, "fq_rate", test->settings->fqrate);
} else if (test->verbose) {
iperf_printf(test, report_cookie, test->cookie);
if (test->protocol->id == SOCK_STREAM) {
if (test->settings->mss)
iperf_printf(test, " TCP MSS: %d\n", test->settings->mss);
else {
iperf_printf(test, " TCP MSS: %d (default)\n", test->ctrl_sck_mss);
}
}
if (test->settings->rate)
iperf_printf(test, " Target Bitrate: %"PRIu64"\n", test->settings->rate);
}
}
void
iperf_on_test_finish(struct iperf_test *test)
{
}
/******************************************************************************/
/*
* iperf_parse_hostname tries to split apart a string into hostname %
* interface parts, which are returned in **p and **p1, if they
* exist. If the %interface part is detected, and it's not an IPv6
* link local address, then returns 1, else returns 0.
*
* Modifies the string pointed to by spec in-place due to the use of
* strtok(3). The caller should strdup(3) or otherwise copy the string
* if an unmodified copy is needed.
*/
int
iperf_parse_hostname(struct iperf_test *test, char *spec, char **p, char **p1) {
struct in6_addr ipv6_addr;
// Format is <addr>[%<device>]
if ((*p = strtok(spec, "%")) != NULL &&
(*p1 = strtok(NULL, "%")) != NULL) {
/*
* If an IPv6 literal for a link-local address, then
* tell the caller to leave the "%" in the hostname.
*/
if (inet_pton(AF_INET6, *p, &ipv6_addr) == 1 &&
IN6_IS_ADDR_LINKLOCAL(&ipv6_addr)) {
if (test->debug) {
iperf_printf(test, "IPv6 link-local address literal detected\n");
}
return 0;
}
/*
* Other kind of address or FQDN. The interface name after
* "%" is a shorthand for --bind-dev.
*/
else {
if (test->debug) {
iperf_printf(test, "p %s p1 %s\n", *p, *p1);
}
return 1;
}
}
else {
if (test->debug) {
iperf_printf(test, "noparse\n");
}
return 0;
}
}
int
iperf_parse_arguments(struct iperf_test *test, int argc, char **argv)
{
static struct option longopts[] =
{
{"port", required_argument, NULL, 'p'},
{"format", required_argument, NULL, 'f'},
{"interval", required_argument, NULL, 'i'},
{"daemon", no_argument, NULL, 'D'},
{"one-off", no_argument, NULL, '1'},
{"verbose", no_argument, NULL, 'V'},
{"json", no_argument, NULL, 'J'},
{"version", no_argument, NULL, 'v'},
{"server", no_argument, NULL, 's'},
{"client", required_argument, NULL, 'c'},
{"udp", no_argument, NULL, 'u'},
{"bitrate", required_argument, NULL, 'b'},
{"bandwidth", required_argument, NULL, 'b'},
{"server-bitrate-limit", required_argument, NULL, OPT_SERVER_BITRATE_LIMIT},
{"time", required_argument, NULL, 't'},
{"bytes", required_argument, NULL, 'n'},
{"blockcount", required_argument, NULL, 'k'},
{"length", required_argument, NULL, 'l'},
{"parallel", required_argument, NULL, 'P'},
{"reverse", no_argument, NULL, 'R'},
{"bidir", no_argument, NULL, OPT_BIDIRECTIONAL},
{"window", required_argument, NULL, 'w'},
{"bind", required_argument, NULL, 'B'},
#if defined(HAVE_SO_BINDTODEVICE)
{"bind-dev", required_argument, NULL, OPT_BIND_DEV},
#endif /* HAVE_SO_BINDTODEVICE */
{"cport", required_argument, NULL, OPT_CLIENT_PORT},
{"set-mss", required_argument, NULL, 'M'},
{"no-delay", no_argument, NULL, 'N'},
{"version4", no_argument, NULL, '4'},
{"version6", no_argument, NULL, '6'},
{"tos", required_argument, NULL, 'S'},
{"dscp", required_argument, NULL, OPT_DSCP},
{"extra-data", required_argument, NULL, OPT_EXTRA_DATA},
#if defined(HAVE_FLOWLABEL)
{"flowlabel", required_argument, NULL, 'L'},
#endif /* HAVE_FLOWLABEL */
{"zerocopy", no_argument, NULL, 'Z'},
{"omit", required_argument, NULL, 'O'},
{"file", required_argument, NULL, 'F'},
{"repeating-payload", no_argument, NULL, OPT_REPEATING_PAYLOAD},
{"timestamps", optional_argument, NULL, OPT_TIMESTAMPS},
#if defined(HAVE_CPU_AFFINITY)
{"affinity", required_argument, NULL, 'A'},
#endif /* HAVE_CPU_AFFINITY */
{"title", required_argument, NULL, 'T'},
#if defined(HAVE_TCP_CONGESTION)
{"congestion", required_argument, NULL, 'C'},
{"linux-congestion", required_argument, NULL, 'C'},
#endif /* HAVE_TCP_CONGESTION */
#if defined(HAVE_SCTP_H)
{"sctp", no_argument, NULL, OPT_SCTP},
{"nstreams", required_argument, NULL, OPT_NUMSTREAMS},
{"xbind", required_argument, NULL, 'X'},
#endif
{"pidfile", required_argument, NULL, 'I'},
{"logfile", required_argument, NULL, OPT_LOGFILE},
{"forceflush", no_argument, NULL, OPT_FORCEFLUSH},
{"get-server-output", no_argument, NULL, OPT_GET_SERVER_OUTPUT},
{"udp-counters-64bit", no_argument, NULL, OPT_UDP_COUNTERS_64BIT},
{"no-fq-socket-pacing", no_argument, NULL, OPT_NO_FQ_SOCKET_PACING},
#if defined(HAVE_DONT_FRAGMENT)
{"dont-fragment", no_argument, NULL, OPT_DONT_FRAGMENT},
#endif /* HAVE_DONT_FRAGMENT */
#if defined(HAVE_SSL)
{"username", required_argument, NULL, OPT_CLIENT_USERNAME},
{"rsa-public-key-path", required_argument, NULL, OPT_CLIENT_RSA_PUBLIC_KEY},
{"rsa-private-key-path", required_argument, NULL, OPT_SERVER_RSA_PRIVATE_KEY},
{"authorized-users-path", required_argument, NULL, OPT_SERVER_AUTHORIZED_USERS},
{"time-skew-threshold", required_argument, NULL, OPT_SERVER_SKEW_THRESHOLD},
#endif /* HAVE_SSL */
{"fq-rate", required_argument, NULL, OPT_FQ_RATE},
{"pacing-timer", required_argument, NULL, OPT_PACING_TIMER},
{"connect-timeout", required_argument, NULL, OPT_CONNECT_TIMEOUT},
{"idle-timeout", required_argument, NULL, OPT_IDLE_TIMEOUT},
{"rcv-timeout", required_argument, NULL, OPT_RCV_TIMEOUT},
{"snd-timeout", required_argument, NULL, OPT_SND_TIMEOUT},
{"debug", optional_argument, NULL, 'd'},
{"help", no_argument, NULL, 'h'},
{NULL, 0, NULL, 0}
};
int flag;
int portno;
int blksize;
int server_flag, client_flag, rate_flag, duration_flag, rcv_timeout_flag, snd_timeout_flag;
char *endptr;
#if defined(HAVE_CPU_AFFINITY)
char* comma;
#endif /* HAVE_CPU_AFFINITY */
char* slash;
char *p, *p1;
struct xbind_entry *xbe;
double farg;
int rcv_timeout_in = 0;
blksize = 0;
server_flag = client_flag = rate_flag = duration_flag = rcv_timeout_flag = snd_timeout_flag =0;
#if defined(HAVE_SSL)
char *client_username = NULL, *client_rsa_public_key = NULL, *server_rsa_private_key = NULL;
#endif /* HAVE_SSL */
while ((flag = getopt_long(argc, argv, "p:f:i:D1VJvsc:ub:t:n:k:l:P:Rw:B:M:N46S:L:ZO:F:A:T:C:dI:hX:", longopts, NULL)) != -1) {
switch (flag) {
case 'p':
portno = atoi(optarg);
if (portno < 1 || portno > 65535) {
i_errno = IEBADPORT;
return -1;
}
test->server_port = portno;
break;
case 'f':
if (!optarg) {
i_errno = IEBADFORMAT;
return -1;
}
test->settings->unit_format = *optarg;
if (test->settings->unit_format == 'k' ||
test->settings->unit_format == 'K' ||
test->settings->unit_format == 'm' ||
test->settings->unit_format == 'M' ||
test->settings->unit_format == 'g' ||
test->settings->unit_format == 'G' ||
test->settings->unit_format == 't' ||
test->settings->unit_format == 'T') {
break;
}
else {
i_errno = IEBADFORMAT;
return -1;
}
break;
case 'i':
/* XXX: could potentially want separate stat collection and reporting intervals,
but just set them to be the same for now */
test->stats_interval = test->reporter_interval = atof(optarg);
if ((test->stats_interval < MIN_INTERVAL || test->stats_interval > MAX_INTERVAL) && test->stats_interval != 0) {
i_errno = IEINTERVAL;
return -1;
}
break;
case 'D':
test->daemon = 1;
server_flag = 1;
break;
case '1':
test->one_off = 1;
server_flag = 1;
break;
case 'V':
test->verbose = 1;
break;
case 'J':
test->json_output = 1;
break;
case 'v':
printf("%s (cJSON %s)\n%s\n%s\n", version, cJSON_Version(), get_system_info(),
get_optional_features());
exit(0);
case 's':
if (test->role == 'c') {
i_errno = IESERVCLIENT;
return -1;
}
iperf_set_test_role(test, 's');
break;
case 'c':
if (test->role == 's') {
i_errno = IESERVCLIENT;
return -1;
}
iperf_set_test_role(test, 'c');
iperf_set_test_server_hostname(test, optarg);
if (iperf_parse_hostname(test, optarg, &p, &p1)) {
#if defined(HAVE_SO_BINDTODEVICE)
/* Get rid of the hostname we saved earlier. */
free(iperf_get_test_server_hostname(test));
iperf_set_test_server_hostname(test, p);
iperf_set_test_bind_dev(test, p1);
#else /* HAVE_SO_BINDTODEVICE */
i_errno = IEBINDDEVNOSUPPORT;
return -1;
#endif /* HAVE_SO_BINDTODEVICE */
}
break;
case 'u':
set_protocol(test, Pudp);
client_flag = 1;
break;
case OPT_SCTP:
#if defined(HAVE_SCTP_H)
set_protocol(test, Psctp);
client_flag = 1;
break;
#else /* HAVE_SCTP_H */
i_errno = IEUNIMP;
return -1;
#endif /* HAVE_SCTP_H */
case OPT_NUMSTREAMS:
#if defined(linux) || defined(__FreeBSD__)
test->settings->num_ostreams = unit_atoi(optarg);
client_flag = 1;
#else /* linux */
i_errno = IEUNIMP;
return -1;
#endif /* linux */
case 'b':
slash = strchr(optarg, '/');
if (slash) {
*slash = '\0';
++slash;
test->settings->burst = atoi(slash);
if (test->settings->burst <= 0 ||
test->settings->burst > MAX_BURST) {
i_errno = IEBURST;
return -1;
}
}
test->settings->rate = unit_atof_rate(optarg);
rate_flag = 1;
client_flag = 1;
break;
case OPT_SERVER_BITRATE_LIMIT:
slash = strchr(optarg, '/');
if (slash) {
*slash = '\0';
++slash;
test->settings->bitrate_limit_interval = atof(slash);
if (test->settings->bitrate_limit_interval != 0 && /* Using same Max/Min limits as for Stats Interval */
(test->settings->bitrate_limit_interval < MIN_INTERVAL || test->settings->bitrate_limit_interval > MAX_INTERVAL) ) {
i_errno = IETOTALINTERVAL;
return -1;
}
}
test->settings->bitrate_limit = unit_atof_rate(optarg);
server_flag = 1;
break;
case 't':
test->duration = atoi(optarg);
if (test->duration > MAX_TIME) {
i_errno = IEDURATION;
return -1;
}
duration_flag = 1;
client_flag = 1;
break;
case 'n':
test->settings->bytes = unit_atoi(optarg);
client_flag = 1;
break;
case 'k':
test->settings->blocks = unit_atoi(optarg);
client_flag = 1;
break;
case 'l':
blksize = unit_atoi(optarg);
client_flag = 1;
break;
case 'P':
test->num_streams = atoi(optarg);
if (test->num_streams > MAX_STREAMS) {
i_errno = IENUMSTREAMS;
return -1;
}
client_flag = 1;
break;
case 'R':
if (test->bidirectional) {
i_errno = IEREVERSEBIDIR;
return -1;
}
iperf_set_test_reverse(test, 1);
client_flag = 1;
break;
case OPT_BIDIRECTIONAL:
if (test->reverse) {
i_errno = IEREVERSEBIDIR;
return -1;
}
iperf_set_test_bidirectional(test, 1);
client_flag = 1;
break;
case 'w':
// XXX: This is a socket buffer, not specific to TCP
// Do sanity checks as double-precision floating point
// to avoid possible integer overflows.
farg = unit_atof(optarg);
if (farg > (double) MAX_TCP_BUFFER) {
i_errno = IEBUFSIZE;
return -1;
}
test->settings->socket_bufsize = (int) farg;
client_flag = 1;
break;
case 'B':
iperf_set_test_bind_address(test, optarg);
if (iperf_parse_hostname(test, optarg, &p, &p1)) {
#if defined(HAVE_SO_BINDTODEVICE)
/* Get rid of the hostname we saved earlier. */
free(iperf_get_test_bind_address(test));
iperf_set_test_bind_address(test, p);
iperf_set_test_bind_dev(test, p1);
#else /* HAVE_SO_BINDTODEVICE */
i_errno = IEBINDDEVNOSUPPORT;
return -1;
#endif /* HAVE_SO_BINDTODEVICE */
}
break;
#if defined (HAVE_SO_BINDTODEVICE)
case OPT_BIND_DEV:
iperf_set_test_bind_dev(test, optarg);
break;
#endif /* HAVE_SO_BINDTODEVICE */
case OPT_CLIENT_PORT:
portno = atoi(optarg);
if (portno < 1 || portno > 65535) {
i_errno = IEBADPORT;
return -1;
}
test->bind_port = portno;
break;
case 'M':
test->settings->mss = atoi(optarg);
if (test->settings->mss > MAX_MSS) {
i_errno = IEMSS;
return -1;
}
client_flag = 1;
break;
case 'N':
test->no_delay = 1;
client_flag = 1;
break;
case '4':
test->settings->domain = AF_INET;
break;
case '6':
test->settings->domain = AF_INET6;
break;
case 'S':
test->settings->tos = strtol(optarg, &endptr, 0);
if (endptr == optarg ||
test->settings->tos < 0 ||
test->settings->tos > 255) {
i_errno = IEBADTOS;
return -1;
}
client_flag = 1;
break;
case OPT_DSCP:
test->settings->tos = parse_qos(optarg);
if(test->settings->tos < 0) {
i_errno = IEBADTOS;
return -1;
}
client_flag = 1;
break;
case OPT_EXTRA_DATA:
test->extra_data = strdup(optarg);
client_flag = 1;
break;
case 'L':
#if defined(HAVE_FLOWLABEL)
test->settings->flowlabel = strtol(optarg, &endptr, 0);
if (endptr == optarg ||
test->settings->flowlabel < 1 || test->settings->flowlabel > 0xfffff) {
i_errno = IESETFLOW;
return -1;
}
client_flag = 1;
#else /* HAVE_FLOWLABEL */
i_errno = IEUNIMP;
return -1;
#endif /* HAVE_FLOWLABEL */
break;
case 'X':
xbe = (struct xbind_entry *)malloc(sizeof(struct xbind_entry));
if (!xbe) {
i_errno = IESETSCTPBINDX;
return -1;
}
memset(xbe, 0, sizeof(*xbe));
xbe->name = strdup(optarg);
if (!xbe->name) {
i_errno = IESETSCTPBINDX;
return -1;
}
TAILQ_INSERT_TAIL(&test->xbind_addrs, xbe, link);
break;
case 'Z':
if (!has_sendfile()) {
i_errno = IENOSENDFILE;
return -1;
}
test->zerocopy = 1;
client_flag = 1;
break;
case OPT_REPEATING_PAYLOAD:
test->repeating_payload = 1;
client_flag = 1;
break;
case OPT_TIMESTAMPS:
iperf_set_test_timestamps(test, 1);
if (optarg) {
iperf_set_test_timestamp_format(test, optarg);
}
else {
iperf_set_test_timestamp_format(test, TIMESTAMP_FORMAT);
}
break;
case 'O':
test->omit = atoi(optarg);
if (test->omit < 0 || test->omit > 60) {
i_errno = IEOMIT;
return -1;
}
client_flag = 1;
break;
case 'F':
test->diskfile_name = optarg;
break;
case OPT_IDLE_TIMEOUT:
test->settings->idle_timeout = atoi(optarg);
if (test->settings->idle_timeout < 1 || test->settings->idle_timeout > MAX_TIME) {
i_errno = IEIDLETIMEOUT;
return -1;
}
server_flag = 1;
break;
case OPT_RCV_TIMEOUT:
rcv_timeout_in = atoi(optarg);
if (rcv_timeout_in < MIN_NO_MSG_RCVD_TIMEOUT || rcv_timeout_in > MAX_TIME * SEC_TO_mS) {
i_errno = IERCVTIMEOUT;
return -1;
}
test->settings->rcv_timeout.secs = rcv_timeout_in / SEC_TO_mS;
test->settings->rcv_timeout.usecs = (rcv_timeout_in % SEC_TO_mS) * mS_TO_US;
rcv_timeout_flag = 1;
break;
#if defined(HAVE_TCP_USER_TIMEOUT)
case OPT_SND_TIMEOUT:
test->settings->snd_timeout = atoi(optarg);
if (test->settings->snd_timeout < 0 || test->settings->snd_timeout > MAX_TIME * SEC_TO_mS) {
i_errno = IESNDTIMEOUT;
return -1;
}
snd_timeout_flag = 1;
break;
#endif /* HAVE_TCP_USER_TIMEOUT */
case 'A':
#if defined(HAVE_CPU_AFFINITY)
test->affinity = strtol(optarg, &endptr, 0);
if (endptr == optarg ||
test->affinity < 0 || test->affinity > 1024) {
i_errno = IEAFFINITY;
return -1;
}
comma = strchr(optarg, ',');
if (comma != NULL) {
test->server_affinity = atoi(comma+1);
if (test->server_affinity < 0 || test->server_affinity > 1024) {
i_errno = IEAFFINITY;
return -1;
}
client_flag = 1;
}
#else /* HAVE_CPU_AFFINITY */
i_errno = IEUNIMP;
return -1;
#endif /* HAVE_CPU_AFFINITY */
break;
case 'T':
test->title = strdup(optarg);
client_flag = 1;
break;
case 'C':
#if defined(HAVE_TCP_CONGESTION)
test->congestion = strdup(optarg);
client_flag = 1;
#else /* HAVE_TCP_CONGESTION */
i_errno = IEUNIMP;
return -1;
#endif /* HAVE_TCP_CONGESTION */
break;
case 'd':
test->debug = 1;
test->debug_level = DEBUG_LEVEL_MAX;
if (optarg) {
test->debug_level = atoi(optarg);
if (test->debug_level < 0)
test->debug_level = DEBUG_LEVEL_MAX;
}
break;
case 'I':
test->pidfile = strdup(optarg);
break;
case OPT_LOGFILE:
test->logfile = strdup(optarg);
break;
case OPT_FORCEFLUSH:
test->forceflush = 1;
break;
case OPT_GET_SERVER_OUTPUT:
test->get_server_output = 1;
client_flag = 1;
break;
case OPT_UDP_COUNTERS_64BIT:
test->udp_counters_64bit = 1;
break;
case OPT_NO_FQ_SOCKET_PACING:
#if defined(HAVE_SO_MAX_PACING_RATE)
printf("Warning: --no-fq-socket-pacing is deprecated\n");
test->settings->fqrate = 0;
client_flag = 1;
#else /* HAVE_SO_MAX_PACING_RATE */
i_errno = IEUNIMP;
return -1;
#endif
break;
case OPT_FQ_RATE:
#if defined(HAVE_SO_MAX_PACING_RATE)
test->settings->fqrate = unit_atof_rate(optarg);
client_flag = 1;
#else /* HAVE_SO_MAX_PACING_RATE */
i_errno = IEUNIMP;
return -1;
#endif
break;
#if defined(HAVE_DONT_FRAGMENT)
case OPT_DONT_FRAGMENT:
test->settings->dont_fragment = 1;
client_flag = 1;
break;
#endif /* HAVE_DONT_FRAGMENT */
#if defined(HAVE_SSL)
case OPT_CLIENT_USERNAME:
client_username = strdup(optarg);
break;
case OPT_CLIENT_RSA_PUBLIC_KEY:
client_rsa_public_key = strdup(optarg);
break;
case OPT_SERVER_RSA_PRIVATE_KEY:
server_rsa_private_key = strdup(optarg);
break;
case OPT_SERVER_AUTHORIZED_USERS:
test->server_authorized_users = strdup(optarg);
break;
case OPT_SERVER_SKEW_THRESHOLD:
test->server_skew_threshold = atoi(optarg);
if(test->server_skew_threshold <= 0){
i_errno = IESKEWTHRESHOLD;
return -1;
}
break;
#endif /* HAVE_SSL */
case OPT_PACING_TIMER:
test->settings->pacing_timer = unit_atoi(optarg);
client_flag = 1;
break;
case OPT_CONNECT_TIMEOUT:
test->settings->connect_timeout = unit_atoi(optarg);
client_flag = 1;
break;
case 'h':
usage_long(stdout);
exit(0);
default:
fprintf(stderr, "\n");
usage();
exit(1);
}
}
/* Check flag / role compatibility. */
if (test->role == 'c' && server_flag) {
i_errno = IESERVERONLY;
return -1;
}
if (test->role == 's' && client_flag) {
i_errno = IECLIENTONLY;
return -1;
}
#if defined(HAVE_SSL)
if (test->role == 's' && (client_username || client_rsa_public_key)){
i_errno = IECLIENTONLY;
return -1;
} else if (test->role == 'c' && (client_username || client_rsa_public_key) &&
!(client_username && client_rsa_public_key)) {
i_errno = IESETCLIENTAUTH;
return -1;
} else if (test->role == 'c' && (client_username && client_rsa_public_key)){
char *client_password = NULL;
size_t s;
if (test_load_pubkey_from_file(client_rsa_public_key) < 0){
iperf_err(test, "%s\n", ERR_error_string(ERR_get_error(), NULL));
i_errno = IESETCLIENTAUTH;
return -1;
}
/* Need to copy env var, so we can do a common free */
if ((client_password = getenv("IPERF3_PASSWORD")) != NULL)
client_password = strdup(client_password);
else if (iperf_getpass(&client_password, &s, stdin) < 0){
i_errno = IESETCLIENTAUTH;
return -1;
}
test->settings->client_username = client_username;
test->settings->client_password = client_password;
test->settings->client_rsa_pubkey = load_pubkey_from_file(client_rsa_public_key);
free(client_rsa_public_key);
client_rsa_public_key = NULL;
}
if (test->role == 'c' && (server_rsa_private_key || test->server_authorized_users)){
i_errno = IESERVERONLY;
return -1;
} else if (test->role == 'c' && (test->server_skew_threshold != 0)){
i_errno = IESERVERONLY;
return -1;
} else if (test->role == 'c' && rcv_timeout_flag && test->mode == SENDER){
i_errno = IERVRSONLYRCVTIMEOUT;
return -1;
} else if (test->role == 's' && (server_rsa_private_key || test->server_authorized_users) &&
!(server_rsa_private_key && test->server_authorized_users)) {
i_errno = IESETSERVERAUTH;
return -1;
} else if (test->role == 's' && server_rsa_private_key) {
test->server_rsa_private_key = load_privkey_from_file(server_rsa_private_key);
if (test->server_rsa_private_key == NULL){
iperf_err(test, "%s\n", ERR_error_string(ERR_get_error(), NULL));
i_errno = IESETSERVERAUTH;
return -1;
}
free(server_rsa_private_key);
server_rsa_private_key = NULL;
if(test->server_skew_threshold == 0){
// Set default value for time skew threshold
test->server_skew_threshold=10;
}
}
#endif //HAVE_SSL
// File cannot be transferred using UDP because of the UDP packets header (packet number, etc.)
if(test->role == 'c' && test->diskfile_name != (char*) 0 && test->protocol->id == Pudp) {
i_errno = IEUDPFILETRANSFER;
return -1;
}
if (blksize == 0) {
if (test->protocol->id == Pudp)
blksize = 0; /* try to dynamically determine from MSS */
else if (test->protocol->id == Psctp)
blksize = DEFAULT_SCTP_BLKSIZE;
else
blksize = DEFAULT_TCP_BLKSIZE;
}
if ((test->protocol->id != Pudp && blksize <= 0)
|| blksize > MAX_BLOCKSIZE) {
i_errno = IEBLOCKSIZE;
return -1;
}
if (test->protocol->id == Pudp &&
(blksize > 0 &&
(blksize < MIN_UDP_BLOCKSIZE || blksize > MAX_UDP_BLOCKSIZE))) {
i_errno = IEUDPBLOCKSIZE;
return -1;
}
test->settings->blksize = blksize;
if (!rate_flag)
test->settings->rate = test->protocol->id == Pudp ? UDP_RATE : 0;
/* if no bytes or blocks specified, nor a duration_flag, and we have -F,
** get the file-size as the bytes count to be transferred
*/
if (test->settings->bytes == 0 &&
test->settings->blocks == 0 &&
! duration_flag &&
test->diskfile_name != (char*) 0 &&
test->role == 'c'
){
struct stat st;
if( stat(test->diskfile_name, &st) == 0 ){
iperf_size_t file_bytes = st.st_size;
test->settings->bytes = file_bytes;
if (test->debug)
printf("End condition set to file-size: %"PRIu64" bytes\n", test->settings->bytes);
}
// if failing to read file stat, it should fallback to default duration mode
}
if ((test->settings->bytes != 0 || test->settings->blocks != 0) && ! duration_flag)
test->duration = 0;
/* Disallow specifying multiple test end conditions. The code actually
** works just fine without this prohibition. As soon as any one of the
** three possible end conditions is met, the test ends. So this check
** could be removed if desired.
*/
if ((duration_flag && test->settings->bytes != 0) ||
(duration_flag && test->settings->blocks != 0) ||
(test->settings->bytes != 0 && test->settings->blocks != 0)) {
i_errno = IEENDCONDITIONS;
return -1;
}
/* For subsequent calls to getopt */
#ifdef __APPLE__
optreset = 1;
#endif
optind = 0;
if ((test->role != 'c') && (test->role != 's')) {
i_errno = IENOROLE;
return -1;
}
/* Set Total-rate average interval to multiplicity of State interval */
if (test->settings->bitrate_limit_interval != 0) {
test->settings->bitrate_limit_stats_per_interval =
(test->settings->bitrate_limit_interval <= test->stats_interval ?
1 : round(test->settings->bitrate_limit_interval/test->stats_interval) );
}
/* Show warning if JSON output is used with explicit report format */
if ((test->json_output) && (test->settings->unit_format != 'a')) {
warning("Report format (-f) flag ignored with JSON output (-J)");
}
/* Show warning if JSON output is used with verbose or debug flags */
if (test->json_output && test->verbose) {
warning("Verbose output (-v) may interfere with JSON output (-J)");
}
if (test->json_output && test->debug) {
warning("Debug output (-d) may interfere with JSON output (-J)");
}
return 0;
}
/*
* Open the file specified by test->logfile and set test->outfile to its' FD.
*/
int iperf_open_logfile(struct iperf_test *test)
{
test->outfile = fopen(test->logfile, "a+");
if (test->outfile == NULL) {
i_errno = IELOGFILE;
return -1;
}
return 0;
}
void iperf_close_logfile(struct iperf_test *test)
{
if (test->outfile && test->outfile != stdout) {
fclose(test->outfile);
test->outfile = NULL;
}
}
int
iperf_set_send_state(struct iperf_test *test, signed char state)
{
if (test->ctrl_sck >= 0) {
test->state = state;
if (Nwrite(test->ctrl_sck, (char*) &state, sizeof(state), Ptcp) < 0) {
i_errno = IESENDMESSAGE;
return -1;
}
}
return 0;
}
void
iperf_check_throttle(struct iperf_stream *sp, struct iperf_time *nowP)
{
struct iperf_time temp_time;
double seconds;
uint64_t bits_per_second;
if (sp->test->done || sp->test->settings->rate == 0)
return;
iperf_time_diff(&sp->result->start_time_fixed, nowP, &temp_time);
seconds = iperf_time_in_secs(&temp_time);
bits_per_second = sp->result->bytes_sent * 8 / seconds;
if (bits_per_second < sp->test->settings->rate) {
sp->green_light = 1;
FD_SET(sp->socket, &sp->test->write_set);
} else {
sp->green_light = 0;
FD_CLR(sp->socket, &sp->test->write_set);
}
}
/* Verify that average traffic is not greater than the specified limit */
void
iperf_check_total_rate(struct iperf_test *test, iperf_size_t last_interval_bytes_transferred)
{
double seconds;
uint64_t bits_per_second;
iperf_size_t total_bytes;
int i;
if (test->done || test->settings->bitrate_limit == 0) // Continue only if check should be done
return;
/* Add last inetrval's transferred bytes to the array */
if (++test->bitrate_limit_last_interval_index >= test->settings->bitrate_limit_stats_per_interval)
test->bitrate_limit_last_interval_index = 0;
test->bitrate_limit_intervals_traffic_bytes[test->bitrate_limit_last_interval_index] = last_interval_bytes_transferred;
/* Ensure that enough stats periods passed to allow averaging throughput */
test->bitrate_limit_stats_count += 1;
if (test->bitrate_limit_stats_count < test->settings->bitrate_limit_stats_per_interval)
return;
/* Calculating total bytes traffic to be averaged */
for (total_bytes = 0, i = 0; i < test->settings->bitrate_limit_stats_per_interval; i++) {
total_bytes += test->bitrate_limit_intervals_traffic_bytes[i];
}
seconds = test->stats_interval * test->settings->bitrate_limit_stats_per_interval;
bits_per_second = total_bytes * 8 / seconds;
if (test->debug) {
iperf_printf(test,"Interval %" PRIu64 " - throughput %" PRIu64 " bps (limit %" PRIu64 ")\n", test->bitrate_limit_stats_count, bits_per_second, test->settings->bitrate_limit);
}
if (bits_per_second > test->settings->bitrate_limit) {
if (iperf_get_verbose(test))
iperf_err(test, "Total throughput of %" PRIu64 " bps exceeded %" PRIu64 " bps limit", bits_per_second, test->settings->bitrate_limit);
test->bitrate_limit_exceeded = 1;
}
}
int
iperf_send(struct iperf_test *test, fd_set *write_setP)
{
register int multisend, r, streams_active;
register struct iperf_stream *sp;
struct iperf_time now;
int no_throttle_check;
/* Can we do multisend mode? */
if (test->settings->burst != 0)
multisend = test->settings->burst;
else if (test->settings->rate == 0)
multisend = test->multisend;
else
multisend = 1; /* nope */
/* Should bitrate throttle be checked for every send */
no_throttle_check = test->settings->rate != 0 && test->settings->burst == 0;
for (; multisend > 0; --multisend) {
if (no_throttle_check)
iperf_time_now(&now);
streams_active = 0;
SLIST_FOREACH(sp, &test->streams, streams) {
if ((sp->green_light && sp->sender &&
(write_setP == NULL || FD_ISSET(sp->socket, write_setP)))) {
if (multisend > 1 && test->settings->bytes != 0 && test->bytes_sent >= test->settings->bytes)
break;
if (multisend > 1 && test->settings->blocks != 0 && test->blocks_sent >= test->settings->blocks)
break;
if ((r = sp->snd(sp)) < 0) {
if (r == NET_SOFTERROR)
break;
i_errno = IESTREAMWRITE;
return r;
}
streams_active = 1;
test->bytes_sent += r;
if (!sp->pending_size)
++test->blocks_sent;
if (no_throttle_check)
iperf_check_throttle(sp, &now);
}
}
if (!streams_active)
break;
}
if (!no_throttle_check) { /* Throttle check if was not checked for each send */
iperf_time_now(&now);
SLIST_FOREACH(sp, &test->streams, streams)
if (sp->sender)
iperf_check_throttle(sp, &now);
}
if (write_setP != NULL)
SLIST_FOREACH(sp, &test->streams, streams)
if (FD_ISSET(sp->socket, write_setP))
FD_CLR(sp->socket, write_setP);
return 0;
}
int
iperf_recv(struct iperf_test *test, fd_set *read_setP)
{
int r;
struct iperf_stream *sp;
SLIST_FOREACH(sp, &test->streams, streams) {
if (FD_ISSET(sp->socket, read_setP) && !sp->sender) {
if ((r = sp->rcv(sp)) < 0) {
i_errno = IESTREAMREAD;
return r;
}
test->bytes_received += r;
++test->blocks_received;
FD_CLR(sp->socket, read_setP);
}
}
return 0;
}
int
iperf_init_test(struct iperf_test *test)
{
struct iperf_time now;
struct iperf_stream *sp;
if (test->protocol->init) {
if (test->protocol->init(test) < 0)
return -1;
}
/* Init each stream. */
if (iperf_time_now(&now) < 0) {
i_errno = IEINITTEST;
return -1;
}
SLIST_FOREACH(sp, &test->streams, streams) {
sp->result->start_time = sp->result->start_time_fixed = now;
}
if (test->on_test_start)
test->on_test_start(test);
return 0;
}
static void
send_timer_proc(TimerClientData client_data, struct iperf_time *nowP)
{
struct iperf_stream *sp = client_data.p;
/* All we do here is set or clear the flag saying that this stream may
** be sent to. The actual sending gets done in the send proc, after
** checking the flag.
*/
iperf_check_throttle(sp, nowP);
}
int
iperf_create_send_timers(struct iperf_test * test)
{
struct iperf_time now;
struct iperf_stream *sp;
TimerClientData cd;
if (iperf_time_now(&now) < 0) {
i_errno = IEINITTEST;
return -1;
}
SLIST_FOREACH(sp, &test->streams, streams) {
sp->green_light = 1;
if (test->settings->rate != 0 && sp->sender) {
cd.p = sp;
sp->send_timer = tmr_create(NULL, send_timer_proc, cd, test->settings->pacing_timer, 1);
if (sp->send_timer == NULL) {
i_errno = IEINITTEST;
return -1;
}
}
}
return 0;
}
#if defined(HAVE_SSL)
int test_is_authorized(struct iperf_test *test){
if ( !(test->server_rsa_private_key && test->server_authorized_users)) {
return 0;
}
if (test->settings->authtoken){
char *username = NULL, *password = NULL;
time_t ts;
int rc = decode_auth_setting(test->debug, test->settings->authtoken, test->server_rsa_private_key, &username, &password, &ts);
if (rc) {
return -1;
}
int ret = check_authentication(username, password, ts, test->server_authorized_users, test->server_skew_threshold);
if (ret == 0){
if (test->debug) {
iperf_printf(test, report_authentication_succeeded, username, ts);
}
free(username);
free(password);
return 0;
} else {
if (test->debug) {
iperf_printf(test, report_authentication_failed, ret, username, ts);
}
free(username);
free(password);
return -1;
}
}
return -1;
}
#endif //HAVE_SSL
/**
* iperf_exchange_parameters - handles the param_Exchange part for client
*
*/
int
iperf_exchange_parameters(struct iperf_test *test)
{
int s;
int32_t err;
if (test->role == 'c') {
if (send_parameters(test) < 0)
return -1;
} else {
if (get_parameters(test) < 0)
return -1;
#if defined(HAVE_SSL)
if (test_is_authorized(test) < 0){
if (iperf_set_send_state(test, SERVER_ERROR) != 0)
return -1;
i_errno = IEAUTHTEST;
err = htonl(i_errno);
if (Nwrite(test->ctrl_sck, (char*) &err, sizeof(err), Ptcp) < 0) {
i_errno = IECTRLWRITE;
return -1;
}
return -1;
}
#endif //HAVE_SSL
if ((s = test->protocol->listen(test)) < 0) {
if (iperf_set_send_state(test, SERVER_ERROR) != 0)
return -1;
err = htonl(i_errno);
if (Nwrite(test->ctrl_sck, (char*) &err, sizeof(err), Ptcp) < 0) {
i_errno = IECTRLWRITE;
return -1;
}
err = htonl(errno);
if (Nwrite(test->ctrl_sck, (char*) &err, sizeof(err), Ptcp) < 0) {
i_errno = IECTRLWRITE;
return -1;
}
return -1;
}
FD_SET(s, &test->read_set);
test->max_fd = (s > test->max_fd) ? s : test->max_fd;
test->prot_listener = s;
// Send the control message to create streams and start the test
if (iperf_set_send_state(test, CREATE_STREAMS) != 0)
return -1;
}
return 0;
}
/*************************************************************/
int
iperf_exchange_results(struct iperf_test *test)
{
if (test->role == 'c') {
/* Send results to server. */
if (send_results(test) < 0)
return -1;
/* Get server results. */
if (get_results(test) < 0)
return -1;
} else {
/* Get client results. */
if (get_results(test) < 0)
return -1;
/* Send results to client. */
if (send_results(test) < 0)
return -1;
}
return 0;
}
/*************************************************************/
static int
send_parameters(struct iperf_test *test)
{
int r = 0;
cJSON *j;
j = cJSON_CreateObject();
if (j == NULL) {
i_errno = IESENDPARAMS;
r = -1;
} else {
if (test->protocol->id == Ptcp)
cJSON_AddTrueToObject(j, "tcp");
else if (test->protocol->id == Pudp)
cJSON_AddTrueToObject(j, "udp");
else if (test->protocol->id == Psctp)
cJSON_AddTrueToObject(j, "sctp");
cJSON_AddNumberToObject(j, "omit", test->omit);
if (test->server_affinity != -1)
cJSON_AddNumberToObject(j, "server_affinity", test->server_affinity);
cJSON_AddNumberToObject(j, "time", test->duration);
cJSON_AddNumberToObject(j, "num", test->settings->bytes);
cJSON_AddNumberToObject(j, "blockcount", test->settings->blocks);
if (test->settings->mss)
cJSON_AddNumberToObject(j, "MSS", test->settings->mss);
if (test->no_delay)
cJSON_AddTrueToObject(j, "nodelay");
cJSON_AddNumberToObject(j, "parallel", test->num_streams);
if (test->reverse)
cJSON_AddTrueToObject(j, "reverse");
if (test->bidirectional)
cJSON_AddTrueToObject(j, "bidirectional");
if (test->settings->socket_bufsize)
cJSON_AddNumberToObject(j, "window", test->settings->socket_bufsize);
if (test->settings->blksize)
cJSON_AddNumberToObject(j, "len", test->settings->blksize);
if (test->settings->rate)
cJSON_AddNumberToObject(j, "bandwidth", test->settings->rate);
if (test->settings->fqrate)
cJSON_AddNumberToObject(j, "fqrate", test->settings->fqrate);
if (test->settings->pacing_timer)
cJSON_AddNumberToObject(j, "pacing_timer", test->settings->pacing_timer);
if (test->settings->burst)
cJSON_AddNumberToObject(j, "burst", test->settings->burst);
if (test->settings->tos)
cJSON_AddNumberToObject(j, "TOS", test->settings->tos);
if (test->settings->flowlabel)
cJSON_AddNumberToObject(j, "flowlabel", test->settings->flowlabel);
if (test->title)
cJSON_AddStringToObject(j, "title", test->title);
if (test->extra_data)
cJSON_AddStringToObject(j, "extra_data", test->extra_data);
if (test->congestion)
cJSON_AddStringToObject(j, "congestion", test->congestion);
if (test->congestion_used)
cJSON_AddStringToObject(j, "congestion_used", test->congestion_used);
if (test->get_server_output)
cJSON_AddNumberToObject(j, "get_server_output", iperf_get_test_get_server_output(test));
if (test->udp_counters_64bit)
cJSON_AddNumberToObject(j, "udp_counters_64bit", iperf_get_test_udp_counters_64bit(test));
if (test->repeating_payload)
cJSON_AddNumberToObject(j, "repeating_payload", test->repeating_payload);
if (test->zerocopy)
cJSON_AddNumberToObject(j, "zerocopy", test->zerocopy);
#if defined(HAVE_DONT_FRAGMENT)
if (test->settings->dont_fragment)
cJSON_AddNumberToObject(j, "dont_fragment", test->settings->dont_fragment);
#endif /* HAVE_DONT_FRAGMENT */
#if defined(HAVE_SSL)
/* Send authentication parameters */
if (test->settings->client_username && test->settings->client_password && test->settings->client_rsa_pubkey){
int rc = encode_auth_setting(test->settings->client_username, test->settings->client_password, test->settings->client_rsa_pubkey, &test->settings->authtoken);
if (rc) {
cJSON_Delete(j);
i_errno = IESENDPARAMS;
return -1;
}
cJSON_AddStringToObject(j, "authtoken", test->settings->authtoken);
}
#endif // HAVE_SSL
cJSON_AddStringToObject(j, "client_version", IPERF_VERSION);
if (test->debug) {
char *str = cJSON_Print(j);
printf("send_parameters:\n%s\n", str);
cJSON_free(str);
}
if (JSON_write(test->ctrl_sck, j) < 0) {
i_errno = IESENDPARAMS;
r = -1;
}
cJSON_Delete(j);
}
return r;
}
/*************************************************************/
static int
get_parameters(struct iperf_test *test)
{
int r = 0;
cJSON *j;
cJSON *j_p;
j = JSON_read(test->ctrl_sck);
if (j == NULL) {
i_errno = IERECVPARAMS;
r = -1;
} else {
if (test->debug) {
char *str;
str = cJSON_Print(j);
printf("get_parameters:\n%s\n", str );
cJSON_free(str);
}
if ((j_p = cJSON_GetObjectItem(j, "tcp")) != NULL)
set_protocol(test, Ptcp);
if ((j_p = cJSON_GetObjectItem(j, "udp")) != NULL)
set_protocol(test, Pudp);
if ((j_p = cJSON_GetObjectItem(j, "sctp")) != NULL)
set_protocol(test, Psctp);
if ((j_p = cJSON_GetObjectItem(j, "omit")) != NULL)
test->omit = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "server_affinity")) != NULL)
test->server_affinity = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "time")) != NULL)
test->duration = j_p->valueint;
test->settings->bytes = 0;
if ((j_p = cJSON_GetObjectItem(j, "num")) != NULL)
test->settings->bytes = j_p->valueint;
test->settings->blocks = 0;
if ((j_p = cJSON_GetObjectItem(j, "blockcount")) != NULL)
test->settings->blocks = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "MSS")) != NULL)
test->settings->mss = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "nodelay")) != NULL)
test->no_delay = 1;
if ((j_p = cJSON_GetObjectItem(j, "parallel")) != NULL)
test->num_streams = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "reverse")) != NULL)
iperf_set_test_reverse(test, 1);
if ((j_p = cJSON_GetObjectItem(j, "bidirectional")) != NULL)
iperf_set_test_bidirectional(test, 1);
if ((j_p = cJSON_GetObjectItem(j, "window")) != NULL)
test->settings->socket_bufsize = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "len")) != NULL)
test->settings->blksize = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "bandwidth")) != NULL)
test->settings->rate = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "fqrate")) != NULL)
test->settings->fqrate = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "pacing_timer")) != NULL)
test->settings->pacing_timer = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "burst")) != NULL)
test->settings->burst = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "TOS")) != NULL)
test->settings->tos = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "flowlabel")) != NULL)
test->settings->flowlabel = j_p->valueint;
if ((j_p = cJSON_GetObjectItem(j, "title")) != NULL)
test->title = strdup(j_p->valuestring);
if ((j_p = cJSON_GetObjectItem(j, "extra_data")) != NULL)
test->extra_data = strdup(j_p->valuestring);
if ((j_p = cJSON_GetObjectItem(j, "congestion")) != NULL)
test->congestion = strdup(j_p->valuestring);
if ((j_p = cJSON_GetObjectItem(j, "congestion_used")) != NULL)
test->congestion_used = strdup(j_p->valuestring);
if ((j_p = cJSON_GetObjectItem(j, "get_server_output")) != NULL)
iperf_set_test_get_server_output(test, 1);
if ((j_p = cJSON_GetObjectItem(j, "udp_counters_64bit")) != NULL)
iperf_set_test_udp_counters_64bit(test, 1);
if ((j_p = cJSON_GetObjectItem(j, "repeating_payload")) != NULL)
test->repeating_payload = 1;
if ((j_p = cJSON_GetObjectItem(j, "zerocopy")) != NULL)
test->zerocopy = j_p->valueint;
#if defined(HAVE_DONT_FRAGMENT)
if ((j_p = cJSON_GetObjectItem(j, "dont_fragment")) != NULL)
test->settings->dont_fragment = j_p->valueint;
#endif /* HAVE_DONT_FRAGMENT */
#if defined(HAVE_SSL)
if ((j_p = cJSON_GetObjectItem(j, "authtoken")) != NULL)
test->settings->authtoken = strdup(j_p->valuestring);
#endif //HAVE_SSL
if (test->mode && test->protocol->id == Ptcp && has_tcpinfo_retransmits())
test->sender_has_retransmits = 1;
if (test->settings->rate)
cJSON_AddNumberToObject(test->json_start, "target_bitrate", test->settings->rate);
cJSON_Delete(j);
}
return r;
}
/*************************************************************/
static int
send_results(struct iperf_test *test)
{
int r = 0;
cJSON *j;
cJSON *j_streams;
struct iperf_stream *sp;
cJSON *j_stream;
int sender_has_retransmits;
iperf_size_t bytes_transferred;
int retransmits;
struct iperf_time temp_time;
double start_time, end_time;
j = cJSON_CreateObject();
if (j == NULL) {
i_errno = IEPACKAGERESULTS;
r = -1;
} else {
cJSON_AddNumberToObject(j, "cpu_util_total", test->cpu_util[0]);
cJSON_AddNumberToObject(j, "cpu_util_user", test->cpu_util[1]);
cJSON_AddNumberToObject(j, "cpu_util_system", test->cpu_util[2]);
if ( test->mode == RECEIVER )
sender_has_retransmits = -1;
else
sender_has_retransmits = test->sender_has_retransmits;
cJSON_AddNumberToObject(j, "sender_has_retransmits", sender_has_retransmits);
if ( test->congestion_used ) {
cJSON_AddStringToObject(j, "congestion_used", test->congestion_used);
}
/* If on the server and sending server output, then do this */
if (test->role == 's' && test->get_server_output) {
if (test->json_output) {
/* Add JSON output */
cJSON_AddItemReferenceToObject(j, "server_output_json", test->json_top);
}
else {
/* Add textual output */
size_t buflen = 0;
/* Figure out how much room we need to hold the complete output string */
struct iperf_textline *t;
TAILQ_FOREACH(t, &(test->server_output_list), textlineentries) {
buflen += strlen(t->line);
}
/* Allocate and build it up from the component lines */
char *output = calloc(buflen + 1, 1);
TAILQ_FOREACH(t, &(test->server_output_list), textlineentries) {
strncat(output, t->line, buflen);
buflen -= strlen(t->line);
}
cJSON_AddStringToObject(j, "server_output_text", output);
free(output);
}
}
j_streams = cJSON_CreateArray();
if (j_streams == NULL) {
i_errno = IEPACKAGERESULTS;
r = -1;
} else {
cJSON_AddItemToObject(j, "streams", j_streams);
SLIST_FOREACH(sp, &test->streams, streams) {
j_stream = cJSON_CreateObject();
if (j_stream == NULL) {
i_errno = IEPACKAGERESULTS;
r = -1;
} else {
cJSON_AddItemToArray(j_streams, j_stream);
bytes_transferred = sp->sender ? (sp->result->bytes_sent - sp->result->bytes_sent_omit) : sp->result->bytes_received;
retransmits = (sp->sender && test->sender_has_retransmits) ? sp->result->stream_retrans : -1;
cJSON_AddNumberToObject(j_stream, "id", sp->id);
cJSON_AddNumberToObject(j_stream, "bytes", bytes_transferred);
cJSON_AddNumberToObject(j_stream, "retransmits", retransmits);
cJSON_AddNumberToObject(j_stream, "jitter", sp->jitter);
cJSON_AddNumberToObject(j_stream, "errors", sp->cnt_error);
cJSON_AddNumberToObject(j_stream, "omitted_errors", sp->omitted_cnt_error);
cJSON_AddNumberToObject(j_stream, "packets", sp->packet_count);
cJSON_AddNumberToObject(j_stream, "omitted_packets", sp->omitted_packet_count);
iperf_time_diff(&sp->result->start_time, &sp->result->start_time, &temp_time);
start_time = iperf_time_in_secs(&temp_time);
iperf_time_diff(&sp->result->start_time, &sp->result->end_time, &temp_time);
end_time = iperf_time_in_secs(&temp_time);
cJSON_AddNumberToObject(j_stream, "start_time", start_time);
cJSON_AddNumberToObject(j_stream, "end_time", end_time);
}
}
if (r == 0 && test->debug) {
char *str = cJSON_Print(j);
printf("send_results\n%s\n", str);
cJSON_free(str);
}
if (r == 0 && JSON_write(test->ctrl_sck, j) < 0) {
i_errno = IESENDRESULTS;
r = -1;
}
}
cJSON_Delete(j);
}
return r;
}
/*************************************************************/
static int
get_results(struct iperf_test *test)
{
int r = 0;
cJSON *j;
cJSON *j_cpu_util_total;
cJSON *j_cpu_util_user;
cJSON *j_cpu_util_system;
cJSON *j_remote_congestion_used;
cJSON *j_sender_has_retransmits;
int result_has_retransmits;
cJSON *j_streams;
int n, i;
cJSON *j_stream;
cJSON *j_id;
cJSON *j_bytes;
cJSON *j_retransmits;
cJSON *j_jitter;
cJSON *j_errors;
cJSON *j_omitted_errors;
cJSON *j_packets;
cJSON *j_omitted_packets;
cJSON *j_server_output;
cJSON *j_start_time, *j_end_time;
int sid;
int64_t cerror, pcount, omitted_cerror, omitted_pcount;
double jitter;
iperf_size_t bytes_transferred;
int retransmits;
struct iperf_stream *sp;
j = JSON_read(test->ctrl_sck);
if (j == NULL) {
i_errno = IERECVRESULTS;
r = -1;
} else {
j_cpu_util_total = cJSON_GetObjectItem(j, "cpu_util_total");
j_cpu_util_user = cJSON_GetObjectItem(j, "cpu_util_user");
j_cpu_util_system = cJSON_GetObjectItem(j, "cpu_util_system");
j_sender_has_retransmits = cJSON_GetObjectItem(j, "sender_has_retransmits");
if (j_cpu_util_total == NULL || j_cpu_util_user == NULL || j_cpu_util_system == NULL || j_sender_has_retransmits == NULL) {
i_errno = IERECVRESULTS;
r = -1;
} else {
if (test->debug) {
char *str = cJSON_Print(j);
printf("get_results\n%s\n", str);
cJSON_free(str);
}
test->remote_cpu_util[0] = j_cpu_util_total->valuedouble;
test->remote_cpu_util[1] = j_cpu_util_user->valuedouble;
test->remote_cpu_util[2] = j_cpu_util_system->valuedouble;
result_has_retransmits = j_sender_has_retransmits->valueint;
if ( test->mode == RECEIVER ) {
test->sender_has_retransmits = result_has_retransmits;
test->other_side_has_retransmits = 0;
}
else if ( test->mode == BIDIRECTIONAL )
test->other_side_has_retransmits = result_has_retransmits;
j_streams = cJSON_GetObjectItem(j, "streams");
if (j_streams == NULL) {
i_errno = IERECVRESULTS;
r = -1;
} else {
n = cJSON_GetArraySize(j_streams);
for (i=0; i<n; ++i) {
j_stream = cJSON_GetArrayItem(j_streams, i);
if (j_stream == NULL) {
i_errno = IERECVRESULTS;
r = -1;
} else {
j_id = cJSON_GetObjectItem(j_stream, "id");
j_bytes = cJSON_GetObjectItem(j_stream, "bytes");
j_retransmits = cJSON_GetObjectItem(j_stream, "retransmits");
j_jitter = cJSON_GetObjectItem(j_stream, "jitter");
j_errors = cJSON_GetObjectItem(j_stream, "errors");
j_omitted_errors = cJSON_GetObjectItem(j_stream, "omitted_errors");
j_packets = cJSON_GetObjectItem(j_stream, "packets");
j_omitted_packets = cJSON_GetObjectItem(j_stream, "omitted_packets");
j_start_time = cJSON_GetObjectItem(j_stream, "start_time");
j_end_time = cJSON_GetObjectItem(j_stream, "end_time");
if (j_id == NULL || j_bytes == NULL || j_retransmits == NULL || j_jitter == NULL || j_errors == NULL || j_packets == NULL) {
i_errno = IERECVRESULTS;
r = -1;
} else if ( (j_omitted_errors == NULL && j_omitted_packets != NULL) || (j_omitted_errors != NULL && j_omitted_packets == NULL) ) {
/* For backward compatibility allow to not receive "omitted" statistcs */
i_errno = IERECVRESULTS;
r = -1;
} else {
sid = j_id->valueint;
bytes_transferred = j_bytes->valueint;
retransmits = j_retransmits->valueint;
jitter = j_jitter->valuedouble;
cerror = j_errors->valueint;
pcount = j_packets->valueint;
if (j_omitted_packets != NULL) {
omitted_cerror = j_omitted_errors->valueint;
omitted_pcount = j_omitted_packets->valueint;
}
SLIST_FOREACH(sp, &test->streams, streams)
if (sp->id == sid) break;
if (sp == NULL) {
i_errno = IESTREAMID;
r = -1;
} else {
if (sp->sender) {
sp->jitter = jitter;
sp->cnt_error = cerror;
sp->peer_packet_count = pcount;
sp->result->bytes_received = bytes_transferred;
if (j_omitted_packets != NULL) {
sp->omitted_cnt_error = omitted_cerror;
sp->peer_omitted_packet_count = omitted_pcount;
} else {
sp->peer_omitted_packet_count = sp->omitted_packet_count;
if (sp->peer_omitted_packet_count > 0) {
/* -1 indicates unknown error count since it includes the omitted count */
sp->omitted_cnt_error = (sp->cnt_error > 0) ? -1 : 0;
} else {
sp->omitted_cnt_error = sp->cnt_error;
}
}
/*
* We have to handle the possibility that
* start_time and end_time might not be
* available; this is the case for older (pre-3.2)
* servers.
*
* We need to have result structure members to hold
* the both sides' start_time and end_time.
*/
if (j_start_time && j_end_time) {
sp->result->receiver_time = j_end_time->valuedouble - j_start_time->valuedouble;
}
else {
sp->result->receiver_time = 0.0;
}
} else {
sp->peer_packet_count = pcount;
sp->result->bytes_sent = bytes_transferred;
sp->result->stream_retrans = retransmits;
if (j_omitted_packets != NULL) {
sp->peer_omitted_packet_count = omitted_pcount;
} else {
sp->peer_omitted_packet_count = sp->peer_packet_count;
}
if (j_start_time && j_end_time) {
sp->result->sender_time = j_end_time->valuedouble - j_start_time->valuedouble;
}
else {
sp->result->sender_time = 0.0;
}
}
}
}
}
}
/*
* If we're the client and we're supposed to get remote results,
* look them up and process accordingly.
*/
if (test->role == 'c' && iperf_get_test_get_server_output(test)) {
/* Look for JSON. If we find it, grab the object so it doesn't get deleted. */
j_server_output = cJSON_DetachItemFromObject(j, "server_output_json");
if (j_server_output != NULL) {
test->json_server_output = j_server_output;
}
else {
/* No JSON, look for textual output. Make a copy of the text for later. */
j_server_output = cJSON_GetObjectItem(j, "server_output_text");
if (j_server_output != NULL) {
test->server_output_text = strdup(j_server_output->valuestring);
}
}
}
}
}
j_remote_congestion_used = cJSON_GetObjectItem(j, "congestion_used");
if (j_remote_congestion_used != NULL) {
test->remote_congestion_used = strdup(j_remote_congestion_used->valuestring);
}
cJSON_Delete(j);
}
return r;
}
/*************************************************************/
static int
JSON_write(int fd, cJSON *json)
{
uint32_t hsize, nsize;
char *str;
int r = 0;
str = cJSON_PrintUnformatted(json);
if (str == NULL)
r = -1;
else {
hsize = strlen(str);
nsize = htonl(hsize);
if (Nwrite(fd, (char*) &nsize, sizeof(nsize), Ptcp) < 0)
r = -1;
else {
if (Nwrite(fd, str, hsize, Ptcp) < 0)
r = -1;
}
cJSON_free(str);
}
return r;
}
/*************************************************************/
static cJSON *
JSON_read(int fd)
{
uint32_t hsize, nsize;
size_t strsize;
char *str;
cJSON *json = NULL;
int rc;
/*
* Read a four-byte integer, which is the length of the JSON to follow.
* Then read the JSON into a buffer and parse it. Return a parsed JSON
* structure, NULL if there was an error.
*/
if (Nread(fd, (char*) &nsize, sizeof(nsize), Ptcp) >= 0) {
hsize = ntohl(nsize);
/* Allocate a buffer to hold the JSON */
strsize = hsize + 1; /* +1 for trailing NULL */
if (strsize) {
str = (char *) calloc(sizeof(char), strsize);
if (str != NULL) {
rc = Nread(fd, str, hsize, Ptcp);
if (rc >= 0) {
/*
* We should be reading in the number of bytes corresponding to the
* length in that 4-byte integer. If we don't the socket might have
* prematurely closed. Only do the JSON parsing if we got the
* correct number of bytes.
*/
if (rc == hsize) {
json = cJSON_Parse(str);
}
else {
printf("WARNING: Size of data read does not correspond to offered length\n");
}
}
}
free(str);
}
else {
printf("WARNING: Data length overflow\n");
}
}
return json;
}
/*************************************************************/
/**
* 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 *irp;
irp = (struct iperf_interval_results *) malloc(sizeof(struct iperf_interval_results));
memcpy(irp, new, sizeof(struct iperf_interval_results));
TAILQ_INSERT_TAIL(&rp->interval_results, irp, irlistentries);
}
/************************************************************/
/**
* connect_msg -- displays connection message
* denoting sender/receiver details
*
*/
void
connect_msg(struct iperf_stream *sp)
{
char ipl[INET6_ADDRSTRLEN], ipr[INET6_ADDRSTRLEN];
int lport, rport;
if (getsockdomain(sp->socket) == AF_INET) {
inet_ntop(AF_INET, (void *) &((struct sockaddr_in *) &sp->local_addr)->sin_addr, ipl, sizeof(ipl));
mapped_v4_to_regular_v4(ipl);
inet_ntop(AF_INET, (void *) &((struct sockaddr_in *) &sp->remote_addr)->sin_addr, ipr, sizeof(ipr));
mapped_v4_to_regular_v4(ipr);
lport = ntohs(((struct sockaddr_in *) &sp->local_addr)->sin_port);
rport = ntohs(((struct sockaddr_in *) &sp->remote_addr)->sin_port);
} else {
inet_ntop(AF_INET6, (void *) &((struct sockaddr_in6 *) &sp->local_addr)->sin6_addr, ipl, sizeof(ipl));
mapped_v4_to_regular_v4(ipl);
inet_ntop(AF_INET6, (void *) &((struct sockaddr_in6 *) &sp->remote_addr)->sin6_addr, ipr, sizeof(ipr));
mapped_v4_to_regular_v4(ipr);
lport = ntohs(((struct sockaddr_in6 *) &sp->local_addr)->sin6_port);
rport = ntohs(((struct sockaddr_in6 *) &sp->remote_addr)->sin6_port);
}
if (sp->test->json_output)
cJSON_AddItemToArray(sp->test->json_connected, iperf_json_printf("socket: %d local_host: %s local_port: %d remote_host: %s remote_port: %d", (int64_t) sp->socket, ipl, (int64_t) lport, ipr, (int64_t) rport));
else
iperf_printf(sp->test, report_connected, sp->socket, ipl, lport, ipr, rport);
}
/**************************************************************************/
struct iperf_test *
iperf_new_test()
{
struct iperf_test *test;
test = (struct iperf_test *) malloc(sizeof(struct iperf_test));
if (!test) {
i_errno = IENEWTEST;
return NULL;
}
/* initialize everything to zero */
memset(test, 0, sizeof(struct iperf_test));
test->settings = (struct iperf_settings *) malloc(sizeof(struct iperf_settings));
if (!test->settings) {
free(test);
i_errno = IENEWTEST;
return NULL;
}
memset(test->settings, 0, sizeof(struct iperf_settings));
test->bitrate_limit_intervals_traffic_bytes = (iperf_size_t *) malloc(sizeof(iperf_size_t) * MAX_INTERVAL);
if (!test->bitrate_limit_intervals_traffic_bytes) {
free(test->settings);
free(test);
i_errno = IENEWTEST;
return NULL;
}
memset(test->bitrate_limit_intervals_traffic_bytes, 0, sizeof(sizeof(iperf_size_t) * MAX_INTERVAL));
/* By default all output goes to stdout */
test->outfile = stdout;
return test;
}
/**************************************************************************/
struct protocol *
protocol_new(void)
{
struct protocol *proto;
proto = malloc(sizeof(struct protocol));
if(!proto) {
return NULL;
}
memset(proto, 0, sizeof(struct protocol));
return proto;
}
void
protocol_free(struct protocol *proto)
{
free(proto);
}
/**************************************************************************/
int
iperf_defaults(struct iperf_test *testp)
{
struct protocol *tcp, *udp;
#if defined(HAVE_SCTP_H)
struct protocol *sctp;
#endif /* HAVE_SCTP_H */
testp->omit = OMIT;
testp->duration = DURATION;
testp->diskfile_name = (char*) 0;
testp->affinity = -1;
testp->server_affinity = -1;
TAILQ_INIT(&testp->xbind_addrs);
#if defined(HAVE_CPUSET_SETAFFINITY)
CPU_ZERO(&testp->cpumask);
#endif /* HAVE_CPUSET_SETAFFINITY */
testp->title = NULL;
testp->extra_data = NULL;
testp->congestion = NULL;
testp->congestion_used = NULL;
testp->remote_congestion_used = NULL;
testp->server_port = PORT;
testp->ctrl_sck = -1;
testp->listener = -1;
testp->prot_listener = -1;
testp->other_side_has_retransmits = 0;
testp->stats_callback = iperf_stats_callback;
testp->reporter_callback = iperf_reporter_callback;
testp->stats_interval = testp->reporter_interval = 1;
testp->num_streams = 1;
testp->settings->domain = AF_UNSPEC;
testp->settings->unit_format = 'a';
testp->settings->socket_bufsize = 0; /* use autotuning */
testp->settings->blksize = DEFAULT_TCP_BLKSIZE;
testp->settings->rate = 0;
testp->settings->bitrate_limit = 0;
testp->settings->bitrate_limit_interval = 5;
testp->settings->bitrate_limit_stats_per_interval = 0;
testp->settings->fqrate = 0;
testp->settings->pacing_timer = DEFAULT_PACING_TIMER;
testp->settings->burst = 0;
testp->settings->mss = 0;
testp->settings->bytes = 0;
testp->settings->blocks = 0;
testp->settings->connect_timeout = -1;
testp->settings->rcv_timeout.secs = DEFAULT_NO_MSG_RCVD_TIMEOUT / SEC_TO_mS;
testp->settings->rcv_timeout.usecs = (DEFAULT_NO_MSG_RCVD_TIMEOUT % SEC_TO_mS) * mS_TO_US;
testp->zerocopy = 0;
memset(testp->cookie, 0, COOKIE_SIZE);
testp->multisend = 10; /* arbitrary */
/* Set up protocol list */
SLIST_INIT(&testp->streams);
SLIST_INIT(&testp->protocols);
tcp = protocol_new();
if (!tcp)
return -1;
tcp->id = Ptcp;
tcp->name = "TCP";
tcp->accept = iperf_tcp_accept;
tcp->listen = iperf_tcp_listen;
tcp->connect = iperf_tcp_connect;
tcp->send = iperf_tcp_send;
tcp->recv = iperf_tcp_recv;
tcp->init = NULL;
SLIST_INSERT_HEAD(&testp->protocols, tcp, protocols);
udp = protocol_new();
if (!udp) {
protocol_free(tcp);
return -1;
}
udp->id = Pudp;
udp->name = "UDP";
udp->accept = iperf_udp_accept;
udp->listen = iperf_udp_listen;
udp->connect = iperf_udp_connect;
udp->send = iperf_udp_send;
udp->recv = iperf_udp_recv;
udp->init = iperf_udp_init;
SLIST_INSERT_AFTER(tcp, udp, protocols);
set_protocol(testp, Ptcp);
#if defined(HAVE_SCTP_H)
sctp = protocol_new();
if (!sctp) {
protocol_free(tcp);
protocol_free(udp);
return -1;
}
sctp->id = Psctp;
sctp->name = "SCTP";
sctp->accept = iperf_sctp_accept;
sctp->listen = iperf_sctp_listen;
sctp->connect = iperf_sctp_connect;
sctp->send = iperf_sctp_send;
sctp->recv = iperf_sctp_recv;
sctp->init = iperf_sctp_init;
SLIST_INSERT_AFTER(udp, sctp, protocols);
#endif /* HAVE_SCTP_H */
testp->on_new_stream = iperf_on_new_stream;
testp->on_test_start = iperf_on_test_start;
testp->on_connect = iperf_on_connect;
testp->on_test_finish = iperf_on_test_finish;
TAILQ_INIT(&testp->server_output_list);
return 0;
}
/**************************************************************************/
void
iperf_free_test(struct iperf_test *test)
{
struct protocol *prot;
struct iperf_stream *sp;
/* Free streams */
while (!SLIST_EMPTY(&test->streams)) {
sp = SLIST_FIRST(&test->streams);
SLIST_REMOVE_HEAD(&test->streams, streams);
iperf_free_stream(sp);
}
if (test->server_hostname)
free(test->server_hostname);
if (test->tmp_template)
free(test->tmp_template);
if (test->bind_address)
free(test->bind_address);
if (test->bind_dev)
free(test->bind_dev);
if (!TAILQ_EMPTY(&test->xbind_addrs)) {
struct xbind_entry *xbe;
while (!TAILQ_EMPTY(&test->xbind_addrs)) {
xbe = TAILQ_FIRST(&test->xbind_addrs);
TAILQ_REMOVE(&test->xbind_addrs, xbe, link);
if (xbe->ai)
freeaddrinfo(xbe->ai);
free(xbe->name);
free(xbe);
}
}
#if defined(HAVE_SSL)
if (test->server_rsa_private_key)
EVP_PKEY_free(test->server_rsa_private_key);
test->server_rsa_private_key = NULL;
free(test->settings->authtoken);
test->settings->authtoken = NULL;
free(test->settings->client_username);
test->settings->client_username = NULL;
free(test->settings->client_password);
test->settings->client_password = NULL;
if (test->settings->client_rsa_pubkey)
EVP_PKEY_free(test->settings->client_rsa_pubkey);
test->settings->client_rsa_pubkey = NULL;
#endif /* HAVE_SSL */
if (test->settings)
free(test->settings);
if (test->title)
free(test->title);
if (test->extra_data)
free(test->extra_data);
if (test->congestion)
free(test->congestion);
if (test->congestion_used)
free(test->congestion_used);
if (test->remote_congestion_used)
free(test->remote_congestion_used);
if (test->timestamp_format)
free(test->timestamp_format);
if (test->omit_timer != NULL)
tmr_cancel(test->omit_timer);
if (test->timer != NULL)
tmr_cancel(test->timer);
if (test->stats_timer != NULL)
tmr_cancel(test->stats_timer);
if (test->reporter_timer != NULL)
tmr_cancel(test->reporter_timer);
/* Free protocol list */
while (!SLIST_EMPTY(&test->protocols)) {
prot = SLIST_FIRST(&test->protocols);
SLIST_REMOVE_HEAD(&test->protocols, protocols);
free(prot);
}
if (test->logfile) {
free(test->logfile);
test->logfile = NULL;
iperf_close_logfile(test);
}
if (test->server_output_text) {
free(test->server_output_text);
test->server_output_text = NULL;
}
if (test->json_output_string) {
free(test->json_output_string);
test->json_output_string = NULL;
}
/* Free output line buffers, if any (on the server only) */
struct iperf_textline *t;
while (!TAILQ_EMPTY(&test->server_output_list)) {
t = TAILQ_FIRST(&test->server_output_list);
TAILQ_REMOVE(&test->server_output_list, t, textlineentries);
free(t->line);
free(t);
}
/* sctp_bindx: do not free the arguments, only the resolver results */
if (!TAILQ_EMPTY(&test->xbind_addrs)) {
struct xbind_entry *xbe;
TAILQ_FOREACH(xbe, &test->xbind_addrs, link) {
if (xbe->ai) {
freeaddrinfo(xbe->ai);
xbe->ai = NULL;
}
}
}
/* Free interval's traffic array for average rate calculations */
if (test->bitrate_limit_intervals_traffic_bytes != NULL)
free(test->bitrate_limit_intervals_traffic_bytes);
/* XXX: Why are we setting these values to NULL? */
// test->streams = NULL;
test->stats_callback = NULL;
test->reporter_callback = NULL;
free(test);
}
void
iperf_reset_test(struct iperf_test *test)
{
struct iperf_stream *sp;
int i;
iperf_close_logfile(test);
/* Free streams */
while (!SLIST_EMPTY(&test->streams)) {
sp = SLIST_FIRST(&test->streams);
SLIST_REMOVE_HEAD(&test->streams, streams);
iperf_free_stream(sp);
}
if (test->omit_timer != NULL) {
tmr_cancel(test->omit_timer);
test->omit_timer = NULL;
}
if (test->timer != NULL) {
tmr_cancel(test->timer);
test->timer = NULL;
}
if (test->stats_timer != NULL) {
tmr_cancel(test->stats_timer);
test->stats_timer = NULL;
}
if (test->reporter_timer != NULL) {
tmr_cancel(test->reporter_timer);
test->reporter_timer = NULL;
}
test->done = 0;
SLIST_INIT(&test->streams);
if (test->remote_congestion_used)
free(test->remote_congestion_used);
test->remote_congestion_used = NULL;
test->role = 's';
test->mode = RECEIVER;
test->sender_has_retransmits = 0;
set_protocol(test, Ptcp);
test->omit = OMIT;
test->duration = DURATION;
test->server_affinity = -1;
#if defined(HAVE_CPUSET_SETAFFINITY)
CPU_ZERO(&test->cpumask);
#endif /* HAVE_CPUSET_SETAFFINITY */
test->state = 0;
test->ctrl_sck = -1;
test->listener = -1;
test->prot_listener = -1;
test->bytes_sent = 0;
test->blocks_sent = 0;
test->bytes_received = 0;
test->blocks_received = 0;
test->other_side_has_retransmits = 0;
test->bitrate_limit_stats_count = 0;
test->bitrate_limit_last_interval_index = 0;
test->bitrate_limit_exceeded = 0;
for (i = 0; i < MAX_INTERVAL; i++)
test->bitrate_limit_intervals_traffic_bytes[i] = 0;
test->reverse = 0;
test->bidirectional = 0;
test->no_delay = 0;
FD_ZERO(&test->read_set);
FD_ZERO(&test->write_set);
test->num_streams = 1;
test->settings->socket_bufsize = 0;
test->settings->blksize = DEFAULT_TCP_BLKSIZE;
test->settings->rate = 0;
test->settings->burst = 0;
test->settings->mss = 0;
test->settings->tos = 0;
test->settings->dont_fragment = 0;
test->zerocopy = 0;
#if defined(HAVE_SSL)
if (test->settings->authtoken) {
free(test->settings->authtoken);
test->settings->authtoken = NULL;
}
if (test->settings->client_username) {
free(test->settings->client_username);
test->settings->client_username = NULL;
}
if (test->settings->client_password) {
free(test->settings->client_password);
test->settings->client_password = NULL;
}
if (test->settings->client_rsa_pubkey) {
EVP_PKEY_free(test->settings->client_rsa_pubkey);
test->settings->client_rsa_pubkey = NULL;
}
#endif /* HAVE_SSL */
memset(test->cookie, 0, COOKIE_SIZE);
test->multisend = 10; /* arbitrary */
test->udp_counters_64bit = 0;
if (test->title) {
free(test->title);
test->title = NULL;
}
if (test->extra_data) {
free(test->extra_data);
test->extra_data = NULL;
}
/* Free output line buffers, if any (on the server only) */
struct iperf_textline *t;
while (!TAILQ_EMPTY(&test->server_output_list)) {
t = TAILQ_FIRST(&test->server_output_list);
TAILQ_REMOVE(&test->server_output_list, t, textlineentries);
free(t->line);
free(t);
}
}
/* Reset all of a test's stats back to zero. Called when the omitting
** period is over.
*/
void
iperf_reset_stats(struct iperf_test *test)
{
struct iperf_time now;
struct iperf_stream *sp;
struct iperf_stream_result *rp;
test->bytes_sent = 0;
test->blocks_sent = 0;
iperf_time_now(&now);
SLIST_FOREACH(sp, &test->streams, streams) {
sp->omitted_packet_count = sp->packet_count;
sp->omitted_cnt_error = sp->cnt_error;
sp->omitted_outoforder_packets = sp->outoforder_packets;
sp->jitter = 0;
rp = sp->result;
rp->bytes_sent_omit = rp->bytes_sent;
rp->bytes_received = 0;
rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0;
if (test->sender_has_retransmits == 1) {
struct iperf_interval_results ir; /* temporary results structure */
save_tcpinfo(sp, &ir);
rp->stream_prev_total_retrans = get_total_retransmits(&ir);
}
rp->stream_retrans = 0;
rp->start_time = now;
}
}
/**************************************************************************/
/**
* Gather statistics during a test.
* This function works for both the client and server side.
*/
void
iperf_stats_callback(struct iperf_test *test)
{
struct iperf_stream *sp;
struct iperf_stream_result *rp = NULL;
struct iperf_interval_results *irp, temp;
struct iperf_time temp_time;
iperf_size_t total_interval_bytes_transferred = 0;
temp.omitted = test->omitting;
SLIST_FOREACH(sp, &test->streams, streams) {
rp = sp->result;
temp.bytes_transferred = sp->sender ? rp->bytes_sent_this_interval : rp->bytes_received_this_interval;
// Total bytes transferred this interval
total_interval_bytes_transferred += rp->bytes_sent_this_interval + rp->bytes_received_this_interval;
irp = TAILQ_LAST(&rp->interval_results, irlisthead);
/* result->end_time contains timestamp of previous interval */
if ( irp != NULL ) /* not the 1st interval */
memcpy(&temp.interval_start_time, &rp->end_time, sizeof(struct iperf_time));
else /* or use timestamp from beginning */
memcpy(&temp.interval_start_time, &rp->start_time, sizeof(struct iperf_time));
/* now save time of end of this interval */
iperf_time_now(&rp->end_time);
memcpy(&temp.interval_end_time, &rp->end_time, sizeof(struct iperf_time));
iperf_time_diff(&temp.interval_start_time, &temp.interval_end_time, &temp_time);
temp.interval_duration = iperf_time_in_secs(&temp_time);
if (test->protocol->id == Ptcp) {
if ( has_tcpinfo()) {
save_tcpinfo(sp, &temp);
if (test->sender_has_retransmits == 1) {
long total_retrans = get_total_retransmits(&temp);
temp.interval_retrans = total_retrans - rp->stream_prev_total_retrans;
rp->stream_retrans += temp.interval_retrans;
rp->stream_prev_total_retrans = total_retrans;
temp.snd_cwnd = get_snd_cwnd(&temp);
if (temp.snd_cwnd > rp->stream_max_snd_cwnd) {
rp->stream_max_snd_cwnd = temp.snd_cwnd;
}
temp.snd_wnd = get_snd_wnd(&temp);
if (temp.snd_wnd > rp->stream_max_snd_wnd) {
rp->stream_max_snd_wnd = temp.snd_wnd;
}
temp.rtt = get_rtt(&temp);
if (temp.rtt > rp->stream_max_rtt) {
rp->stream_max_rtt = temp.rtt;
}
if (rp->stream_min_rtt == 0 ||
temp.rtt < rp->stream_min_rtt) {
rp->stream_min_rtt = temp.rtt;
}
rp->stream_sum_rtt += temp.rtt;
rp->stream_count_rtt++;
temp.rttvar = get_rttvar(&temp);
temp.pmtu = get_pmtu(&temp);
}
}
} else {
if (irp == NULL) {
temp.interval_packet_count = sp->packet_count;
temp.interval_outoforder_packets = sp->outoforder_packets;
temp.interval_cnt_error = sp->cnt_error;
} else {
temp.interval_packet_count = sp->packet_count - irp->packet_count;
temp.interval_outoforder_packets = sp->outoforder_packets - irp->outoforder_packets;
temp.interval_cnt_error = sp->cnt_error - irp->cnt_error;
}
temp.packet_count = sp->packet_count;
temp.jitter = sp->jitter;
temp.outoforder_packets = sp->outoforder_packets;
temp.cnt_error = sp->cnt_error;
}
add_to_interval_list(rp, &temp);
rp->bytes_sent_this_interval = rp->bytes_received_this_interval = 0;
}
/* Verify that total server's throughput is not above specified limit */
if (test->role == 's') {
iperf_check_total_rate(test, total_interval_bytes_transferred);
}
}
/**
* Print intermediate results during a test (interval report).
* Uses print_interval_results to print the results for each stream,
* then prints an interval summary for all streams in this
* interval.
*/
static void
iperf_print_intermediate(struct iperf_test *test)
{
struct iperf_stream *sp = NULL;
struct iperf_interval_results *irp;
struct iperf_time temp_time;
cJSON *json_interval;
cJSON *json_interval_streams;
int lower_mode, upper_mode;
int current_mode;
/*
* Due to timing oddities, there can be cases, especially on the
* server side, where at the end of a test there is a fairly short
* interval with no data transferred. This could caused by
* the control and data flows sharing the same path in the network,
* and having the control messages for stopping the test being
* queued behind the data packets.
*
* We'd like to try to omit that last interval when it happens, to
* avoid cluttering data and output with useless stuff.
* So we're going to try to ignore very short intervals (less than
* 10% of the interval time) that have no data.
*/
int interval_ok = 0;
SLIST_FOREACH(sp, &test->streams, streams) {
irp = TAILQ_LAST(&sp->result->interval_results, irlisthead);
if (irp) {
iperf_time_diff(&irp->interval_start_time, &irp->interval_end_time, &temp_time);
double interval_len = iperf_time_in_secs(&temp_time);
if (test->debug) {
printf("interval_len %f bytes_transferred %" PRIu64 "\n", interval_len, irp->bytes_transferred);
}
/*
* If the interval is at least 10% the normal interval
* length, or if there were actual bytes transferred,
* then we want to keep this interval.
*/
if (interval_len >= test->stats_interval * 0.10 ||
irp->bytes_transferred > 0) {
interval_ok = 1;
if (test->debug) {
printf("interval forces keep\n");
}
}
}
}
if (!interval_ok) {
if (test->debug) {
printf("ignoring short interval with no data\n");
}
return;
}
if (test->json_output) {
json_interval = cJSON_CreateObject();
if (json_interval == NULL)
return;
cJSON_AddItemToArray(test->json_intervals, json_interval);
json_interval_streams = cJSON_CreateArray();
if (json_interval_streams == NULL)
return;
cJSON_AddItemToObject(json_interval, "streams", json_interval_streams);
} else {
json_interval = NULL;
json_interval_streams = NULL;
}
/*
* We must to sum streams separately.
* For bidirectional mode we must to display
* information about sender and receiver streams.
* For client side we must handle sender streams
* firstly and receiver streams for server side.
* The following design allows us to do this.
*/
if (test->mode == BIDIRECTIONAL) {
if (test->role == 'c') {
lower_mode = -1;
upper_mode = 0;
} else {
lower_mode = 0;
upper_mode = 1;
}
} else {
lower_mode = test->mode;
upper_mode = lower_mode;
}
for (current_mode = lower_mode; current_mode <= upper_mode; ++current_mode) {
char ubuf[UNIT_LEN];
char nbuf[UNIT_LEN];
char mbuf[UNIT_LEN];
char zbuf[] = " ";
iperf_size_t bytes = 0;
double bandwidth;
int retransmits = 0;
double start_time, end_time;
int64_t total_packets = 0, lost_packets = 0;
double avg_jitter = 0.0, lost_percent;
int stream_must_be_sender = current_mode * current_mode;
char *sum_name;
/* Print stream role just for bidirectional mode. */
if (test->mode == BIDIRECTIONAL) {
sprintf(mbuf, "[%s-%s]", stream_must_be_sender?"TX":"RX", test->role == 'c'?"C":"S");
} else {
mbuf[0] = '\0';
zbuf[0] = '\0';
}
SLIST_FOREACH(sp, &test->streams, streams) {
if (sp->sender == stream_must_be_sender) {
print_interval_results(test, sp, json_interval_streams);
/* sum up all streams */
irp = TAILQ_LAST(&sp->result->interval_results, irlisthead);
if (irp == NULL) {
iperf_err(test,
"iperf_print_intermediate error: interval_results is NULL");
return;
}
bytes += irp->bytes_transferred;
if (test->protocol->id == Ptcp) {
if (test->sender_has_retransmits == 1) {
retransmits += irp->interval_retrans;
}
} else {
total_packets += irp->interval_packet_count;
lost_packets += irp->interval_cnt_error;
avg_jitter += irp->jitter;
}
}
}
/* next build string with sum of all streams */
if (test->num_streams > 1 || test->json_output) {
/*
* With BIDIR give a different JSON object name to the one sent/receive sums.
* The different name is given to the data sent from the server, which is
* the "reverse" channel. This makes sure that the name reported on the server
* and client are compatible, and the names are the same as with non-bidir,
* except for when reverse is used.
*/
sum_name = "sum";
if (test->mode == BIDIRECTIONAL) {
if ((test->role == 'c' && !stream_must_be_sender) ||
(test->role != 'c' && stream_must_be_sender))
{
sum_name = "sum_bidir_reverse";
}
}
sp = SLIST_FIRST(&test->streams); /* reset back to 1st stream */
/* Only do this of course if there was a first stream */
if (sp) {
irp = TAILQ_LAST(&sp->result->interval_results, irlisthead); /* use 1st stream for timing info */
unit_snprintf(ubuf, UNIT_LEN, (double) bytes, 'A');
bandwidth = (double) bytes / (double) irp->interval_duration;
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
iperf_time_diff(&sp->result->start_time,&irp->interval_start_time, &temp_time);
start_time = iperf_time_in_secs(&temp_time);
iperf_time_diff(&sp->result->start_time,&irp->interval_end_time, &temp_time);
end_time = iperf_time_in_secs(&temp_time);
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits == 1 && stream_must_be_sender) {
/* Interval sum, TCP with retransmits. */
if (test->json_output)
cJSON_AddItemToObject(json_interval, sum_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d omitted: %b sender: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, (int64_t) retransmits, irp->omitted, stream_must_be_sender)); /* XXX irp->omitted or test->omitting? */
else
iperf_printf(test, report_sum_bw_retrans_format, mbuf, start_time, end_time, ubuf, nbuf, retransmits, irp->omitted?report_omitted:""); /* XXX irp->omitted or test->omitting? */
} else {
/* Interval sum, TCP without retransmits. */
if (test->json_output)
cJSON_AddItemToObject(json_interval, sum_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f omitted: %b sender: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, test->omitting, stream_must_be_sender));
else
iperf_printf(test, report_sum_bw_format, mbuf, start_time, end_time, ubuf, nbuf, test->omitting?report_omitted:"");
}
} else {
/* Interval sum, UDP. */
if (stream_must_be_sender) {
if (test->json_output)
cJSON_AddItemToObject(json_interval, sum_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f packets: %d omitted: %b sender: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, (int64_t) total_packets, test->omitting, stream_must_be_sender));
else
iperf_printf(test, report_sum_bw_udp_sender_format, mbuf, start_time, end_time, ubuf, nbuf, zbuf, total_packets, test->omitting?report_omitted:"");
} else {
avg_jitter /= test->num_streams;
if (total_packets > 0) {
lost_percent = 100.0 * lost_packets / total_packets;
}
else {
lost_percent = 0.0;
}
if (test->json_output)
cJSON_AddItemToObject(json_interval, sum_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f omitted: %b sender: %b", (double) start_time, (double) end_time, (double) irp->interval_duration, (int64_t) bytes, bandwidth * 8, (double) avg_jitter * 1000.0, (int64_t) lost_packets, (int64_t) total_packets, (double) lost_percent, test->omitting, stream_must_be_sender));
else
iperf_printf(test, report_sum_bw_udp_format, mbuf, start_time, end_time, ubuf, nbuf, avg_jitter * 1000.0, lost_packets, total_packets, lost_percent, test->omitting?report_omitted:"");
}
}
}
}
}
}
/**
* Print overall summary statistics at the end of a test.
*/
static void
iperf_print_results(struct iperf_test *test)
{
cJSON *json_summary_streams = NULL;
int lower_mode, upper_mode;
int current_mode;
char *sum_sent_name, *sum_received_name, *sum_name;
int tmp_sender_has_retransmits = test->sender_has_retransmits;
/* print final summary for all intervals */
if (test->json_output) {
json_summary_streams = cJSON_CreateArray();
if (json_summary_streams == NULL)
return;
cJSON_AddItemToObject(test->json_end, "streams", json_summary_streams);
} else {
iperf_printf(test, "%s", report_bw_separator);
if (test->verbose)
iperf_printf(test, "%s", report_summary);
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits || test->other_side_has_retransmits) {
if (test->bidirectional)
iperf_printf(test, "%s", report_bw_retrans_header_bidir);
else
iperf_printf(test, "%s", report_bw_retrans_header);
}
else {
if (test->bidirectional)
iperf_printf(test, "%s", report_bw_header_bidir);
else
iperf_printf(test, "%s", report_bw_header);
}
} else {
if (test->bidirectional)
iperf_printf(test, "%s", report_bw_udp_header_bidir);
else
iperf_printf(test, "%s", report_bw_udp_header);
}
}
/*
* We must to sum streams separately.
* For bidirectional mode we must to display
* information about sender and receiver streams.
* For client side we must handle sender streams
* firstly and receiver streams for server side.
* The following design allows us to do this.
*/
if (test->mode == BIDIRECTIONAL) {
if (test->role == 'c') {
lower_mode = -1;
upper_mode = 0;
} else {
lower_mode = 0;
upper_mode = 1;
}
} else {
lower_mode = test->mode;
upper_mode = lower_mode;
}
for (current_mode = lower_mode; current_mode <= upper_mode; ++current_mode) {
cJSON *json_summary_stream = NULL;
int64_t total_retransmits = 0;
int64_t total_packets = 0, lost_packets = 0;
int64_t sender_packet_count = 0, receiver_packet_count = 0; /* for this stream, this interval */
int64_t sender_omitted_packet_count = 0, receiver_omitted_packet_count = 0; /* for this stream, this interval */
int64_t sender_total_packets = 0, receiver_total_packets = 0; /* running total */
char ubuf[UNIT_LEN];
char nbuf[UNIT_LEN];
struct stat sb;
char sbuf[UNIT_LEN];
struct iperf_stream *sp = NULL;
iperf_size_t bytes_sent, total_sent = 0;
iperf_size_t bytes_received, total_received = 0;
double start_time, end_time = 0.0, avg_jitter = 0.0, lost_percent = 0.0;
double sender_time = 0.0, receiver_time = 0.0;
struct iperf_time temp_time;
double bandwidth;
char mbuf[UNIT_LEN];
int stream_must_be_sender = current_mode * current_mode;
/* Print stream role just for bidirectional mode. */
if (test->mode == BIDIRECTIONAL) {
sprintf(mbuf, "[%s-%s]", stream_must_be_sender?"TX":"RX", test->role == 'c'?"C":"S");
} else {
mbuf[0] = '\0';
}
/* Get sender_has_retransmits for each sender side (client and server) */
if (test->mode == BIDIRECTIONAL && stream_must_be_sender)
test->sender_has_retransmits = tmp_sender_has_retransmits;
else if (test->mode == BIDIRECTIONAL && !stream_must_be_sender)
test->sender_has_retransmits = test->other_side_has_retransmits;
start_time = 0.;
sp = SLIST_FIRST(&test->streams);
/*
* If there is at least one stream, then figure out the length of time
* we were running the tests and print out some statistics about
* the streams. It's possible to not have any streams at all
* if the client got interrupted before it got to do anything.
*
* Also note that we try to keep separate values for the sender
* and receiver ending times. Earlier iperf (3.1 and earlier)
* servers didn't send that to the clients, so in this case we fall
* back to using the client's ending timestamp. The fallback is
* basically emulating what iperf 3.1 did.
*/
if (sp) {
iperf_time_diff(&sp->result->start_time, &sp->result->end_time, &temp_time);
end_time = iperf_time_in_secs(&temp_time);
if (sp->sender) {
sp->result->sender_time = end_time;
if (sp->result->receiver_time == 0.0) {
sp->result->receiver_time = sp->result->sender_time;
}
}
else {
sp->result->receiver_time = end_time;
if (sp->result->sender_time == 0.0) {
sp->result->sender_time = sp->result->receiver_time;
}
}
sender_time = sp->result->sender_time;
receiver_time = sp->result->receiver_time;
SLIST_FOREACH(sp, &test->streams, streams) {
if (sp->sender == stream_must_be_sender) {
if (test->json_output) {
json_summary_stream = cJSON_CreateObject();
if (json_summary_stream == NULL)
return;
cJSON_AddItemToArray(json_summary_streams, json_summary_stream);
}
bytes_sent = sp->result->bytes_sent - sp->result->bytes_sent_omit;
bytes_received = sp->result->bytes_received;
total_sent += bytes_sent;
total_received += bytes_received;
if (sp->sender) {
sender_packet_count = sp->packet_count;
sender_omitted_packet_count = sp->omitted_packet_count;
receiver_packet_count = sp->peer_packet_count;
receiver_omitted_packet_count = sp->peer_omitted_packet_count;
}
else {
sender_packet_count = sp->peer_packet_count;
sender_omitted_packet_count = sp->peer_omitted_packet_count;
receiver_packet_count = sp->packet_count;
receiver_omitted_packet_count = sp->omitted_packet_count;
}
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits) {
total_retransmits += sp->result->stream_retrans;
}
} else {
/*
* Running total of the total number of packets. Use the sender packet count if we
* have it, otherwise use the receiver packet count.
*/
int64_t packet_count = sender_packet_count ? sender_packet_count : receiver_packet_count;
total_packets += (packet_count - sp->omitted_packet_count);
sender_total_packets += (sender_packet_count - sender_omitted_packet_count);
receiver_total_packets += (receiver_packet_count - receiver_omitted_packet_count);
lost_packets += sp->cnt_error;
if (sp->omitted_cnt_error > -1)
lost_packets -= sp->omitted_cnt_error;
avg_jitter += sp->jitter;
}
unit_snprintf(ubuf, UNIT_LEN, (double) bytes_sent, 'A');
if (sender_time > 0.0) {
bandwidth = (double) bytes_sent / (double) sender_time;
}
else {
bandwidth = 0.0;
}
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits) {
/* Sender summary, TCP and SCTP with retransmits. */
if (test->json_output)
cJSON_AddItemToObject(json_summary_stream, report_sender, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d max_snd_cwnd: %d max_snd_wnd: %d max_rtt: %d min_rtt: %d mean_rtt: %d sender: %b", (int64_t) sp->socket, (double) start_time, (double) sender_time, (double) sender_time, (int64_t) bytes_sent, bandwidth * 8, (int64_t) sp->result->stream_retrans, (int64_t) sp->result->stream_max_snd_cwnd, (int64_t) sp->result->stream_max_snd_wnd, (int64_t) sp->result->stream_max_rtt, (int64_t) sp->result->stream_min_rtt, (int64_t) ((sp->result->stream_count_rtt == 0) ? 0 : sp->result->stream_sum_rtt / sp->result->stream_count_rtt), stream_must_be_sender));
else
if (test->role == 's' && !sp->sender) {
if (test->verbose)
iperf_printf(test, report_sender_not_available_format, sp->socket);
}
else {
iperf_printf(test, report_bw_retrans_format, sp->socket, mbuf, start_time, sender_time, ubuf, nbuf, sp->result->stream_retrans, report_sender);
}
} else {
/* Sender summary, TCP and SCTP without retransmits. */
if (test->json_output)
cJSON_AddItemToObject(json_summary_stream, report_sender, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f sender: %b", (int64_t) sp->socket, (double) start_time, (double) sender_time, (double) sender_time, (int64_t) bytes_sent, bandwidth * 8, stream_must_be_sender));
else
if (test->role == 's' && !sp->sender) {
if (test->verbose)
iperf_printf(test, report_sender_not_available_format, sp->socket);
}
else {
iperf_printf(test, report_bw_format, sp->socket, mbuf, start_time, sender_time, ubuf, nbuf, report_sender);
}
}
} else {
/* Sender summary, UDP. */
if (sender_packet_count - sender_omitted_packet_count > 0) {
lost_percent = 100.0 * (sp->cnt_error - sp->omitted_cnt_error) / (sender_packet_count - sender_omitted_packet_count);
}
else {
lost_percent = 0.0;
}
if (test->json_output) {
/*
* For historical reasons, we only emit one JSON
* object for the UDP summary, and it contains
* information for both the sender and receiver
* side.
*
* The JSON format as currently defined only includes one
* value for the number of packets. We usually want that
* to be the sender's value (how many packets were sent
* by the sender). However this value might not be
* available on the receiver in certain circumstances
* specifically on the server side for a normal test or
* the client side for a reverse-mode test. If this
* is the case, then use the receiver's count of packets
* instead.
*/
int64_t packet_count = sender_packet_count ? sender_packet_count : receiver_packet_count;
cJSON_AddItemToObject(json_summary_stream, "udp", iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f out_of_order: %d sender: %b", (int64_t) sp->socket, (double) start_time, (double) sender_time, (double) sender_time, (int64_t) bytes_sent, bandwidth * 8, (double) sp->jitter * 1000.0, (int64_t) (sp->cnt_error - sp->omitted_cnt_error), (int64_t) (packet_count - sp->omitted_packet_count), (double) lost_percent, (int64_t) (sp->outoforder_packets - sp->omitted_outoforder_packets), stream_must_be_sender));
}
else {
/*
* Due to ordering of messages on the control channel,
* the server cannot report on client-side summary
* statistics. If we're the server, omit one set of
* summary statistics to avoid giving meaningless
* results.
*/
if (test->role == 's' && !sp->sender) {
if (test->verbose)
iperf_printf(test, report_sender_not_available_format, sp->socket);
}
else {
iperf_printf(test, report_bw_udp_format, sp->socket, mbuf, start_time, sender_time, ubuf, nbuf, 0.0, (int64_t) 0, (sender_packet_count - sender_omitted_packet_count), (double) 0, report_sender);
}
if ((sp->outoforder_packets - sp->omitted_outoforder_packets) > 0)
iperf_printf(test, report_sum_outoforder, mbuf, start_time, sender_time, (sp->outoforder_packets - sp->omitted_outoforder_packets));
}
}
if (sp->diskfile_fd >= 0) {
if (fstat(sp->diskfile_fd, &sb) == 0) {
/* In the odd case that it's a zero-sized file, say it was all transferred. */
int percent_sent = 100, percent_received = 100;
if (sb.st_size > 0) {
percent_sent = (int) ( ( (double) bytes_sent / (double) sb.st_size ) * 100.0 );
percent_received = (int) ( ( (double) bytes_received / (double) sb.st_size ) * 100.0 );
}
unit_snprintf(sbuf, UNIT_LEN, (double) sb.st_size, 'A');
if (test->json_output)
cJSON_AddItemToObject(json_summary_stream, "diskfile", iperf_json_printf("sent: %d received: %d size: %d percent_sent: %d percent_received: %d filename: %s", (int64_t) bytes_sent, (int64_t) bytes_received, (int64_t) sb.st_size, (int64_t) percent_sent, (int64_t) percent_received, test->diskfile_name));
else
if (stream_must_be_sender) {
iperf_printf(test, report_diskfile, ubuf, sbuf, percent_sent, test->diskfile_name);
}
else {
unit_snprintf(ubuf, UNIT_LEN, (double) bytes_received, 'A');
iperf_printf(test, report_diskfile, ubuf, sbuf, percent_received, test->diskfile_name);
}
}
}
unit_snprintf(ubuf, UNIT_LEN, (double) bytes_received, 'A');
if (receiver_time > 0) {
bandwidth = (double) bytes_received / (double) receiver_time;
}
else {
bandwidth = 0.0;
}
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
/* Receiver summary, TCP and SCTP */
if (test->json_output)
cJSON_AddItemToObject(json_summary_stream, report_receiver, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f sender: %b", (int64_t) sp->socket, (double) start_time, (double) receiver_time, (double) end_time, (int64_t) bytes_received, bandwidth * 8, stream_must_be_sender));
else
if (test->role == 's' && sp->sender) {
if (test->verbose)
iperf_printf(test, report_receiver_not_available_format, sp->socket);
}
else {
iperf_printf(test, report_bw_format, sp->socket, mbuf, start_time, receiver_time, ubuf, nbuf, report_receiver);
}
}
else {
/*
* Receiver summary, UDP. Note that JSON was emitted with
* the sender summary, so we only deal with human-readable
* data here.
*/
if (! test->json_output) {
if (receiver_packet_count - receiver_omitted_packet_count > 0 && sp->omitted_cnt_error > -1) {
lost_percent = 100.0 * (sp->cnt_error - sp->omitted_cnt_error) / (receiver_packet_count - receiver_omitted_packet_count);
}
else {
lost_percent = 0.0;
}
if (test->role == 's' && sp->sender) {
if (test->verbose)
iperf_printf(test, report_receiver_not_available_format, sp->socket);
}
else {
if (sp->omitted_cnt_error > -1) {
iperf_printf(test, report_bw_udp_format, sp->socket, mbuf, start_time, receiver_time, ubuf, nbuf, sp->jitter * 1000.0, (sp->cnt_error - sp->omitted_cnt_error), (receiver_packet_count - receiver_omitted_packet_count), lost_percent, report_receiver);
} else {
iperf_printf(test, report_bw_udp_format_no_omitted_error, sp->socket, mbuf, start_time, receiver_time, ubuf, nbuf, sp->jitter * 1000.0, (receiver_packet_count - receiver_omitted_packet_count), report_receiver);
}
}
}
}
}
}
}
if (test->num_streams > 1 || test->json_output) {
/*
* With BIDIR give a different JSON object name to the one sent/receive sums.
* The different name is given to the data sent from the server, which is
* the "reverse" channel. This makes sure that the name reported on the server
* and client are compatible, and the names are the same as with non-bidir,
* except for when reverse is used.
*/
sum_name = "sum";
sum_sent_name = "sum_sent";
sum_received_name = "sum_received";
if (test->mode == BIDIRECTIONAL) {
if ((test->role == 'c' && !stream_must_be_sender) ||
(test->role != 'c' && stream_must_be_sender))
{
sum_name = "sum_bidir_reverse";
sum_sent_name = "sum_sent_bidir_reverse";
sum_received_name = "sum_received_bidir_reverse";
}
}
unit_snprintf(ubuf, UNIT_LEN, (double) total_sent, 'A');
/* If no tests were run, arbitrarily set bandwidth to 0. */
if (sender_time > 0.0) {
bandwidth = (double) total_sent / (double) sender_time;
}
else {
bandwidth = 0.0;
}
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits) {
/* Summary sum, TCP with retransmits. */
if (test->json_output)
cJSON_AddItemToObject(test->json_end, sum_sent_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d sender: %b", (double) start_time, (double) sender_time, (double) sender_time, (int64_t) total_sent, bandwidth * 8, (int64_t) total_retransmits, stream_must_be_sender));
else
if (test->role == 's' && !stream_must_be_sender) {
if (test->verbose)
iperf_printf(test, report_sender_not_available_summary_format, "SUM");
}
else {
iperf_printf(test, report_sum_bw_retrans_format, mbuf, start_time, sender_time, ubuf, nbuf, total_retransmits, report_sender);
}
} else {
/* Summary sum, TCP without retransmits. */
if (test->json_output)
cJSON_AddItemToObject(test->json_end, sum_sent_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f sender: %b", (double) start_time, (double) sender_time, (double) sender_time, (int64_t) total_sent, bandwidth * 8, stream_must_be_sender));
else
if (test->role == 's' && !stream_must_be_sender) {
if (test->verbose)
iperf_printf(test, report_sender_not_available_summary_format, "SUM");
}
else {
iperf_printf(test, report_sum_bw_format, mbuf, start_time, sender_time, ubuf, nbuf, report_sender);
}
}
unit_snprintf(ubuf, UNIT_LEN, (double) total_received, 'A');
/* If no tests were run, set received bandwidth to 0 */
if (receiver_time > 0.0) {
bandwidth = (double) total_received / (double) receiver_time;
}
else {
bandwidth = 0.0;
}
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
if (test->json_output)
cJSON_AddItemToObject(test->json_end, sum_received_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f sender: %b", (double) start_time, (double) receiver_time, (double) receiver_time, (int64_t) total_received, bandwidth * 8, stream_must_be_sender));
else
if (test->role == 's' && stream_must_be_sender) {
if (test->verbose)
iperf_printf(test, report_receiver_not_available_summary_format, "SUM");
}
else {
iperf_printf(test, report_sum_bw_format, mbuf, start_time, receiver_time, ubuf, nbuf, report_receiver);
}
} else {
/* Summary sum, UDP. */
avg_jitter /= test->num_streams;
/* If no packets were sent, arbitrarily set loss percentage to 0. */
if (total_packets > 0) {
lost_percent = 100.0 * lost_packets / total_packets;
}
else {
lost_percent = 0.0;
}
if (test->json_output) {
/*
* Original, summary structure. Using this
* structure is not recommended due to
* ambiguities between the sender and receiver.
*/
cJSON_AddItemToObject(test->json_end, sum_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f sender: %b", (double) start_time, (double) receiver_time, (double) receiver_time, (int64_t) total_sent, bandwidth * 8, (double) avg_jitter * 1000.0, (int64_t) lost_packets, (int64_t) total_packets, (double) lost_percent, stream_must_be_sender));
/*
* Separate sum_sent and sum_received structures.
* Using these structures to get the most complete
* information about UDP transfer.
*/
cJSON_AddItemToObject(test->json_end, sum_sent_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f sender: %b", (double) start_time, (double) sender_time, (double) sender_time, (int64_t) total_sent, (double) total_sent * 8 / sender_time, (double) 0.0, (int64_t) 0, (int64_t) sender_total_packets, (double) 0.0, 1));
cJSON_AddItemToObject(test->json_end, sum_received_name, iperf_json_printf("start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f sender: %b", (double) start_time, (double) receiver_time, (double) receiver_time, (int64_t) total_received, (double) total_received * 8 / receiver_time, (double) avg_jitter * 1000.0, (int64_t) lost_packets, (int64_t) receiver_total_packets, (double) lost_percent, 0));
} else {
/*
* On the client we have both sender and receiver overall summary
* stats. On the server we have only the side that was on the
* server. Output whatever we have.
*/
if (! (test->role == 's' && !stream_must_be_sender) ) {
unit_snprintf(ubuf, UNIT_LEN, (double) total_sent, 'A');
iperf_printf(test, report_sum_bw_udp_format, mbuf, start_time, sender_time, ubuf, nbuf, 0.0, (int64_t) 0, sender_total_packets, 0.0, report_sender);
}
if (! (test->role == 's' && stream_must_be_sender) ) {
unit_snprintf(ubuf, UNIT_LEN, (double) total_received, 'A');
/* Compute received bandwidth. */
if (end_time > 0.0) {
bandwidth = (double) total_received / (double) receiver_time;
}
else {
bandwidth = 0.0;
}
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
iperf_printf(test, report_sum_bw_udp_format, mbuf, start_time, receiver_time, ubuf, nbuf, avg_jitter * 1000.0, lost_packets, receiver_total_packets, lost_percent, report_receiver);
}
}
}
}
if (test->json_output && current_mode == upper_mode) {
cJSON_AddItemToObject(test->json_end, "cpu_utilization_percent", iperf_json_printf("host_total: %f host_user: %f host_system: %f remote_total: %f remote_user: %f remote_system: %f", (double) test->cpu_util[0], (double) test->cpu_util[1], (double) test->cpu_util[2], (double) test->remote_cpu_util[0], (double) test->remote_cpu_util[1], (double) test->remote_cpu_util[2]));
if (test->protocol->id == Ptcp) {
char *snd_congestion = NULL, *rcv_congestion = NULL;
if (stream_must_be_sender) {
snd_congestion = test->congestion_used;
rcv_congestion = test->remote_congestion_used;
}
else {
snd_congestion = test->remote_congestion_used;
rcv_congestion = test->congestion_used;
}
if (snd_congestion) {
cJSON_AddStringToObject(test->json_end, "sender_tcp_congestion", snd_congestion);
}
if (rcv_congestion) {
cJSON_AddStringToObject(test->json_end, "receiver_tcp_congestion", rcv_congestion);
}
}
}
else {
if (test->verbose) {
if (stream_must_be_sender) {
if (test->bidirectional) {
iperf_printf(test, report_cpu, report_local, stream_must_be_sender?report_sender:report_receiver, test->cpu_util[0], test->cpu_util[1], test->cpu_util[2], report_remote, stream_must_be_sender?report_receiver:report_sender, test->remote_cpu_util[0], test->remote_cpu_util[1], test->remote_cpu_util[2]);
iperf_printf(test, report_cpu, report_local, !stream_must_be_sender?report_sender:report_receiver, test->cpu_util[0], test->cpu_util[1], test->cpu_util[2], report_remote, !stream_must_be_sender?report_receiver:report_sender, test->remote_cpu_util[0], test->remote_cpu_util[1], test->remote_cpu_util[2]);
} else
iperf_printf(test, report_cpu, report_local, stream_must_be_sender?report_sender:report_receiver, test->cpu_util[0], test->cpu_util[1], test->cpu_util[2], report_remote, stream_must_be_sender?report_receiver:report_sender, test->remote_cpu_util[0], test->remote_cpu_util[1], test->remote_cpu_util[2]);
}
if (test->protocol->id == Ptcp) {
char *snd_congestion = NULL, *rcv_congestion = NULL;
if (stream_must_be_sender) {
snd_congestion = test->congestion_used;
rcv_congestion = test->remote_congestion_used;
}
else {
snd_congestion = test->remote_congestion_used;
rcv_congestion = test->congestion_used;
}
if (snd_congestion) {
iperf_printf(test, "snd_tcp_congestion %s\n", snd_congestion);
}
if (rcv_congestion) {
iperf_printf(test, "rcv_tcp_congestion %s\n", rcv_congestion);
}
}
}
/* Print server output if we're on the client and it was requested/provided */
if (test->role == 'c' && iperf_get_test_get_server_output(test) && !test->json_output) {
if (test->json_server_output) {
char *str = cJSON_Print(test->json_server_output);
iperf_printf(test, "\nServer JSON output:\n%s\n", str);
cJSON_free(str);
cJSON_Delete(test->json_server_output);
test->json_server_output = NULL;
}
if (test->server_output_text) {
iperf_printf(test, "\nServer output:\n%s\n", test->server_output_text);
test->server_output_text = NULL;
}
}
}
}
/* Set real sender_has_retransmits for current side */
if (test->mode == BIDIRECTIONAL)
test->sender_has_retransmits = tmp_sender_has_retransmits;
}
/**************************************************************************/
/**
* Main report-printing callback.
* Prints results either during a test (interval report only) or
* after the entire test has been run (last interval report plus
* overall summary).
*/
void
iperf_reporter_callback(struct iperf_test *test)
{
switch (test->state) {
case TEST_RUNNING:
case STREAM_RUNNING:
/* print interval results for each stream */
iperf_print_intermediate(test);
break;
case TEST_END:
case DISPLAY_RESULTS:
iperf_print_intermediate(test);
iperf_print_results(test);
break;
}
}
/**
* Print the interval results for one stream.
* This function needs to know about the overall test so it can determine the
* context for printing headers, separators, etc.
*/
static void
print_interval_results(struct iperf_test *test, struct iperf_stream *sp, cJSON *json_interval_streams)
{
char ubuf[UNIT_LEN];
char nbuf[UNIT_LEN];
char cbuf[UNIT_LEN];
char mbuf[UNIT_LEN];
char zbuf[] = " ";
double st = 0., et = 0.;
struct iperf_time temp_time;
struct iperf_interval_results *irp = NULL;
double bandwidth, lost_percent;
if (test->mode == BIDIRECTIONAL) {
sprintf(mbuf, "[%s-%s]", sp->sender?"TX":"RX", test->role == 'c'?"C":"S");
} else {
mbuf[0] = '\0';
zbuf[0] = '\0';
}
irp = TAILQ_LAST(&sp->result->interval_results, irlisthead); /* get last entry in linked list */
if (irp == NULL) {
iperf_err(test, "print_interval_results error: interval_results is NULL");
return;
}
if (!test->json_output) {
/* First stream? */
if (sp == SLIST_FIRST(&test->streams)) {
/* It it's the first interval, print the header;
** else if there's more than one stream, print the separator;
** else nothing.
*/
if (iperf_time_compare(&sp->result->start_time, &irp->interval_start_time) == 0) {
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits == 1) {
if (test->bidirectional)
iperf_printf(test, "%s", report_bw_retrans_cwnd_header_bidir);
else
iperf_printf(test, "%s", report_bw_retrans_cwnd_header);
}
else {
if (test->bidirectional)
iperf_printf(test, "%s", report_bw_header_bidir);
else
iperf_printf(test, "%s", report_bw_header);
}
} else {
if (test->mode == SENDER) {
iperf_printf(test, "%s", report_bw_udp_sender_header);
} else if (test->mode == RECEIVER){
iperf_printf(test, "%s", report_bw_udp_header);
} else {
/* BIDIRECTIONAL */
iperf_printf(test, "%s", report_bw_udp_header_bidir);
}
}
} else if (test->num_streams > 1)
iperf_printf(test, "%s", report_bw_separator);
}
}
unit_snprintf(ubuf, UNIT_LEN, (double) (irp->bytes_transferred), 'A');
if (irp->interval_duration > 0.0) {
bandwidth = (double) irp->bytes_transferred / (double) irp->interval_duration;
}
else {
bandwidth = 0.0;
}
unit_snprintf(nbuf, UNIT_LEN, bandwidth, test->settings->unit_format);
iperf_time_diff(&sp->result->start_time, &irp->interval_start_time, &temp_time);
st = iperf_time_in_secs(&temp_time);
iperf_time_diff(&sp->result->start_time, &irp->interval_end_time, &temp_time);
et = iperf_time_in_secs(&temp_time);
if (test->protocol->id == Ptcp || test->protocol->id == Psctp) {
if (test->sender_has_retransmits == 1 && sp->sender) {
/* Interval, TCP with retransmits. */
if (test->json_output)
cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f retransmits: %d snd_cwnd: %d snd_wnd: %d rtt: %d rttvar: %d pmtu: %d omitted: %b sender: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, (int64_t) irp->interval_retrans, (int64_t) irp->snd_cwnd, (int64_t) irp->snd_wnd, (int64_t) irp->rtt, (int64_t) irp->rttvar, (int64_t) irp->pmtu, irp->omitted, sp->sender));
else {
unit_snprintf(cbuf, UNIT_LEN, irp->snd_cwnd, 'A');
iperf_printf(test, report_bw_retrans_cwnd_format, sp->socket, mbuf, st, et, ubuf, nbuf, irp->interval_retrans, cbuf, irp->omitted?report_omitted:"");
}
} else {
/* Interval, TCP without retransmits. */
if (test->json_output)
cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f omitted: %b sender: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, irp->omitted, sp->sender));
else
iperf_printf(test, report_bw_format, sp->socket, mbuf, st, et, ubuf, nbuf, irp->omitted?report_omitted:"");
}
} else {
/* Interval, UDP. */
if (sp->sender) {
if (test->json_output)
cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f packets: %d omitted: %b sender: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, (int64_t) irp->interval_packet_count, irp->omitted, sp->sender));
else
iperf_printf(test, report_bw_udp_sender_format, sp->socket, mbuf, st, et, ubuf, nbuf, zbuf, irp->interval_packet_count, irp->omitted?report_omitted:"");
} else {
if (irp->interval_packet_count > 0) {
lost_percent = 100.0 * irp->interval_cnt_error / irp->interval_packet_count;
}
else {
lost_percent = 0.0;
}
if (test->json_output)
cJSON_AddItemToArray(json_interval_streams, iperf_json_printf("socket: %d start: %f end: %f seconds: %f bytes: %d bits_per_second: %f jitter_ms: %f lost_packets: %d packets: %d lost_percent: %f omitted: %b sender: %b", (int64_t) sp->socket, (double) st, (double) et, (double) irp->interval_duration, (int64_t) irp->bytes_transferred, bandwidth * 8, (double) irp->jitter * 1000.0, (int64_t) irp->interval_cnt_error, (int64_t) irp->interval_packet_count, (double) lost_percent, irp->omitted, sp->sender));
else
iperf_printf(test, report_bw_udp_format, sp->socket, mbuf, st, et, ubuf, nbuf, irp->jitter * 1000.0, irp->interval_cnt_error, irp->interval_packet_count, lost_percent, irp->omitted?report_omitted:"");
}
}
if (test->logfile || test->forceflush)
iflush(test);
}
/**************************************************************************/
void
iperf_free_stream(struct iperf_stream *sp)
{
struct iperf_interval_results *irp, *nirp;
/* XXX: need to free interval list too! */
munmap(sp->buffer, sp->test->settings->blksize);
close(sp->buffer_fd);
if (sp->diskfile_fd >= 0)
close(sp->diskfile_fd);
for (irp = TAILQ_FIRST(&sp->result->interval_results); irp != NULL; irp = nirp) {
nirp = TAILQ_NEXT(irp, irlistentries);
free(irp);
}
free(sp->result);
if (sp->send_timer != NULL)
tmr_cancel(sp->send_timer);
free(sp);
}
/**************************************************************************/
struct iperf_stream *
iperf_new_stream(struct iperf_test *test, int s, int sender)
{
struct iperf_stream *sp;
int ret = 0;
char template[1024];
if (test->tmp_template) {
snprintf(template, sizeof(template) / sizeof(char), "%s", test->tmp_template);
} else {
//find the system temporary dir *unix, windows, cygwin support
char* tempdir = getenv("TMPDIR");
if (tempdir == 0){
tempdir = getenv("TEMP");
}
if (tempdir == 0){
tempdir = getenv("TMP");
}
if (tempdir == 0){
#if defined(__ANDROID__)
tempdir = "/data/local/tmp";
#else
tempdir = "/tmp";
#endif
}
snprintf(template, sizeof(template) / sizeof(char), "%s/iperf3.XXXXXX", tempdir);
}
sp = (struct iperf_stream *) malloc(sizeof(struct iperf_stream));
if (!sp) {
i_errno = IECREATESTREAM;
return NULL;
}
memset(sp, 0, sizeof(struct iperf_stream));
sp->sender = sender;
sp->test = test;
sp->settings = test->settings;
sp->result = (struct iperf_stream_result *) malloc(sizeof(struct iperf_stream_result));
if (!sp->result) {
free(sp);
i_errno = IECREATESTREAM;
return NULL;
}
memset(sp->result, 0, sizeof(struct iperf_stream_result));
TAILQ_INIT(&sp->result->interval_results);
/* Create and randomize the buffer */
sp->buffer_fd = mkstemp(template);
if (sp->buffer_fd == -1) {
i_errno = IECREATESTREAM;
free(sp->result);
free(sp);
return NULL;
}
if (unlink(template) < 0) {
i_errno = IECREATESTREAM;
free(sp->result);
free(sp);
return NULL;
}
if (ftruncate(sp->buffer_fd, test->settings->blksize) < 0) {
i_errno = IECREATESTREAM;
free(sp->result);
free(sp);
return NULL;
}
sp->buffer = (char *) mmap(NULL, test->settings->blksize, PROT_READ|PROT_WRITE, MAP_PRIVATE, sp->buffer_fd, 0);
if (sp->buffer == MAP_FAILED) {
i_errno = IECREATESTREAM;
free(sp->result);
free(sp);
return NULL;
}
sp->pending_size = 0;
/* Set socket */
sp->socket = s;
sp->snd = test->protocol->send;
sp->rcv = test->protocol->recv;
if (test->diskfile_name != (char*) 0) {
sp->diskfile_fd = open(test->diskfile_name, sender ? O_RDONLY : (O_WRONLY|O_CREAT|O_TRUNC), S_IRUSR|S_IWUSR);
if (sp->diskfile_fd == -1) {
i_errno = IEFILE;
munmap(sp->buffer, sp->test->settings->blksize);
free(sp->result);
free(sp);
return NULL;
}
sp->snd2 = sp->snd;
sp->snd = diskfile_send;
sp->rcv2 = sp->rcv;
sp->rcv = diskfile_recv;
} else
sp->diskfile_fd = -1;
/* Initialize stream */
if (test->repeating_payload)
fill_with_repeating_pattern(sp->buffer, test->settings->blksize);
else
ret = readentropy(sp->buffer, test->settings->blksize);
if ((ret < 0) || (iperf_init_stream(sp, test) < 0)) {
close(sp->buffer_fd);
munmap(sp->buffer, sp->test->settings->blksize);
free(sp->result);
free(sp);
return NULL;
}
iperf_add_stream(test, sp);
return sp;
}
/**************************************************************************/
int
iperf_common_sockopts(struct iperf_test *test, int s)
{
int opt;
/* Set IP TOS */
if ((opt = test->settings->tos)) {
if (getsockdomain(s) == AF_INET6) {
#ifdef IPV6_TCLASS
if (setsockopt(s, IPPROTO_IPV6, IPV6_TCLASS, &opt, sizeof(opt)) < 0) {
i_errno = IESETCOS;
return -1;
}
/* if the control connection was established with a mapped v4 address
then set IP_TOS on v6 stream socket as well */
if (iperf_get_mapped_v4(test)) {
if (setsockopt(s, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) < 0) {
/* ignore any failure of v4 TOS in IPv6 case */
}
}
#else
i_errno = IESETCOS;
return -1;
#endif
} else {
if (setsockopt(s, IPPROTO_IP, IP_TOS, &opt, sizeof(opt)) < 0) {
i_errno = IESETTOS;
return -1;
}
}
}
return 0;
}
/**************************************************************************/
int
iperf_init_stream(struct iperf_stream *sp, struct iperf_test *test)
{
int opt;
socklen_t len;
len = sizeof(struct sockaddr_storage);
if (getsockname(sp->socket, (struct sockaddr *) &sp->local_addr, &len) < 0) {
i_errno = IEINITSTREAM;
return -1;
}
len = sizeof(struct sockaddr_storage);
if (getpeername(sp->socket, (struct sockaddr *) &sp->remote_addr, &len) < 0) {
i_errno = IEINITSTREAM;
return -1;
}
#if defined(HAVE_DONT_FRAGMENT)
/* Set Don't Fragment (DF). Only applicable to IPv4/UDP tests. */
if (iperf_get_test_protocol_id(test) == Pudp &&
getsockdomain(sp->socket) == AF_INET &&
iperf_get_dont_fragment(test)) {
/*
* There are multiple implementations of this feature depending on the OS.
* We need to handle separately Linux, UNIX, and Windows, as well as
* the case that DF isn't supported at all (such as on macOS).
*/
#if defined(IP_MTU_DISCOVER) /* Linux version of IP_DONTFRAG */
opt = IP_PMTUDISC_DO;
if (setsockopt(sp->socket, IPPROTO_IP, IP_MTU_DISCOVER, &opt, sizeof(opt)) < 0) {
i_errno = IESETDONTFRAGMENT;
return -1;
}
#else
#if defined(IP_DONTFRAG) /* UNIX does IP_DONTFRAG */
opt = 1;
if (setsockopt(sp->socket, IPPROTO_IP, IP_DONTFRAG, &opt, sizeof(opt)) < 0) {
i_errno = IESETDONTFRAGMENT;
return -1;
}
#else
#if defined(IP_DONTFRAGMENT) /* Windows does IP_DONTFRAGMENT */
opt = 1;
if (setsockopt(sp->socket, IPPROTO_IP, IP_DONTFRAGMENT, &opt, sizeof(opt)) < 0) {
i_errno = IESETDONTFRAGMENT;
return -1;
}
#else
i_errno = IESETDONTFRAGMENT;
return -1;
#endif /* IP_DONTFRAGMENT */
#endif /* IP_DONTFRAG */
#endif /* IP_MTU_DISCOVER */
}
#endif /* HAVE_DONT_FRAGMENT */
return 0;
}
/**************************************************************************/
void
iperf_add_stream(struct iperf_test *test, struct iperf_stream *sp)
{
int i;
struct iperf_stream *n, *prev;
if (SLIST_EMPTY(&test->streams)) {
SLIST_INSERT_HEAD(&test->streams, sp, streams);
sp->id = 1;
} else {
// for (n = test->streams, i = 2; n->next; n = n->next, ++i);
// NOTE: this would ideally be set to 1, however this will not
// be changed since it is not causing a significant problem
// and changing it would break multi-stream tests between old
// and new iperf3 versions.
i = 2;
prev = NULL;
SLIST_FOREACH(n, &test->streams, streams) {
prev = n;
++i;
}
if (prev) {
SLIST_INSERT_AFTER(prev, sp, streams);
sp->id = i;
}
}
}
/* This pair of routines gets inserted into the snd/rcv function pointers
** when there's a -F flag. They handle the file stuff and call the real
** snd/rcv functions, which have been saved in snd2/rcv2.
**
** The advantage of doing it this way is that in the much more common
** case of no -F flag, there is zero extra overhead.
*/
static int
diskfile_send(struct iperf_stream *sp)
{
int r;
int buffer_left = sp->diskfile_left; // represents total data in buffer to be sent out
static int rtot;
/* if needed, read enough data from the disk to fill up the buffer */
if (sp->diskfile_left < sp->test->settings->blksize && !sp->test->done) {
r = read(sp->diskfile_fd, sp->buffer, sp->test->settings->blksize -
sp->diskfile_left);
buffer_left += r;
rtot += r;
if (sp->test->debug) {
printf("read %d bytes from file, %d total\n", r, rtot);
}
// If the buffer doesn't contain a full buffer at this point,
// adjust the size of the data to send.
if (buffer_left != sp->test->settings->blksize) {
if (sp->test->debug)
printf("possible eof\n");
// setting data size to be sent,
// which is less than full block/buffer size
// (to be used by iperf_tcp_send, etc.)
sp->pending_size = buffer_left;
}
// If there's no work left, we're done.
if (buffer_left == 0) {
sp->test->done = 1;
if (sp->test->debug)
printf("done\n");
}
}
// If there's no data left in the file or in the buffer, we're done.
// No more data available to be sent.
// Return without sending data to the network
if( sp->test->done || buffer_left == 0 ){
if (sp->test->debug)
printf("already done\n");
sp->test->done = 1;
return 0;
}
r = sp->snd2(sp);
if (r < 0) {
return r;
}
/*
* Compute how much data is in the buffer but didn't get sent.
* If there are bytes that got left behind, slide them to the
* front of the buffer so they can hopefully go out on the next
* pass.
*/
sp->diskfile_left = buffer_left - r;
if (sp->diskfile_left && sp->diskfile_left < sp->test->settings->blksize) {
memcpy(sp->buffer,
sp->buffer + (sp->test->settings->blksize - sp->diskfile_left),
sp->diskfile_left);
if (sp->test->debug)
printf("Shifting %d bytes by %d\n", sp->diskfile_left, (sp->test->settings->blksize - sp->diskfile_left));
}
return r;
}
static int
diskfile_recv(struct iperf_stream *sp)
{
int r;
r = sp->rcv2(sp);
if (r > 0) {
// NOTE: Currently ignoring the return value of writing to disk
(void) (write(sp->diskfile_fd, sp->buffer, r) + 1);
}
return r;
}
void
iperf_catch_sigend(void (*handler)(int))
{
#ifdef SIGINT
signal(SIGINT, handler);
#endif
#ifdef SIGTERM
signal(SIGTERM, handler);
#endif
#ifdef SIGHUP
signal(SIGHUP, handler);
#endif
}
/**
* Called as a result of getting a signal.
* Depending on the current state of the test (and the role of this
* process) compute and report one more set of ending statistics
* before cleaning up and exiting.
*/
void
iperf_got_sigend(struct iperf_test *test)
{
/*
* If we're the client, or if we're a server and running a test,
* then dump out the accumulated stats so far.
*/
if (test->role == 'c' ||
(test->role == 's' && test->state == TEST_RUNNING)) {
test->done = 1;
cpu_util(test->cpu_util);
test->stats_callback(test);
test->state = DISPLAY_RESULTS; /* change local state only */
if (test->on_test_finish)
test->on_test_finish(test);
test->reporter_callback(test);
}
if (test->ctrl_sck >= 0) {
test->state = (test->role == 'c') ? CLIENT_TERMINATE : SERVER_TERMINATE;
(void) Nwrite(test->ctrl_sck, (char*) &test->state, sizeof(signed char), Ptcp);
}
i_errno = (test->role == 'c') ? IECLIENTTERM : IESERVERTERM;
iperf_errexit(test, "interrupt - %s", iperf_strerror(i_errno));
}
/* Try to write a PID file if requested, return -1 on an error. */
int
iperf_create_pidfile(struct iperf_test *test)
{
if (test->pidfile) {
int fd;
char buf[8];
/* See if the file already exists and we can read it. */
fd = open(test->pidfile, O_RDONLY, 0);
if (fd >= 0) {
if (read(fd, buf, sizeof(buf) - 1) >= 0) {
/* We read some bytes, see if they correspond to a valid PID */
pid_t pid;
pid = atoi(buf);
if (pid > 0) {
/* See if the process exists. */
if (kill(pid, 0) == 0) {
/*
* Make sure not to try to delete existing PID file by
* scribbling over the pathname we'd use to refer to it.
* Then exit with an error.
*/
free(test->pidfile);
test->pidfile = NULL;
iperf_errexit(test, "Another instance of iperf3 appears to be running");
}
}
}
}
/*
* File didn't exist, we couldn't read it, or it didn't correspond to
* a running process. Try to create it.
*/
fd = open(test->pidfile, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR|S_IWUSR);
if (fd < 0) {
return -1;
}
snprintf(buf, sizeof(buf), "%d", getpid()); /* no trailing newline */
if (write(fd, buf, strlen(buf)) < 0) {
(void)close(fd);
return -1;
}
if (close(fd) < 0) {
return -1;
};
}
return 0;
}
/* Get rid of a PID file, return -1 on error. */
int
iperf_delete_pidfile(struct iperf_test *test)
{
if (test->pidfile) {
if (unlink(test->pidfile) < 0) {
return -1;
}
}
return 0;
}
int
iperf_json_start(struct iperf_test *test)
{
test->json_top = cJSON_CreateObject();
if (test->json_top == NULL)
return -1;
test->json_start = cJSON_CreateObject();
if (test->json_start == NULL)
return -1;
cJSON_AddItemToObject(test->json_top, "start", test->json_start);
test->json_connected = cJSON_CreateArray();
if (test->json_connected == NULL)
return -1;
cJSON_AddItemToObject(test->json_start, "connected", test->json_connected);
test->json_intervals = cJSON_CreateArray();
if (test->json_intervals == NULL)
return -1;
cJSON_AddItemToObject(test->json_top, "intervals", test->json_intervals);
test->json_end = cJSON_CreateObject();
if (test->json_end == NULL)
return -1;
cJSON_AddItemToObject(test->json_top, "end", test->json_end);
return 0;
}
int
iperf_json_finish(struct iperf_test *test)
{
if (test->json_top) {
if (test->title) {
cJSON_AddStringToObject(test->json_top, "title", test->title);
}
if (test->extra_data) {
cJSON_AddStringToObject(test->json_top, "extra_data", test->extra_data);
}
/* Include server output */
if (test->json_server_output) {
cJSON_AddItemToObject(test->json_top, "server_output_json", test->json_server_output);
}
if (test->server_output_text) {
cJSON_AddStringToObject(test->json_top, "server_output_text", test->server_output_text);
}
// Get ASCII rendering of JSON structure. Then make our
// own copy of it and return the storage that cJSON allocated
// on our behalf. We keep our own copy around.
char *str = cJSON_Print(test->json_top);
if (str == NULL) {
return -1;
}
test->json_output_string = strdup(str);
cJSON_free(str);
if (test->json_output_string == NULL) {
return -1;
}
fprintf(test->outfile, "%s\n", test->json_output_string);
iflush(test);
cJSON_Delete(test->json_top);
test->json_top = NULL;
}
test->json_start = test->json_connected = test->json_intervals = test->json_server_output = test->json_end = NULL;
return 0;
}
/* CPU affinity stuff - Linux, FreeBSD, and Windows only. */
int
iperf_setaffinity(struct iperf_test *test, int affinity)
{
#if defined(HAVE_SCHED_SETAFFINITY)
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
CPU_SET(affinity, &cpu_set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0) {
i_errno = IEAFFINITY;
return -1;
}
return 0;
#elif defined(HAVE_CPUSET_SETAFFINITY)
cpuset_t cpumask;
if(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1,
sizeof(cpuset_t), &test->cpumask) != 0) {
i_errno = IEAFFINITY;
return -1;
}
CPU_ZERO(&cpumask);
CPU_SET(affinity, &cpumask);
if(cpuset_setaffinity(CPU_LEVEL_WHICH,CPU_WHICH_PID, -1,
sizeof(cpuset_t), &cpumask) != 0) {
i_errno = IEAFFINITY;
return -1;
}
return 0;
#elif defined(HAVE_SETPROCESSAFFINITYMASK)
HANDLE process = GetCurrentProcess();
DWORD_PTR processAffinityMask = 1 << affinity;
if (SetProcessAffinityMask(process, processAffinityMask) == 0) {
i_errno = IEAFFINITY;
return -1;
}
return 0;
#else /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY nor HAVE_SETPROCESSAFFINITYMASK */
i_errno = IEAFFINITY;
return -1;
#endif /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY nor HAVE_SETPROCESSAFFINITYMASK */
}
int
iperf_clearaffinity(struct iperf_test *test)
{
#if defined(HAVE_SCHED_SETAFFINITY)
cpu_set_t cpu_set;
int i;
CPU_ZERO(&cpu_set);
for (i = 0; i < CPU_SETSIZE; ++i)
CPU_SET(i, &cpu_set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set) != 0) {
i_errno = IEAFFINITY;
return -1;
}
return 0;
#elif defined(HAVE_CPUSET_SETAFFINITY)
if(cpuset_setaffinity(CPU_LEVEL_WHICH,CPU_WHICH_PID, -1,
sizeof(cpuset_t), &test->cpumask) != 0) {
i_errno = IEAFFINITY;
return -1;
}
return 0;
#elif defined(HAVE_SETPROCESSAFFINITYMASK)
HANDLE process = GetCurrentProcess();
DWORD_PTR processAffinityMask;
DWORD_PTR lpSystemAffinityMask;
if (GetProcessAffinityMask(process, &processAffinityMask, &lpSystemAffinityMask) == 0
|| SetProcessAffinityMask(process, lpSystemAffinityMask) == 0) {
i_errno = IEAFFINITY;
return -1;
}
return 0;
#else /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY nor HAVE_SETPROCESSAFFINITYMASK */
i_errno = IEAFFINITY;
return -1;
#endif /* neither HAVE_SCHED_SETAFFINITY nor HAVE_CPUSET_SETAFFINITY nor HAVE_SETPROCESSAFFINITYMASK */
}
static char iperf_timestr[100];
static char linebuffer[1024];
int
iperf_printf(struct iperf_test *test, const char* format, ...)
{
va_list argp;
int r = 0, r0;
time_t now;
struct tm *ltm = NULL;
char *ct = NULL;
/* Timestamp if requested */
if (iperf_get_test_timestamps(test)) {
time(&now);
ltm = localtime(&now);
strftime(iperf_timestr, sizeof(iperf_timestr), iperf_get_test_timestamp_format(test), ltm);
ct = iperf_timestr;
}
/*
* There are roughly two use cases here. If we're the client,
* want to print stuff directly to the output stream.
* If we're the sender we might need to buffer up output to send
* to the client.
*
* This doesn't make a whole lot of difference except there are
* some chunks of output on the client (on particular the whole
* of the server output with --get-server-output) that could
* easily exceed the size of the line buffer, but which don't need
* to be buffered up anyway.
*/
if (test->role == 'c') {
if (ct) {
r0 = fprintf(test->outfile, "%s", ct);
if (r0 < 0)
return r0;
r += r0;
}
if (test->title) {
r0 = fprintf(test->outfile, "%s: ", test->title);
if (r0 < 0)
return r0;
r += r0;
}
va_start(argp, format);
r0 = vfprintf(test->outfile, format, argp);
va_end(argp);
if (r0 < 0)
return r0;
r += r0;
}
else if (test->role == 's') {
if (ct) {
r0 = snprintf(linebuffer, sizeof(linebuffer), "%s", ct);
if (r0 < 0)
return r0;
r += r0;
}
/* Should always be true as long as sizeof(ct) < sizeof(linebuffer) */
if (r < sizeof(linebuffer)) {
va_start(argp, format);
r0 = vsnprintf(linebuffer + r, sizeof(linebuffer) - r, format, argp);
va_end(argp);
if (r0 < 0)
return r0;
r += r0;
}
fprintf(test->outfile, "%s", linebuffer);
if (test->role == 's' && iperf_get_test_get_server_output(test)) {
struct iperf_textline *l = (struct iperf_textline *) malloc(sizeof(struct iperf_textline));
l->line = strdup(linebuffer);
TAILQ_INSERT_TAIL(&(test->server_output_list), l, textlineentries);
}
}
return r;
}
int
iflush(struct iperf_test *test)
{
return fflush(test->outfile);
}
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iperf_api.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iperf / src