diff options
Diffstat (limited to '')
| -rw-r--r-- | src/Client.cpp | 1871 | ||||
| -rw-r--r-- | src/Extractor.c | 188 | ||||
| -rw-r--r-- | src/Launch.cpp | 478 | ||||
| -rw-r--r-- | src/Listener.cpp | 1447 | ||||
| -rw-r--r-- | src/Locale.c | 757 | ||||
| -rw-r--r-- | src/Makefile.am | 71 | ||||
| -rw-r--r-- | src/Makefile.in | 829 | ||||
| -rw-r--r-- | src/PerfSocket.cpp | 445 | ||||
| -rw-r--r-- | src/ReportOutputs.c | 2019 | ||||
| -rw-r--r-- | src/Reporter.c | 1937 | ||||
| -rw-r--r-- | src/Reports.c | 1091 | ||||
| -rw-r--r-- | src/Server.cpp | 946 | ||||
| -rw-r--r-- | src/Settings.cpp | 2577 | ||||
| -rw-r--r-- | src/SocketAddr.c | 941 | ||||
| -rw-r--r-- | src/active_hosts.cpp | 261 | ||||
| -rw-r--r-- | src/checkdelay.c | 203 | ||||
| -rw-r--r-- | src/checkisoch.cpp | 129 | ||||
| -rw-r--r-- | src/checkpdfs.c | 217 | ||||
| -rw-r--r-- | src/checksums.c | 229 | ||||
| -rw-r--r-- | src/dscp.c | 180 | ||||
| -rw-r--r-- | src/gnu_getopt.c | 818 | ||||
| -rw-r--r-- | src/gnu_getopt_long.c | 162 | ||||
| -rw-r--r-- | src/histogram.c | 269 | ||||
| -rw-r--r-- | src/igmp_querier.c | 213 | ||||
| -rw-r--r-- | src/iperf_formattime.c | 100 | ||||
| -rw-r--r-- | src/isochronous.cpp | 275 | ||||
| -rw-r--r-- | src/main.cpp | 479 | ||||
| -rw-r--r-- | src/packet_ring.c | 219 | ||||
| -rw-r--r-- | src/pdfs.c | 100 | ||||
| -rw-r--r-- | src/socket_io.c | 239 | ||||
| -rw-r--r-- | src/stdio.c | 355 | ||||
| -rw-r--r-- | src/tcp_window_size.c | 227 |
32 files changed, 20272 insertions, 0 deletions
diff --git a/src/Client.cpp b/src/Client.cpp new file mode 100644 index 0000000..89e47e2 --- /dev/null +++ b/src/Client.cpp @@ -0,0 +1,1871 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Client.cpp + * by Mark Gates <mgates@nlanr.net> + * ------------------------------------------------------------------- + * A client thread initiates a connect to the server and handles + * sending and receiving data, then closes the socket. + * ------------------------------------------------------------------- */ +#include <ctime> +#include <cmath> +#include "headers.h" +#include "Client.hpp" +#include "Thread.h" +#include "SocketAddr.h" +#include "PerfSocket.hpp" +#include "Extractor.h" +#include "delay.h" +#include "util.h" +#include "Locale.h" +#include "isochronous.hpp" +#include "pdfs.h" +#include "version.h" +#include "payloads.h" +#include "active_hosts.h" +#include "gettcpinfo.h" + +// const double kSecs_to_usecs = 1e6; +const double kSecs_to_nsecs = 1e9; +const int kBytes_to_Bits = 8; + +#define VARYLOAD_PERIOD 0.1 // recompute the variable load every n seconds +#define MAXUDPBUF 1470 + +Client::Client (thread_Settings *inSettings) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client constructor with thread %p sum=%p (flags=%x)", (void *) inSettings, (void *)inSettings->mSumReport, inSettings->flags); +#endif + mSettings = inSettings; + myJob = NULL; + myReport = NULL; + framecounter = NULL; + one_report = false; + udp_payload_minimum = 1; + apply_first_udppkt_delay = false; + + memset(&scratchpad, 0, sizeof(struct ReportStruct)); + reportstruct = &scratchpad; + reportstruct->packetID = 1; + mySocket = isServerReverse(mSettings) ? mSettings->mSock : INVALID_SOCKET; + connected = isServerReverse(mSettings); + if (isCompat(mSettings) && isPeerVerDetect(mSettings)) { + fprintf(stderr, "%s", warn_compat_and_peer_exchange); + unsetPeerVerDetect(mSettings); + } + + pattern(mSettings->mBuf, mSettings->mBufLen); + if (isIsochronous(mSettings)) { + FAIL_errno(!(mSettings->mFPS > 0.0), "Invalid value for frames per second in the isochronous settings\n", mSettings); + } + if (isFileInput(mSettings)) { + if (!isSTDIN(mSettings)) + Extractor_Initialize(mSettings->mFileName, mSettings->mBufLen, mSettings); + else + Extractor_InitializeFile(stdin, mSettings->mBufLen, mSettings); + + if (!Extractor_canRead(mSettings)) { + unsetFileInput(mSettings); + } + } + peerclose = false; + mysock_init_done = false; + isburst = (isIsochronous(mSettings) || isPeriodicBurst(mSettings) || (isTripTime(mSettings) && !isUDP(mSettings))); +} // end Client + +/* ------------------------------------------------------------------- + * Destructor + * ------------------------------------------------------------------- */ +Client::~Client () { +#if HAVE_THREAD_DEBUG + thread_debug("Client destructor sock=%d report=%p server-reverse=%s fullduplex=%s", \ + mySocket, (void *) mSettings->reporthdr, \ + (isServerReverse(mSettings) ? "true" : "false"), (isFullDuplex(mSettings) ? "true" : "false")); +#endif + DELETE_PTR(framecounter); +} // end ~Client + +/* ------------------------------------------------------------------- + * Setup a socket connected to a server. + * If inLocalhost is not null, bind to that address, specifying + * which outgoing interface to use. + * ------------------------------------------------------------------- */ +void Client::mySockInit (void) { + // create an internet socket + int type = (isUDP(mSettings) ? SOCK_DGRAM : SOCK_STREAM); + int domain = (SockAddr_isIPv6(&mSettings->peer) ? +#if HAVE_IPV6 + AF_INET6 +#else + AF_INET +#endif + : AF_INET); + + mySocket = socket(domain, type, 0); + WARN_errno(mySocket == INVALID_SOCKET, "socket"); + // Socket is carried both by the object and the thread + mSettings->mSock=mySocket; + SetSocketOptions(mSettings); + SockAddr_localAddr(mSettings); + SockAddr_remoteAddr(mSettings); + if (mSettings->mLocalhost != NULL) { + // bind socket to local address + int rc = bind(mySocket, reinterpret_cast<sockaddr*>(&mSettings->local), + SockAddr_get_sizeof_sockaddr(&mSettings->local)); + WARN_errno(rc == SOCKET_ERROR, "bind"); + } + mysock_init_done = true; + if (!isUDP(mSettings) && isReport(mSettings) && isSettingsReport(mSettings)) { + struct ReportHeader *tmp = InitSettingsReport(mSettings); + assert(tmp!=NULL); + PostReport(tmp); + setNoSettReport(mSettings); + } +} +/* ------------------------------------------------------------------- + * Setup a socket connected to a server. + * If inLocalhost is not null, bind to that address, specifying + * which outgoing interface to use. + * ------------------------------------------------------------------- */ +bool Client::my_connect (bool close_on_fail) { + int rc; + if (!mysock_init_done) { + mySockInit(); + } + // connect socket + connected = false; + mSettings->tcpinitstats.connecttime = -1; + if (!isUDP(mSettings)) { + int trycnt = mSettings->mConnectRetries + 1; + while (trycnt > 0) { + connect_start.setnow(); + rc = connect(mySocket, reinterpret_cast<sockaddr*>(&mSettings->peer), + SockAddr_get_sizeof_sockaddr(&mSettings->peer)); + WARN_errno((rc == SOCKET_ERROR), "tcp connect"); + if (rc == SOCKET_ERROR) { + if ((--trycnt) <= 0) { + if (close_on_fail) { + close(mySocket); + mySocket = INVALID_SOCKET; + } + } else { + delay_loop(200000); + } + } else { + connect_done.setnow(); + mSettings->tcpinitstats.connecttime = 1e3 * connect_done.subSec(connect_start); + connected = true; + break; + } + } + } else { + rc = connect(mySocket, reinterpret_cast<sockaddr*>(&mSettings->peer), + SockAddr_get_sizeof_sockaddr(&mSettings->peer)); + mSettings->tcpinitstats.connecttime = 0.0; // UDP doesn't have a 3WHS + WARN_errno((rc == SOCKET_ERROR), "udp connect"); + if (rc != SOCKET_ERROR) + connected = true; + } + if (connected) { +#if HAVE_TCP_STATS + assert(reportstruct); + if (!isUDP(mSettings)) { + gettcpinfo(mySocket, &mSettings->tcpinitstats); + } +#endif + // Set the send timeout for the very first write which has the test exchange + int sosndtimer = TESTEXCHANGETIMEOUT; // 4 sec in usecs + SetSocketOptionsSendTimeout(mSettings, sosndtimer); + getsockname(mySocket, reinterpret_cast<sockaddr*>(&mSettings->local), &mSettings->size_local); + getpeername(mySocket, reinterpret_cast<sockaddr*>(&mSettings->peer), &mSettings->size_peer); + SockAddr_Ifrname(mSettings); +#ifdef DEFAULT_PAYLOAD_LEN_PER_MTU_DISCOVERY + if (isUDP(mSettings) && !isBuflenSet(mSettings)) { + checksock_max_udp_payload(mSettings); + } +#endif + if (isUDP(mSettings) && !isIsochronous(mSettings) && !isIPG(mSettings)) { + mSettings->mBurstIPG = get_delay_target() / 1e3; // this is being set for the settings report only + } + if (isReport(mSettings) && isSettingsReport(mSettings)) { + struct ReportHeader *tmp = InitSettingsReport(mSettings); + assert(tmp!=NULL); + PostReport(tmp); + setNoSettReport(mSettings); + } + } else { + if (mySocket != INVALID_SOCKET) { + int rc = close(mySocket); + WARN_errno(rc == SOCKET_ERROR, "client connect close"); + mySocket = INVALID_SOCKET; + } + } + // Post the connect report unless peer version exchange is set + if (isConnectionReport(mSettings) && !isSumOnly(mSettings)) { + if (connected) { + struct ReportHeader *reporthdr = InitConnectionReport(mSettings); + struct ConnectionInfo *cr = static_cast<struct ConnectionInfo *>(reporthdr->this_report); + cr->connect_timestamp.tv_sec = connect_start.getSecs(); + cr->connect_timestamp.tv_usec = connect_start.getUsecs(); + assert(reporthdr); + PostReport(reporthdr); + } else { + PostReport(InitConnectionReport(mSettings)); + } + } + return connected; +} // end Connect + +bool Client::isConnected () const { +#ifdef HAVE_THREAD_DEBUG + // thread_debug("Client is connected %d", connected); +#endif + return connected; +} + +void Client::TxDelay () { + if (isTxHoldback(mSettings)) { + clock_usleep(&mSettings->txholdback_timer); + } +} + +inline void Client::myReportPacket (void) { + ReportPacket(myReport, reportstruct); + reportstruct->packetLen = 0; +} + + +// There are multiple startup synchronizations, this code +// handles them all. The caller decides to apply them +// either before connect() or after connect() and before writes() +int Client::StartSynch () { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client start sync enterred"); +#endif + bool delay_test_exchange = (isFullDuplex(mSettings) && isUDP(mSettings)); + if (isTxStartTime(mSettings) && delay_test_exchange) { + clock_usleep_abstime(&mSettings->txstart_epoch); + } + myJob = InitIndividualReport(mSettings); + myReport = static_cast<struct ReporterData *>(myJob->this_report); + myReport->info.common->socket=mySocket; + myReport->info.isEnableTcpInfo = false; // default here, set in init traffic actions + if (!isReverse(mSettings) && (mSettings->mReportMode == kReport_CSV)) { + format_ips_port_string(&myReport->info, 0); + } + + // Perform delays, usually between connect() and data xfer though before connect + // Two delays are supported: + // o First is an absolute start time per unix epoch format + // o Second is a holdback, a relative amount of seconds between the connect and data xfers + // check for an epoch based start time + reportstruct->packetLen = 0; + if (!isServerReverse(mSettings)) { + if (!isCompat(mSettings) && !isBounceBack(mSettings)) { + reportstruct->packetLen = SendFirstPayload(); + // Reverse UDP tests need to retry "first sends" a few times + // before going to server or read mode + if (isReverse(mSettings) && isUDP(mSettings)) { + reportstruct->packetLen = 0; + fd_set set; + struct timeval timeout; + int resend_udp = 100; + while (--resend_udp > 0) { + FD_ZERO(&set); + FD_SET(mySocket, &set); + timeout.tv_sec = 0; + timeout.tv_usec = rand() % 20000; // randomize IPG a bit + if (select(mySocket + 1, &set, NULL, NULL, &timeout) == 0) { + reportstruct->packetLen = SendFirstPayload(); + // printf("**** resend sock=%d count=%d\n", mySocket, resend_udp); + } else { + break; + } + } + } + } + if (isTxStartTime(mSettings) && !delay_test_exchange) { + clock_usleep_abstime(&mSettings->txstart_epoch); + } else if (isTxHoldback(mSettings)) { + TxDelay(); + } + // Server side client + } else if (isTripTime(mSettings) || isPeriodicBurst(mSettings)) { + reportstruct->packetLen = SendFirstPayload(); + } + if (isIsochronous(mSettings) || isPeriodicBurst(mSettings)) { + Timestamp tmp; + tmp.set(mSettings->txstart_epoch.tv_sec, mSettings->txstart_epoch.tv_usec); + framecounter = new Isochronous::FrameCounter(mSettings->mFPS, tmp); + // set the mbuf valid for burst period ahead of time. The same value will be set for all burst writes + if (!isUDP(mSettings) && framecounter) { + struct TCP_burst_payload * mBuf_burst = reinterpret_cast<struct TCP_burst_payload *>(mSettings->mBuf); + mBuf_burst->burst_period_us = htonl(framecounter->period_us()); + } + } + int setfullduplexflag = 0; + if (isFullDuplex(mSettings) && !isServerReverse(mSettings)) { + assert(mSettings->mFullDuplexReport != NULL); + if ((setfullduplexflag = fullduplex_start_barrier(&mSettings->mFullDuplexReport->fullduplex_barrier)) < 0) + return -1; + } + SetReportStartTime(); +#if HAVE_TCP_STATS + if (!isUDP(mSettings)) { + // Near congestion and peridiodic need sampling on every report packet + if (isNearCongest(mSettings) || isPeriodicBurst(mSettings)) { + myReport->info.isEnableTcpInfo = true; + myReport->info.ts.nextTCPSampleTime.tv_sec = 0; + myReport->info.ts.nextTCPSampleTime.tv_usec = 0; + } else if (isEnhanced(mSettings) || isBounceBack(mSettings)) { + myReport->info.isEnableTcpInfo = true; + myReport->info.ts.nextTCPSampleTime = myReport->info.ts.nextTime; + } + } +#endif + + if (reportstruct->packetLen > 0) { + reportstruct->packetTime = myReport->info.ts.startTime; + reportstruct->sentTime = reportstruct->packetTime; + reportstruct->prevSentTime = reportstruct->packetTime; + reportstruct->prevPacketTime = myReport->info.ts.prevpacketTime; + if (isModeAmount(mSettings)) { + mSettings->mAmount -= reportstruct->packetLen; + } + myReportPacket(); + myReport->info.ts.prevpacketTime = reportstruct->packetTime; + reportstruct->packetID++; + } + if (setfullduplexflag) { + SetFullDuplexReportStartTime(); + } + // Full duplex sockets need to be syncronized +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client start sync exited"); +#endif + return 0; +} + +inline void Client::SetFullDuplexReportStartTime () { + assert(myReport->FullDuplexReport != NULL); + struct TransferInfo *fullduplexstats = &myReport->FullDuplexReport->info; + assert(fullduplexstats != NULL); + if (TimeZero(fullduplexstats->ts.startTime)) { + fullduplexstats->ts.startTime = myReport->info.ts.startTime; + if (isModeTime(mSettings)) { + fullduplexstats->ts.nextTime = myReport->info.ts.nextTime; + } + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client fullduplex report start=%ld.%ld next=%ld.%ld", fullduplexstats->ts.startTime.tv_sec, fullduplexstats->ts.startTime.tv_usec, fullduplexstats->ts.nextTime.tv_sec, fullduplexstats->ts.nextTime.tv_usec); +#endif +} +inline void Client::SetReportStartTime () { + assert(myReport!=NULL); + now.setnow(); + myReport->info.ts.startTime.tv_sec = now.getSecs(); + myReport->info.ts.startTime.tv_usec = now.getUsecs(); + myReport->info.ts.IPGstart = myReport->info.ts.startTime; + myReport->info.ts.prevpacketTime = myReport->info.ts.startTime; + if (!TimeZero(myReport->info.ts.intervalTime)) { + myReport->info.ts.nextTime = myReport->info.ts.startTime; + TimeAdd(myReport->info.ts.nextTime, myReport->info.ts.intervalTime); + } + if (myReport->GroupSumReport) { + struct TransferInfo *sumstats = &myReport->GroupSumReport->info; + assert(sumstats != NULL); + Mutex_Lock(&myReport->GroupSumReport->reference.lock); + if (TimeZero(sumstats->ts.startTime)) { + sumstats->ts.startTime = myReport->info.ts.startTime; + if (isModeTime(mSettings) || isModeInfinite(mSettings)) { + sumstats->ts.nextTime = myReport->info.ts.nextTime; + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client group sum report start=%ld.%ld next=%ld.%ld", sumstats->ts.startTime.tv_sec, sumstats->ts.startTime.tv_usec, sumstats->ts.nextTime.tv_sec, sumstats->ts.nextTime.tv_usec); +#endif + } + Mutex_Unlock(&myReport->GroupSumReport->reference.lock); + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client(%d) report start/ipg=%ld.%ld next=%ld.%ld", mSettings->mSock, myReport->info.ts.startTime.tv_sec, myReport->info.ts.startTime.tv_usec, myReport->info.ts.nextTime.tv_sec, myReport->info.ts.nextTime.tv_usec); +#endif +} + +void Client::ConnectPeriodic () { + Timestamp end; + Timestamp next; + unsigned int amount_usec = 1000000; + if (isModeTime(mSettings)) { + amount_usec = (mSettings->mAmount * 10000); + end.add(amount_usec); // add in micro seconds + } + setNoConnectSync(mSettings); + int num_connects = -1; + if (!(mSettings->mInterval > 0)) { + if (mSettings->connectonly_count < 0) + num_connects = 10; + else if (mSettings->connectonly_count > 0) + num_connects = mSettings->connectonly_count; + } + + do { + if (my_connect(false)){ + int rc = close(mySocket); + WARN_errno(rc == SOCKET_ERROR, "client close"); + mySocket = INVALID_SOCKET; + mysock_init_done = false; + } + if (mSettings->mInterval > 0) { + now.setnow(); + do { + next.add(mSettings->mInterval); + } while (next.before(now)); + if (next.before(end)) { + struct timeval tmp; + tmp.tv_sec = next.getSecs(); + tmp.tv_usec = next.getUsecs(); + clock_usleep_abstime(&tmp); + } + } + if (num_connects > 0) { + --num_connects; + } + } while (num_connects && !sInterupted && (next.before(end) || (isModeTime(mSettings) && !(mSettings->mInterval > 0)))); +} +/* ------------------------------------------------------------------- + * Common traffic loop intializations + * ------------------------------------------------------------------- */ +void Client::InitTrafficLoop () { + // Enable socket write timeouts for responsive reporting + // Do this after the connection establishment + // and after Client::InitiateServer as during these + // default socket timeouts are preferred. + int sosndtimer = 0; + // sosndtimer units microseconds + // mInterval units are microseconds, mAmount units is 10 ms + // SetSocketOptionsSendTimeout takes microseconds + // Set the timeout value to 1/2 the interval (per -i) or 1/2 the -t value + if (isPeriodicBurst(mSettings) && (mSettings->mFPS > 0.0)) { + sosndtimer = static_cast<int>(round(250000.0 / mSettings->mFPS)); + } else if (mSettings->mInterval > 0) { + sosndtimer = static_cast<int>(round(0.5 * mSettings->mInterval)); + } else { + sosndtimer = static_cast<int>(mSettings->mAmount * 5e3); + } + SetSocketOptionsSendTimeout(mSettings, sosndtimer); + // set the lower bounds delay based of the socket timeout timer + // units needs to be in nanoseconds + delay_lower_bounds = static_cast<double>(sosndtimer) * -1e3; + + if (isIsochronous(mSettings)) + myReport->info.matchframeID = 1; + + // set the total bytes sent to zero + totLen = 0; + if (isModeTime(mSettings)) { + mEndTime.setnow(); + mEndTime.add(mSettings->mAmount / 100.0); + // now.setnow(); fprintf(stderr, "DEBUG: end time set to %ld.%ld now is %ld.%ld\n", mEndTime.getSecs(), mEndTime.getUsecs(), now.getSecs(), now.getUsecs()); + } + readAt = mSettings->mBuf; + lastPacketTime.set(myReport->info.ts.startTime.tv_sec, myReport->info.ts.startTime.tv_usec); + reportstruct->errwrite=WriteNoErr; + reportstruct->emptyreport=0; + reportstruct->packetLen = 0; + // Finally, post this thread's "job report" which the reporter thread + // will continuously process as long as there are packets flowing + // right now the ring is empty + if (!isReverse(mSettings) && !isSingleUDP(mSettings) && isDataReport(mSettings)) { + assert(myJob!=NULL); + assert(myReport!=NULL); + PostReport(myJob); + } + one_report = (!isUDP(mSettings) && !isEnhanced(mSettings) && (mSettings->mIntervalMode != kInterval_Time) \ + && !isIsochronous(mSettings) && !isPeriodicBurst(mSettings) && !isTripTime(mSettings) && !isReverse(mSettings)); +} + +/* ------------------------------------------------------------------- + * Run the appropriate send loop between + * + * 1) TCP without rate limiting + * 2) TCP with rate limiting + * 3) UDP + * 4) UDP isochronous w/vbr + * + * ------------------------------------------------------------------- */ +void Client::Run () { + // Initialize the report struct scratch pad + // Peform common traffic setup + InitTrafficLoop(); + /* + * UDP + */ + if (isUDP(mSettings)) { + if (isFileInput(mSettings)) { + // Due to the UDP timestamps etc, included + // reduce the read size by an amount + // equal to the header size + Extractor_reduceReadSize(sizeof(struct UDP_datagram), mSettings); + readAt += sizeof(struct UDP_datagram); + } + // Launch the approprate UDP traffic loop + if (isIsochronous(mSettings)) { + RunUDPIsochronous(); + } else { + RunUDP(); + } + } else { + // Launch the approprate TCP traffic loop + if (isBounceBack(mSettings)) { + RunBounceBackTCP(); + } else if (mSettings->mAppRate > 0) { + RunRateLimitedTCP(); + } else if (isNearCongest(mSettings)) { + RunNearCongestionTCP(); +#if HAVE_DECL_TCP_NOTSENT_LOWAT + } else if (isWritePrefetch(mSettings) && \ + !isIsochronous(mSettings) && !isPeriodicBurst(mSettings)) { + RunWriteEventsTCP(); +#endif + } else { + RunTCP(); + } + } +} + +/* + * TCP send loop + */ +void Client::RunTCP () { + int burst_remaining = 0; + uint32_t burst_id = 1; + int writelen = mSettings->mBufLen; + + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->write_time = 0; + while (InProgress()) { + reportstruct->writecnt = 0; + reportstruct->scheduled = false; + if (isModeAmount(mSettings)) { + writelen = ((mSettings->mAmount < static_cast<unsigned>(mSettings->mBufLen)) ? mSettings->mAmount : mSettings->mBufLen); + } + if (isburst && !(burst_remaining > 0)) { + if (isIsochronous(mSettings)) { + assert(mSettings->mMean); + burst_remaining = static_cast<int>(lognormal(mSettings->mMean,mSettings->mVariance)) / (mSettings->mFPS * 8); + } else if (isPeriodicBurst(mSettings)){ + assert(mSettings->mBurstSize); + burst_remaining = mSettings->mBurstSize; + } else { + burst_remaining = mSettings->mBufLen; + } + // check for TCP minimum payload + if (burst_remaining < static_cast<int>(sizeof(struct TCP_burst_payload))) + burst_remaining = static_cast<int>(sizeof(struct TCP_burst_payload)); + // apply scheduling if needed + if (framecounter) { + burst_id = framecounter->wait_tick(&reportstruct->sched_err); + reportstruct->scheduled = true; + if (isPeriodicBurst(mSettings)) { + // low duty cycle traffic needs special event handling + now.setnow(); + myReport->info.ts.prevsendTime = reportstruct->packetTime; + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + if (!InProgress()) { + reportstruct->packetLen = 0; + reportstruct->emptyreport = 1; + // wait may have crossed the termination boundry + break; + } else { + //time interval crossings may have occurred during the wait + //post a null event to cause the report to flush the packet ring + PostNullEvent(); + } + } +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (isWritePrefetch(mSettings)) { + AwaitWriteSelectEventTCP(); + } +#endif + } + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + WriteTcpTxHdr(reportstruct, burst_remaining, burst_id++); + reportstruct->sentTime = reportstruct->packetTime; + myReport->info.ts.prevsendTime = reportstruct->packetTime; + writelen = (mSettings->mBufLen > burst_remaining) ? burst_remaining : mSettings->mBufLen; + // perform write, full header must succeed + if (isTcpWriteTimes(mSettings)) { + write_start.setnow(); + } + reportstruct->packetLen = writen(mySocket, mSettings->mBuf, writelen, &reportstruct->writecnt); + FAIL_errno(reportstruct->packetLen < (intmax_t) sizeof(struct TCP_burst_payload), "burst written", mSettings); + if (isTcpWriteTimes(mSettings)) { + now.setnow(); + reportstruct->write_time = now.subUsec(write_start); + } + } else { + // printf("pl=%ld\n",reportstruct->packetLen); + // perform write + if (isburst) + writelen = (mSettings->mBufLen > burst_remaining) ? burst_remaining : mSettings->mBufLen; + if (isTcpWriteTimes(mSettings)) { + write_start.setnow(); + } +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (isWritePrefetch(mSettings)) { + AwaitWriteSelectEventTCP(); + } +#endif + reportstruct->packetLen = write(mySocket, mSettings->mBuf, writelen); + now.setnow(); + reportstruct->writecnt++; + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + if (isTcpWriteTimes(mSettings)) { + reportstruct->write_time = now.subUsec(write_start); + } + reportstruct->sentTime = reportstruct->packetTime; + } + if (reportstruct->packetLen <= 0) { + if (reportstruct->packetLen == 0) { + peerclose = true; + } else if (NONFATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrAccount; + } else if (FATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrFatal; + WARN_errno(1, "tcp write"); + break; + } else { + reportstruct->errwrite=WriteErrNoAccount; + } + reportstruct->packetLen = 0; + reportstruct->emptyreport = 1; + } else { + reportstruct->emptyreport = 0; + totLen += reportstruct->packetLen; + reportstruct->errwrite=WriteNoErr; + if (isburst) { + burst_remaining -= reportstruct->packetLen; + if (burst_remaining > 0) { + reportstruct->transit_ready = 0; + } else { + reportstruct->transit_ready = 1; + reportstruct->prevSentTime = myReport->info.ts.prevsendTime; + } + } + } + if (isModeAmount(mSettings) && !reportstruct->emptyreport) { + /* mAmount may be unsigned, so don't let it underflow! */ + if (mSettings->mAmount >= static_cast<unsigned long>(reportstruct->packetLen)) { + mSettings->mAmount -= static_cast<unsigned long>(reportstruct->packetLen); + } else { + mSettings->mAmount = 0; + } + } + if (!one_report) { + myReportPacket(); + } + } + FinishTrafficActions(); +} + +/* + * TCP send loop + */ +void Client::RunNearCongestionTCP () { + int burst_remaining = 0; + int burst_id = 1; + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + while (InProgress()) { + reportstruct->writecnt = 0; + if (isModeAmount(mSettings)) { + reportstruct->packetLen = ((mSettings->mAmount < static_cast<unsigned>(mSettings->mBufLen)) ? mSettings->mAmount : mSettings->mBufLen); + } else { + reportstruct->packetLen = mSettings->mBufLen; + } + if (!burst_remaining) { + burst_remaining = mSettings->mBufLen; + // mAmount check + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + WriteTcpTxHdr(reportstruct, burst_remaining, burst_id++); + reportstruct->sentTime = reportstruct->packetTime; + myReport->info.ts.prevsendTime = reportstruct->packetTime; + // perform write + int writelen = (mSettings->mBufLen > burst_remaining) ? burst_remaining : mSettings->mBufLen; + reportstruct->packetLen = write(mySocket, mSettings->mBuf, writelen); + reportstruct->writecnt++; + assert(reportstruct->packetLen >= (intmax_t) sizeof(struct TCP_burst_payload)); + goto ReportNow; + } + if (reportstruct->packetLen > burst_remaining) { + reportstruct->packetLen = burst_remaining; + } + // printf("pl=%ld\n",reportstruct->packetLen); + // perform write + reportstruct->packetLen = write(mySocket, mSettings->mBuf, reportstruct->packetLen); + now.setnow(); + reportstruct->writecnt++; + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->sentTime = reportstruct->packetTime; + ReportNow: + reportstruct->transit_ready = 0; + if (reportstruct->packetLen < 0) { + if (NONFATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrAccount; + } else if (FATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrFatal; + WARN_errno(1, "tcp write"); + break; + } else { + reportstruct->errwrite=WriteErrNoAccount; + } + reportstruct->packetLen = 0; + reportstruct->emptyreport = 1; + } else { + reportstruct->emptyreport = 0; + totLen += reportstruct->packetLen; + reportstruct->errwrite=WriteNoErr; + burst_remaining -= reportstruct->packetLen; + if (burst_remaining <= 0) { + reportstruct->transit_ready = 1; + } + } + if (isModeAmount(mSettings) && !reportstruct->emptyreport) { + /* mAmount may be unsigned, so don't let it underflow! */ + if (mSettings->mAmount >= static_cast<unsigned long>(reportstruct->packetLen)) { + mSettings->mAmount -= static_cast<unsigned long>(reportstruct->packetLen); + } else { + mSettings->mAmount = 0; + } + } + // apply placing after write burst completes + if (reportstruct->transit_ready) { + myReportPacket(); // this will set the tcpstats in the report struct + // pacing timer is weighted by the RTT (set to 1 when RTT is not supported) + int pacing_timer = 0; +#if HAVE_TCP_STATS + pacing_timer = static_cast<int>(std::ceil(static_cast<double>(reportstruct->tcpstats.rtt) * mSettings->rtt_nearcongest_weight_factor)); +#else + pacing_timer = static_cast<int>(100 * mSettings->rtt_nearcongest_weight_factor); +#endif + if (pacing_timer) + delay_loop(pacing_timer); + } + } + FinishTrafficActions(); +} + +/* + * A version of the transmit loop that supports TCP rate limiting using a token bucket + */ +void Client::RunRateLimitedTCP () { + double tokens = 0; + Timestamp time1, time2; + int burst_size = mSettings->mBufLen; + int burst_remaining = 0; + int burst_id = 1; + + long var_rate = mSettings->mAppRate; + int fatalwrite_err = 0; + + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + while (InProgress() && !fatalwrite_err) { + reportstruct->writecnt = 0; + // Add tokens per the loop time + time2.setnow(); + if (isVaryLoad(mSettings)) { + static Timestamp time3; + if (time2.subSec(time3) >= VARYLOAD_PERIOD) { + var_rate = lognormal(mSettings->mAppRate,mSettings->mVariance); + time3 = time2; + if (var_rate < 0) + var_rate = 0; + } + } + tokens += time2.subSec(time1) * (var_rate / 8.0); + time1 = time2; + if (tokens >= 0.0) { + if (isModeAmount(mSettings)) { + reportstruct->packetLen = ((mSettings->mAmount < static_cast<unsigned>(mSettings->mBufLen)) ? mSettings->mAmount : mSettings->mBufLen); + } else { + reportstruct->packetLen = mSettings->mBufLen; + } + // perform write + int len = 0; + int len2 = 0; + if (burst_remaining == 0) { + burst_remaining = mSettings->mBufLen; + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->sentTime = reportstruct->packetTime; + WriteTcpTxHdr(reportstruct, burst_size, burst_id++); + // perform write + if (isTripTime(mSettings)) { + len = writen(mySocket, mSettings->mBuf, mSettings->mBufLen, &reportstruct->writecnt); + WARN(len != mSettings->mBufLen, "burst write failed"); + } else { + len = writen(mySocket, mSettings->mBuf, sizeof(struct TCP_burst_payload), &reportstruct->writecnt); + WARN(len != sizeof(struct TCP_burst_payload), "burst hdr write failed"); + } + if (len < 0) { + len = 0; + if (NONFATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrAccount; + } else if (FATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrFatal; + WARN_errno(1, "write"); + fatalwrite_err = 1; + break; + } else { + reportstruct->errwrite=WriteErrNoAccount; + } + } else { + burst_remaining -= len; + } + // thread_debug("***write burst header %d id=%d", burst_size, (burst_id - 1)); + } else if (reportstruct->packetLen > burst_remaining) { + reportstruct->packetLen = burst_remaining; + } + if (burst_remaining > 0) { + len2 = write(mySocket, mSettings->mBuf, reportstruct->packetLen); + reportstruct->writecnt++; + } + if (len2 < 0) { + len2 = 0; + if (NONFATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrAccount; + } else if (FATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrFatal; + WARN_errno(1, "write"); + fatalwrite_err = 1; + break; + } else { + reportstruct->errwrite=WriteErrNoAccount; + } + } else { + // Consume tokens per the transmit + tokens -= (len + len2); + totLen += (len + len2);; + reportstruct->errwrite=WriteNoErr; + } + time2.setnow(); + reportstruct->packetLen = len + len2; + reportstruct->packetTime.tv_sec = time2.getSecs(); + reportstruct->packetTime.tv_usec = time2.getUsecs(); + reportstruct->sentTime = reportstruct->packetTime; + if (isModeAmount(mSettings)) { + /* mAmount may be unsigned, so don't let it underflow! */ + if (mSettings->mAmount >= static_cast<unsigned long>(reportstruct->packetLen)) { + mSettings->mAmount -= static_cast<unsigned long>(reportstruct->packetLen); + } else { + mSettings->mAmount = 0; + } + } + if (!one_report) { + myReportPacket(); + } + } else { + // Use a 4 usec delay to fill tokens +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (isWritePrefetch(mSettings)) { + AwaitWriteSelectEventTCP(); + } else +#endif + { + delay_loop(4); + } + } + } + FinishTrafficActions(); +} + +#if HAVE_DECL_TCP_NOTSENT_LOWAT +inline bool Client::AwaitWriteSelectEventTCP (void) { + int rc; + struct timeval timeout; + fd_set writeset; + FD_ZERO(&writeset); + FD_SET(mySocket, &writeset); + if (isModeTime(mSettings)) { + Timestamp write_event_timeout(0,0); + if (mSettings->mInterval && (mSettings->mIntervalMode == kInterval_Time)) { + write_event_timeout.add((double) mSettings->mInterval / 1e6 * 2.0); + } else { + write_event_timeout.add((double) mSettings->mAmount / 1e2 * 4.0); + } + timeout.tv_sec = write_event_timeout.getSecs(); + timeout.tv_usec = write_event_timeout.getUsecs(); + } else { + timeout.tv_sec = 10; // longest is 10 seconds + timeout.tv_usec = 0; + } + + if ((rc = select(mySocket + 1, NULL, &writeset, NULL, &timeout)) <= 0) { + WARN_errno((rc < 0), "select"); +#ifdef HAVE_THREAD_DEBUG + if (rc == 0) + thread_debug("AwaitWrite timeout"); +#endif + return false; + } + return true; +} + +void Client::RunWriteEventsTCP () { + int burst_id = 0; + int writelen = mSettings->mBufLen; + Timestamp write_end; + + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + while (InProgress()) { + if (isModeAmount(mSettings)) { + writelen = ((mSettings->mAmount < static_cast<unsigned>(mSettings->mBufLen)) ? mSettings->mAmount : mSettings->mBufLen); + } + now.setnow(); + reportstruct->write_time = 0; + if (isTcpWriteTimes(mSettings)) { + write_start = now; + } + bool rc = AwaitWriteSelectEventTCP(); + reportstruct->emptyreport = (rc == false) ? 1 : 0; + if (rc) { + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + WriteTcpTxHdr(reportstruct, writelen, ++burst_id); + reportstruct->sentTime = reportstruct->packetTime; + reportstruct->packetLen = writen(mySocket, mSettings->mBuf, writelen, &reportstruct->writecnt); + if (reportstruct->packetLen <= 0) { + WARN_errno((reportstruct->packetLen < 0), "event writen()"); + if (reportstruct->packetLen == 0) { + peerclose = true; + } + reportstruct->packetLen = 0; + reportstruct->emptyreport = 1; + } else if (isTcpWriteTimes(mSettings)) { + write_end.setnow(); + reportstruct->write_time = write_end.subUsec(write_start); + } + } + if (isModeAmount(mSettings) && !reportstruct->emptyreport) { + /* mAmount may be unsigned, so don't let it underflow! */ + if (mSettings->mAmount >= static_cast<unsigned long>(reportstruct->packetLen)) { + mSettings->mAmount -= static_cast<unsigned long>(reportstruct->packetLen); + } else { + mSettings->mAmount = 0; + } + } + if (!one_report) { + myReportPacket(); + } + } + FinishTrafficActions(); +} +#endif +void Client::RunBounceBackTCP () { + int burst_id = 0; + int writelen = mSettings->mBufLen; + memset(mSettings->mBuf, 0x5A, sizeof(struct bounceback_hdr)); + if (mSettings->mInterval && (mSettings->mIntervalMode == kInterval_Time)) { + int sotimer = static_cast<int>(round(mSettings->mInterval / 2.0)); + SetSocketOptionsReceiveTimeout(mSettings, sotimer); + SetSocketOptionsSendTimeout(mSettings, sotimer); + } else if (isModeTime(mSettings)) { + int sotimer = static_cast<int>(round(mSettings->mAmount * 10000) / 2); + SetSocketOptionsReceiveTimeout(mSettings, sotimer); + SetSocketOptionsSendTimeout(mSettings, sotimer); + } + if (isModeTime(mSettings)) { + uintmax_t end_usecs = (mSettings->mAmount * 10000); + if (int err = set_itimer(end_usecs)) { + FAIL_errno(err != 0, "setitimer", mSettings); + } + } + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + while (InProgress()) { + int n; + reportstruct->writecnt = 0; + bool isFirst; + if (framecounter) { + burst_id = framecounter->wait_tick(&reportstruct->sched_err); + PostNullEvent(true); // this will set the now timestamp + reportstruct->sentTime.tv_sec = now.getSecs(); + reportstruct->sentTime.tv_usec = now.getUsecs(); + isFirst = true; + } else { + burst_id++; + isFirst = false; + } + int bb_burst = (mSettings->mBounceBackBurst > 0) ? mSettings->mBounceBackBurst : 1; + while (bb_burst > 0) { + bb_burst--; + if (isFirst) { + isFirst = false; + } else { + now.setnow(); + reportstruct->sentTime.tv_sec = now.getSecs(); + reportstruct->sentTime.tv_usec = now.getUsecs(); + } + WriteTcpTxBBHdr(reportstruct, burst_id, 0); + reportstruct->packetLen = writen(mySocket, mSettings->mBuf, writelen, &reportstruct->writecnt); + if (reportstruct->packetLen <= 0) { + if ((reportstruct->packetLen < 0) && FATALTCPWRITERR(errno)) { + reportstruct->errwrite=WriteErrFatal; + WARN_errno(1, "tcp bounceback write fatal error"); + peerclose = true; + } else if (reportstruct->packetLen == 0) { + peerclose = true; + } else if (reportstruct->packetLen != writelen) { + WARN_errno(1, "tcp bounceback writen incomplete"); + peerclose = true; + } else { + // retry the write + bb_burst++; + continue; + } + break; + } + if (reportstruct->packetLen == writelen) { + reportstruct->emptyreport = 0; + totLen += reportstruct->packetLen; + reportstruct->errwrite=WriteNoErr; +#if HAVE_DECL_TCP_QUICKACK + if (isTcpQuickAck(mSettings)) { + int opt = 1; + Socklen_t len = sizeof(opt); + int rc = setsockopt(mySocket, IPPROTO_TCP, TCP_QUICKACK, + reinterpret_cast<char*>(&opt), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_QUICKACK"); + } +#endif + if ((n = recvn(mySocket, mSettings->mBuf, mSettings->mBounceBackBytes, 0)) == mSettings->mBounceBackBytes) { + struct bounceback_hdr *bbhdr = reinterpret_cast<struct bounceback_hdr *>(mSettings->mBuf); + now.setnow(); + reportstruct->sentTimeRX.tv_sec = ntohl(bbhdr->bbserverRx_ts.sec); + reportstruct->sentTimeRX.tv_usec = ntohl(bbhdr->bbserverRx_ts.usec); + reportstruct->sentTimeTX.tv_sec = ntohl(bbhdr->bbserverTx_ts.sec); + reportstruct->sentTimeTX.tv_usec = ntohl(bbhdr->bbserverTx_ts.usec); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->packetLen += n; + reportstruct->emptyreport = 0; + myReportPacket(); + } else if (n == 0) { + peerclose = true; + } else if (n < 0) { + if (FATALTCPREADERR(errno)) { + WARN_errno(1, "bounceback read"); + peerclose = true; + n = 0; + } else { + WARN(1, "timeout: bounceback read"); + } + } + } else if ((reportstruct->packetLen < 0 ) && NONFATALTCPWRITERR(errno)) { + reportstruct->packetLen = 0; + reportstruct->emptyreport = 1; + reportstruct->errwrite=WriteErrNoAccount; + myReportPacket(); + } else { + reportstruct->errwrite=WriteErrFatal; + reportstruct->packetLen = -1; + FAIL_errno(1, "tcp bounce-back write", mSettings); + } + } + } + WriteTcpTxBBHdr(reportstruct, 0x0, 1); + disarm_itimer(); + FinishTrafficActions(); +} +/* + * UDP send loop + */ +double Client::get_delay_target () { + double delay_target; + if (isIPG(mSettings)) { + delay_target = mSettings->mBurstIPG * 1000000; // convert from milliseconds to nanoseconds + } else { + // compute delay target in units of nanoseconds + if (mSettings->mAppRateUnits == kRate_BW) { + // compute delay for bandwidth restriction, constrained to [0,1] seconds + delay_target = (mSettings->mBufLen * ((kSecs_to_nsecs * kBytes_to_Bits) + / mSettings->mAppRate)); + } else { + delay_target = 1e9 / mSettings->mAppRate; + } + } + return delay_target; +} + +void Client::RunUDP () { + struct UDP_datagram* mBuf_UDP = reinterpret_cast<struct UDP_datagram*>(mSettings->mBuf); + int currLen; + + double delay_target = get_delay_target(); + double delay = 0; + double adjust = 0; + + // Set this to > 0 so first loop iteration will delay the IPG + currLen = 1; + double variance = mSettings->mVariance; + if (apply_first_udppkt_delay && (delay_target > 100000)) { + //the case when a UDP first packet went out in SendFirstPayload + delay_loop(static_cast<unsigned long>(delay_target / 1000)); + } + + while (InProgress()) { + // Test case: drop 17 packets and send 2 out-of-order: + // sequence 51, 52, 70, 53, 54, 71, 72 + //switch(datagramID) { + // case 53: datagramID = 70; break; + // case 71: datagramID = 53; break; + // case 55: datagramID = 71; break; + // default: break; + //} + now.setnow(); + reportstruct->writecnt = 1; + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->sentTime = reportstruct->packetTime; + if (isVaryLoad(mSettings) && mSettings->mAppRateUnits == kRate_BW) { + static Timestamp time3; + if (now.subSec(time3) >= VARYLOAD_PERIOD) { + long var_rate = lognormal(mSettings->mAppRate,variance); + if (var_rate < 0) + var_rate = 0; + delay_target = (mSettings->mBufLen * ((kSecs_to_nsecs * kBytes_to_Bits) / var_rate)); + time3 = now; + } + } + // store datagram ID into buffer + WritePacketID(reportstruct->packetID); + mBuf_UDP->tv_sec = htonl(reportstruct->packetTime.tv_sec); + mBuf_UDP->tv_usec = htonl(reportstruct->packetTime.tv_usec); + + // Adjustment for the running delay + // o measure how long the last loop iteration took + // o calculate the delay adjust + // - If write succeeded, adjust = target IPG - the loop time + // - If write failed, adjust = the loop time + // o then adjust the overall running delay + // Note: adjust units are nanoseconds, + // packet timestamps are microseconds + if (currLen > 0) + adjust = delay_target + \ + (1000.0 * lastPacketTime.subUsec(reportstruct->packetTime)); + else + adjust = 1000.0 * lastPacketTime.subUsec(reportstruct->packetTime); + + lastPacketTime.set(reportstruct->packetTime.tv_sec, reportstruct->packetTime.tv_usec); + // Since linux nanosleep/busyloop can exceed delay + // there are two possible equilibriums + // 1) Try to perserve inter packet gap + // 2) Try to perserve requested transmit rate + // The latter seems preferred, hence use a running delay + // that spans the life of the thread and constantly adjust. + // A negative delay means the iperf app is behind. + delay += adjust; + // Don't let delay grow unbounded + if (delay < delay_lower_bounds) { + delay = delay_target; + } + + reportstruct->errwrite = WriteNoErr; + reportstruct->emptyreport = 0; + // perform write + if (isModeAmount(mSettings)) { + currLen = write(mySocket, mSettings->mBuf, (mSettings->mAmount < static_cast<unsigned>(mSettings->mBufLen)) ? mSettings->mAmount : mSettings->mBufLen); + } else { + currLen = write(mySocket, mSettings->mBuf, mSettings->mBufLen); + } + if (currLen < 0) { + reportstruct->packetID--; + if (FATALUDPWRITERR(errno)) { + reportstruct->errwrite = WriteErrFatal; + WARN_errno(1, "write"); + break; + } else { + reportstruct->errwrite = WriteErrAccount; + currLen = 0; + } + reportstruct->emptyreport = 1; + } + + if (isModeAmount(mSettings)) { + /* mAmount may be unsigned, so don't let it underflow! */ + if (mSettings->mAmount >= static_cast<unsigned long>(currLen)) { + mSettings->mAmount -= static_cast<unsigned long>(currLen); + } else { + mSettings->mAmount = 0; + } + } + + // report packets + reportstruct->packetLen = static_cast<unsigned long>(currLen); + reportstruct->prevPacketTime = myReport->info.ts.prevpacketTime; + myReportPacket(); + reportstruct->packetID++; + myReport->info.ts.prevpacketTime = reportstruct->packetTime; + // Insert delay here only if the running delay is greater than 100 usec, + // otherwise don't delay and immediately continue with the next tx. + if (delay >= 100000) { + // Convert from nanoseconds to microseconds + // and invoke the microsecond delay + delay_loop(static_cast<unsigned long>(delay / 1000)); + } + } + FinishTrafficActions(); +} + +/* + * UDP isochronous send loop + */ +void Client::RunUDPIsochronous () { + struct UDP_datagram* mBuf_UDP = reinterpret_cast<struct UDP_datagram*>(mSettings->mBuf); + // skip over the UDP datagram (seq no, timestamp) to reach the isoch fields + struct client_udp_testhdr *udp_payload = reinterpret_cast<client_udp_testhdr *>(mSettings->mBuf); + + double delay_target = mSettings->mBurstIPG * 1000000; // convert from milliseconds to nanoseconds + double delay = 0; + double adjust = 0; + int currLen = 1; + int frameid=0; + Timestamp t1; + + // make sure the packet can carry the isoch payload + if (!framecounter) { + framecounter = new Isochronous::FrameCounter(mSettings->mFPS); + } + udp_payload->isoch.burstperiod = htonl(framecounter->period_us()); + + int initdone = 0; + int fatalwrite_err = 0; + while (InProgress() && !fatalwrite_err) { + int bytecnt = static_cast<int>(lognormal(mSettings->mMean,mSettings->mVariance)) / (mSettings->mFPS * 8); + if (bytecnt < udp_payload_minimum) + bytecnt = udp_payload_minimum; + delay = 0; + + // printf("bits=%d\n", (int) (mSettings->mFPS * bytecnt * 8)); + udp_payload->isoch.burstsize = htonl(bytecnt); + udp_payload->isoch.prevframeid = htonl(frameid); + reportstruct->burstsize=bytecnt; + frameid = framecounter->wait_tick(&reportstruct->sched_err); + reportstruct->scheduled = true; + udp_payload->isoch.frameid = htonl(frameid); + lastPacketTime.setnow(); + if (!initdone) { + initdone = 1; + udp_payload->isoch.start_tv_sec = htonl(lastPacketTime.getSecs()); + udp_payload->isoch.start_tv_usec = htonl(lastPacketTime.getUsecs()); + } + while ((bytecnt > 0) && InProgress()) { + t1.setnow(); + reportstruct->packetTime.tv_sec = t1.getSecs(); + reportstruct->packetTime.tv_usec = t1.getUsecs(); + reportstruct->sentTime = reportstruct->packetTime; + mBuf_UDP->tv_sec = htonl(reportstruct->packetTime.tv_sec); + mBuf_UDP->tv_usec = htonl(reportstruct->packetTime.tv_usec); + WritePacketID(reportstruct->packetID); + + // Adjustment for the running delay + // o measure how long the last loop iteration took + // o calculate the delay adjust + // - If write succeeded, adjust = target IPG - the loop time + // - If write failed, adjust = the loop time + // o then adjust the overall running delay + // Note: adjust units are nanoseconds, + // packet timestamps are microseconds + if (currLen > 0) + adjust = delay_target + \ + (1000.0 * lastPacketTime.subUsec(reportstruct->packetTime)); + else + adjust = 1000.0 * lastPacketTime.subUsec(reportstruct->packetTime); + + lastPacketTime.set(reportstruct->packetTime.tv_sec, reportstruct->packetTime.tv_usec); + // Since linux nanosleep/busyloop can exceed delay + // there are two possible equilibriums + // 1) Try to perserve inter packet gap + // 2) Try to perserve requested transmit rate + // The latter seems preferred, hence use a running delay + // that spans the life of the thread and constantly adjust. + // A negative delay means the iperf app is behind. + delay += adjust; + // Don't let delay grow unbounded + // if (delay < delay_lower_bounds) { + // delay = delay_target; + // } + + reportstruct->errwrite = WriteNoErr; + reportstruct->emptyreport = 0; + reportstruct->writecnt = 1; + + // perform write + if (isModeAmount(mSettings) && (mSettings->mAmount < static_cast<unsigned>(mSettings->mBufLen))) { + udp_payload->isoch.remaining = htonl(mSettings->mAmount); + reportstruct->remaining=mSettings->mAmount; + currLen = write(mySocket, mSettings->mBuf, mSettings->mAmount); + } else { + udp_payload->isoch.remaining = htonl(bytecnt); + reportstruct->remaining=bytecnt; + currLen = write(mySocket, mSettings->mBuf, (bytecnt < mSettings->mBufLen) ? bytecnt : mSettings->mBufLen); + } + + if (currLen < 0) { + reportstruct->packetID--; + reportstruct->emptyreport = 1; + currLen = 0; + if (FATALUDPWRITERR(errno)) { + reportstruct->errwrite = WriteErrFatal; + WARN_errno(1, "write"); + fatalwrite_err = 1; + } else { + reportstruct->errwrite = WriteErrAccount; + } + } else { + bytecnt -= currLen; + if (!bytecnt) + reportstruct->transit_ready = 1; + else + reportstruct->transit_ready = 0; + // adjust bytecnt so last packet of burst is greater or equal to min packet + if ((bytecnt > 0) && (bytecnt < udp_payload_minimum)) { + bytecnt = udp_payload_minimum; + udp_payload->isoch.burstsize = htonl(bytecnt); + reportstruct->burstsize=bytecnt; + } + } + if (isModeAmount(mSettings)) { + /* mAmount may be unsigned, so don't let it underflow! */ + if (mSettings->mAmount >= static_cast<unsigned long>(currLen)) { + mSettings->mAmount -= static_cast<unsigned long>(currLen); + } else { + mSettings->mAmount = 0; + } + } + // report packets + + reportstruct->frameID=frameid; + reportstruct->packetLen = static_cast<unsigned long>(currLen); + reportstruct->prevPacketTime = myReport->info.ts.prevpacketTime; + myReportPacket(); + reportstruct->scheduled = false; // reset to false after the report + reportstruct->packetID++; + myReport->info.ts.prevpacketTime = reportstruct->packetTime; + // Insert delay here only if the running delay is greater than 1 usec, + // otherwise don't delay and immediately continue with the next tx. + if (delay >= 1000) { + // Convert from nanoseconds to microseconds + // and invoke the microsecond delay + delay_loop(static_cast<unsigned long>(delay / 1000)); + } + } + } + FinishTrafficActions(); +} +// end RunUDPIsoch + +inline void Client::WritePacketID (intmax_t packetID) { + struct UDP_datagram * mBuf_UDP = reinterpret_cast<struct UDP_datagram *>(mSettings->mBuf); + // store datagram ID into buffer +#ifdef HAVE_INT64_T + // Pack signed 64bit packetID into unsigned 32bit id1 + unsigned + // 32bit id2. A legacy server reading only id1 will still be able + // to reconstruct a valid signed packet ID number up to 2^31. + uint32_t id1, id2; + id1 = packetID & 0xFFFFFFFFLL; + id2 = (packetID & 0xFFFFFFFF00000000LL) >> 32; + + mBuf_UDP->id = htonl(id1); + mBuf_UDP->id2 = htonl(id2); + +#ifdef HAVE_PACKET_DEBUG + printf("id %" PRIdMAX " (0x%" PRIxMAX ") -> 0x%x, 0x%x\n", + packetID, packetID, id1, id2); +#endif +#else + mBuf_UDP->id = htonl((reportstruct->packetID)); +#endif +} + +inline void Client::WriteTcpTxHdr (struct ReportStruct *reportstruct, int burst_size, int burst_id) { + struct TCP_burst_payload * mBuf_burst = reinterpret_cast<struct TCP_burst_payload *>(mSettings->mBuf); + // store packet ID into buffer + reportstruct->packetID += burst_size; + mBuf_burst->start_tv_sec = htonl(myReport->info.ts.startTime.tv_sec); + mBuf_burst->start_tv_usec = htonl(myReport->info.ts.startTime.tv_usec); + +#ifdef HAVE_INT64_T + // Pack signed 64bit packetID into unsigned 32bit id1 + unsigned + // 32bit id2. A legacy server reading only id1 will still be able + // to reconstruct a valid signed packet ID number up to 2^31. + uint32_t id1, id2; + id1 = reportstruct->packetID & 0xFFFFFFFFLL; + id2 = (reportstruct->packetID & 0xFFFFFFFF00000000LL) >> 32; + + mBuf_burst->seqno_lower = htonl(id1); + mBuf_burst->seqno_upper = htonl(id2); + +#ifdef HAVE_PACKET_DEBUG + printf("id %" PRIdMAX " (0x%" PRIxMAX ") -> 0x%x, 0x%x\n", + reportstruct->packetID, reportstruct->packetID, id1, id2); +#endif +#else + mBuf_burst->seqno_lower = htonl((reportstruct->packetID)); + mBuf_burst->seqno_upper = htonl(0x0); +#endif + mBuf_burst->send_tt.write_tv_sec = htonl(reportstruct->packetTime.tv_sec); + mBuf_burst->send_tt.write_tv_usec = htonl(reportstruct->packetTime.tv_usec); + mBuf_burst->burst_id = htonl((uint32_t)burst_id); + mBuf_burst->burst_size = htonl((uint32_t)burst_size); + reportstruct->frameID=burst_id; + reportstruct->burstsize=burst_size; +// printf("**** Write tcp burst header size= %d id = %d\n", burst_size, burst_id); +} + +// See payloads.h +void Client::WriteTcpTxBBHdr (struct ReportStruct *reportstruct, uint32_t bbid, int final) { + struct bounceback_hdr * mBuf_bb = reinterpret_cast<struct bounceback_hdr *>(mSettings->mBuf); + // store packet ID into buffer + uint32_t flags = HEADER_BOUNCEBACK; + uint32_t bbflags = 0x0; + mBuf_bb->flags = htonl(flags); + if (isTripTime(mSettings)) { + bbflags |= HEADER_BBCLOCKSYNCED; + } + if (mSettings->mTOS) { + bbflags |= HEADER_BBTOS; + mBuf_bb->tos = htons((mSettings->mTOS & 0xFF)); + } + if (isTcpQuickAck(mSettings)) { + bbflags |= HEADER_BBQUICKACK; + } + mBuf_bb->bbRunTime = 0x0; + if (final) { + bbflags |= HEADER_BBSTOP; + } + mBuf_bb->bbflags = htons(bbflags); + mBuf_bb->bbsize = htonl(mSettings->mBufLen); + mBuf_bb->bbid = htonl(bbid); + mBuf_bb->bbclientTx_ts.sec = htonl(reportstruct->packetTime.tv_sec); + mBuf_bb->bbclientTx_ts.usec = htonl(reportstruct->packetTime.tv_usec); + mBuf_bb->bbserverRx_ts.sec = -1; + mBuf_bb->bbserverRx_ts.usec = -1; + mBuf_bb->bbserverTx_ts.sec = -1; + mBuf_bb->bbserverTx_ts.usec = -1; + mBuf_bb->bbhold = htonl(mSettings->mBounceBackHold); +} + +inline bool Client::InProgress (void) { + // Read the next data block from + // the file if it's file input + if (isFileInput(mSettings)) { + Extractor_getNextDataBlock(readAt, mSettings); + return Extractor_canRead(mSettings) != 0; + } + // fprintf(stderr, "DEBUG: SI=%d PC=%d T=%d A=%d\n", sInterupted, peerclose, (isModeTime(mSettings) && mEndTime.before(reportstruct->packetTime)), (isModeAmount(mSettings) && (mSettings->mAmount <= 0))); + return !(sInterupted || peerclose || \ + (isModeTime(mSettings) && mEndTime.before(reportstruct->packetTime)) || + (isModeAmount(mSettings) && (mSettings->mAmount <= 0))); +} + +inline void Client::tcp_shutdown (void) { + if ((mySocket != INVALID_SOCKET) && isConnected()) { + int rc = shutdown(mySocket, SHUT_WR); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client calls shutdown() SHUTW_WR on tcp socket %d", mySocket); +#endif + WARN_errno(rc == SOCKET_ERROR, "shutdown"); + if (!rc && !isFullDuplex(mSettings)) + AwaitServerCloseEvent(); + } +} + +/* + * Common things to do to finish a traffic thread + * + * Notes on the negative packet count or seq no: + * A negative packet id is used to tell the server + * this UDP stream is terminating. The server will remove + * the sign. So a decrement will be seen as increments by + * the server (e.g, -1000, -1001, -1002 as 1000, 1001, 1002) + * If the retries weren't decrement here the server can get out + * of order packets per these retries actually being received + * by the server (e.g. -1000, -1000, -1000) + */ +void Client::FinishTrafficActions () { + disarm_itimer(); + // Shutdown the TCP socket's writes as the event for the server to end its traffic loop + if (!isUDP(mSettings)) { + tcp_shutdown(); + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + if (one_report) { + /* + * For TCP and if not doing interval or enhanced reporting (needed for write accounting), + * then report the entire transfer as one big packet + * + */ + reportstruct->packetLen = totLen; + } + } else { + // stop timing + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->sentTime = reportstruct->packetTime; + // send a final terminating datagram + // Don't count in the mTotalLen. The server counts this one, + // but didn't count our first datagram, so we're even now. + // The negative datagram ID signifies termination to the server. + WritePacketID(-reportstruct->packetID); + struct UDP_datagram * mBuf_UDP = reinterpret_cast<struct UDP_datagram *>(mSettings->mBuf); + mBuf_UDP->tv_sec = htonl(reportstruct->packetTime.tv_sec); + mBuf_UDP->tv_usec = htonl(reportstruct->packetTime.tv_usec); + int len = write(mySocket, mSettings->mBuf, mSettings->mBufLen); +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDP client sent final packet per negative seqno %ld", -reportstruct->packetID); +#endif + if (len > 0) { + reportstruct->packetLen = len; + myReportPacket(); + } + reportstruct->packetLen = 0; + } + int do_close = EndJob(myJob, reportstruct); + if (isIsochronous(mSettings) && (myReport->info.schedule_error.cnt > 2)) { + fprintf(stderr,"%sIsoch schedule errors (mean/min/max/stdev) = %0.3f/%0.3f/%0.3f/%0.3f ms\n",mSettings->mTransferIDStr, \ + ((myReport->info.schedule_error.sum / myReport->info.schedule_error.cnt) * 1e-3), (myReport->info.schedule_error.min * 1e-3), \ + (myReport->info.schedule_error.max * 1e-3), (1e-3 * (sqrt(myReport->info.schedule_error.m2 / (myReport->info.schedule_error.cnt - 1))))); + } + if (isUDP(mSettings) && !isMulticast(mSettings) && !isNoUDPfin(mSettings)) { + /* + * For UDP, there is a final handshake between the client and the server, + * do that now (unless requested no to) + */ + AwaitServerFinPacket(); + } + if (do_close) { +#if HAVE_THREAD_DEBUG + thread_debug("client close sock=%d", mySocket); +#endif + int rc = close(mySocket); + WARN_errno(rc == SOCKET_ERROR, "client close"); + } + Iperf_remove_host(mSettings); + FreeReport(myJob); + if (framecounter) + DELETE_PTR(framecounter); +} + +/* ------------------------------------------------------------------- + * Await for the server's fin packet which also has the server + * stats to displayed on the client. Attempt to re-transmit + * until the fin is received + * ------------------------------------------------------------------- */ +#define RETRYTIMER 10000 //units of us +#define RETRYCOUNT (2 * 1000000 / RETRYTIMER) // 2 seconds worth of retries +void Client::AwaitServerFinPacket () { + int rc; + fd_set readSet; + struct timeval timeout; + int ack_success = 0; + int count = RETRYCOUNT; + while (--count >= 0) { + // wait until the socket is readable, or our timeout expires + FD_ZERO(&readSet); + FD_SET(mySocket, &readSet); + timeout.tv_sec = 0; + timeout.tv_usec = RETRYTIMER; + rc = select(mySocket+1, &readSet, NULL, NULL, &timeout); + FAIL_errno(rc == SOCKET_ERROR, "select", mSettings); + // rc= zero means select's read timed out + if (rc == 0) { + // try to trigger another FIN by resending a negative seq no + WritePacketID(-(++reportstruct->packetID)); + // write data + rc = write(mySocket, mSettings->mBuf, mSettings->mBufLen); + WARN_errno(rc < 0, "write-fin"); +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDP client retransmit final packet per negative seqno %ld", -reportstruct->packetID); +#endif + } else { + // socket ready to read, this packet size + // is set by the server. Assume it's large enough + // to contain the final server packet + rc = read(mySocket, mSettings->mBuf, MAXUDPBUF); + + // dump any 2.0.13 client acks sent at the start of traffic + if (rc == sizeof(client_hdr_ack)) { + struct client_hdr_ack *ack = reinterpret_cast<struct client_hdr_ack *>(mSettings->mBuf); + if (ntohl(ack->typelen.type) == CLIENTHDRACK) { + // printf("**** dump stale ack \n"); + continue; + } + } + + WARN_errno(rc < 0, "read"); + if (rc > 0) { + ack_success = 1; +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDP client received server relay report ack (%d)", -reportstruct->packetID); +#endif + if (mSettings->mReportMode != kReport_CSV) { + PostReport(InitServerRelayUDPReport(mSettings, reinterpret_cast<server_hdr*>(reinterpret_cast<UDP_datagram*>(mSettings->mBuf) + 1))); + } + break; + } + } + } + if ((!ack_success) && (mSettings->mReportMode != kReport_CSV)) + fprintf(stderr, warn_no_ack, mySocket, (isModeTime(mSettings) ? 10 : 1)); +} + + +void Client::PostNullEvent (void) { + assert(myReport!=NULL); + // push a nonevent into the packet ring + // this will cause the reporter to process + // up to this event + memset(reportstruct, 0, sizeof(struct ReportStruct)); + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->emptyreport=1; + myReportPacket(); +} + +void Client::PostNullEvent (bool isFirst) { + assert(myReport!=NULL); + // push a nonevent into the packet ring + // this will cause the reporter to process + // up to this event + memset(reportstruct, 0, sizeof(struct ReportStruct)); + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->emptyreport=1; + reportstruct->scheduled = isFirst; + myReportPacket(); +} + +// The client end timer is based upon the final fin, fin-ack w/the server +// A way to detect this is to hang a recv and wait for the zero byte +// return indicating the socket is closed for recv per the server +// closing it's socket +#define MINAWAITCLOSEUSECS 2000000 +void Client::AwaitServerCloseEvent () { + // the await detection can take awhile so post a non event ahead of it + PostNullEvent(); + unsigned int amount_usec = \ + (isModeTime(mSettings) ? static_cast<int>(mSettings->mAmount * 10000) : MINAWAITCLOSEUSECS); + if (amount_usec < MINAWAITCLOSEUSECS) + amount_usec = MINAWAITCLOSEUSECS; + SetSocketOptionsReceiveTimeout(mSettings, amount_usec); + int rc; + while ((rc = recv(mySocket, mSettings->mBuf, mSettings->mBufLen, 0) > 0)) {}; + if (rc < 0) + WARN_errno(1, "client await server close"); + + if (rc==0) { + connected = false; +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client detected server close %d", mySocket); +#endif + } +} + +int Client::SendFirstPayload () { + int pktlen = 0; + if (!isConnectOnly(mSettings)) { + if (myReport && !TimeZero(myReport->info.ts.startTime) && !(mSettings->mMode == kTest_TradeOff)) { + reportstruct->packetTime = myReport->info.ts.startTime; + } else { + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + } + pattern(mSettings->mBuf, mSettings->mBufLen); + if (isTxStartTime(mSettings)) { + pktlen = Settings_GenerateClientHdr(mSettings, (void *) mSettings->mBuf, mSettings->txstart_epoch); + } else { + pktlen = Settings_GenerateClientHdr(mSettings, (void *) mSettings->mBuf, reportstruct->packetTime); + } + if (pktlen > 0) { + if (isUDP(mSettings)) { + struct client_udp_testhdr *tmphdr = reinterpret_cast<struct client_udp_testhdr *>(mSettings->mBuf); + WritePacketID(reportstruct->packetID); + tmphdr->seqno_ts.tv_sec = htonl(reportstruct->packetTime.tv_sec); + tmphdr->seqno_ts.tv_usec = htonl(reportstruct->packetTime.tv_usec); + udp_payload_minimum = pktlen; +#if HAVE_DECL_MSG_DONTWAIT + pktlen = send(mySocket, mSettings->mBuf, (pktlen > mSettings->mBufLen) ? pktlen : mSettings->mBufLen, MSG_DONTWAIT); +#else + pktlen = send(mySocket, mSettings->mBuf, (pktlen > mSettings->mBufLen) ? pktlen : mSettings->mBufLen, 0); +#endif + apply_first_udppkt_delay = true; + } else { +#if HAVE_DECL_TCP_NODELAY + if (!isNoDelay(mSettings) && isPeerVerDetect(mSettings) && isTripTime(mSettings)) { + int optflag=1; + int rc; + // Disable Nagle to reduce latency of this intial message + if ((rc = setsockopt(mSettings->mSock, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&optflag), sizeof(int))) < 0) { + WARN_errno(rc < 0, "tcpnodelay"); + } + } +#endif +#if HAVE_DECL_MSG_DONTWAIT + pktlen = send(mySocket, mSettings->mBuf, pktlen, MSG_DONTWAIT); +#else + pktlen = send(mySocket, mSettings->mBuf, pktlen, 0); +#endif + if (isPeerVerDetect(mSettings) && !isServerReverse(mSettings)) { + PeerXchange(); + } +#if HAVE_DECL_TCP_NODELAY + if (!isNoDelay(mSettings) && isPeerVerDetect(mSettings) && isTripTime(mSettings)) { + int optflag=0; + int rc; + // Disable Nagle to reduce latency of this intial message + if ((rc = setsockopt(mSettings->mSock, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&optflag), sizeof(int))) < 0) { + WARN_errno(rc < 0, "tcpnodelay"); + } + } +#endif + } + WARN_errno(pktlen < 0, "send_hdr"); + } + } + return pktlen; +} + +void Client::PeerXchange () { + int n; + client_hdr_ack ack; + /* + * Hang read and see if this is a header ack message + */ + int readlen = isTripTime(mSettings) ? sizeof(struct client_hdr_ack) : (sizeof(struct client_hdr_ack) - sizeof(struct client_hdr_ack_ts)); + if ((n = recvn(mySocket, reinterpret_cast<char *>(&ack), readlen, 0)) == readlen) { + if (ntohl(ack.typelen.type) == CLIENTHDRACK) { + mSettings->peer_version_u = ntohl(ack.version_u); + mSettings->peer_version_l = ntohl(ack.version_l); + if (isTripTime(mSettings)) { + Timestamp now; + Timestamp senttx(ntohl(ack.ts.sent_tv_sec), ntohl(ack.ts.sent_tv_usec)); + Timestamp sentrx(ntohl(ack.ts.sentrx_tv_sec), ntohl(ack.ts.sentrx_tv_usec)); + Timestamp acktx(ntohl(ack.ts.ack_tv_sec), ntohl(ack.ts.ack_tv_usec)); + Timestamp ackrx(now.getSecs(), now.getUsecs()); + double str = (sentrx.get() - senttx.get()) * 1e3; + double atr = (now.get() - acktx.get()) * 1e3; + double rtt = str + atr; + double halfrtt = rtt / 2.0; + fprintf(stderr,"%sClock sync check (ms): RTT/Half=(%0.3f/%0.3f) OWD-send/ack/asym=(%0.3f/%0.3f/%0.3f)\n",mSettings->mTransferIDStr, rtt, halfrtt, str, atr, (str-atr)); + } + } + } else { + WARN_errno(1, "recvack"); + } +} + +/* + * BarrierClient allows for multiple stream clients to be syncronized + */ +int Client::BarrierClient (struct BarrierMutex *barrier) { + int last = 0; +#ifdef HAVE_THREAD + assert(barrier != NULL); + Condition_Lock(barrier->await); + if (--barrier->count <= 0) { + // store the barrier release timer +#ifdef HAVE_CLOCK_GETTIME + struct timespec t1; + clock_gettime(CLOCK_REALTIME, &t1); + barrier->release_time.tv_sec = t1.tv_sec; + barrier->release_time.tv_usec = t1.tv_nsec / 1000; +#else + gettimeofday(&barrier->release_time, NULL); +#endif + last = 1; + // last one wake's up everyone else + Condition_Broadcast(&barrier->await); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Barrier BROADCAST on condition %p", (void *)&barrier->await); +#endif + } else { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Barrier WAIT on condition %p count=%d", (void *)&barrier->await, barrier->count); +#endif + Condition_Wait(&barrier->await); + } + Condition_Unlock(barrier->await); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Barrier EXIT on condition %p", (void *)&barrier->await); +#endif +#else + last = 1; +#endif // HAVE_THREAD + return last; +} diff --git a/src/Extractor.c b/src/Extractor.c new file mode 100644 index 0000000..4678018 --- /dev/null +++ b/src/Extractor.c @@ -0,0 +1,188 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * Extractor.cpp + * by Ajay Tirumala (tirumala@ncsa.uiuc.edu) + * ------------------------------------------------------------------- + * Extract data from a file, used to measure the transfer rates + * for various stream formats. + * + * E.g. Use a gzipped file to measure the transfer rates for + * compressed data + * Use an MPEG file to measure the transfer rates of + * Multimedia data formats + * Use a plain BMP file to measure the transfer rates of + * Uncompressed data + * + * This is beneficial especially in measuring bandwidth across WAN + * links where data compression takes place before data transmission + * ------------------------------------------------------------------- + */ + +#include "Extractor.h" + + +/** + * Constructor + * @arg fileName Name of the file + * @arg size Block size for reading + * Open the file and set the block size + */ +void Extractor_Initialize ( char *fileName, int inSize, struct thread_Settings *mSettings ) { + + if ( (mSettings->Extractor_file = fopen (fileName, "rb")) == NULL ) { + fprintf( stderr, "Unable to open the file stream\n"); + fprintf( stderr, "Will use the default data stream\n"); + return; + } + mSettings->Extractor_size = inSize; +} + + +/** + * Constructor + * @arg fp File Pointer + * @arg size Block size for reading + * Set the block size,file pointer + */ +void Extractor_InitializeFile ( FILE *fp, int inSize, struct thread_Settings *mSettings ) { + mSettings->Extractor_file = fp; + mSettings->Extractor_size = inSize; +} + + +/** + * Destructor - Close the file + */ +void Extractor_Destroy ( struct thread_Settings *mSettings ) { + if ( mSettings->Extractor_file != NULL ) + fclose( mSettings->Extractor_file ); +} + + +/* + * Fetches the next data block from + * the file + * @arg block Pointer to the data read + * @return Number of bytes read + */ +int Extractor_getNextDataBlock ( char *data, struct thread_Settings *mSettings ) { + if ( Extractor_canRead( mSettings ) ) { + return(fread( data, 1, mSettings->Extractor_size, + mSettings->Extractor_file )); + } + return 0; +} + +/** + * Function which determines whether + * the file stream is still readable + * @return boolean true, if readable; false, if not + */ +int Extractor_canRead ( struct thread_Settings *mSettings ) { + return(( mSettings->Extractor_file != NULL ) + && !(feof( mSettings->Extractor_file ))); +} + +/** + * This is used to reduce the read size + * Used in UDP transfer to accomodate the + * the header (timestamp) + * @arg delta Size to reduce + */ +void Extractor_reduceReadSize ( int delta, struct thread_Settings *mSettings ) { + mSettings->Extractor_size -= delta; +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/Launch.cpp b/src/Launch.cpp new file mode 100644 index 0000000..9f0c633 --- /dev/null +++ b/src/Launch.cpp @@ -0,0 +1,478 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Launch.cpp + * by Kevin Gibbs <kgibbs@nlanr.net> + * ------------------------------------------------------------------- + * Functions to launch new server and client threads from C while + * the server and client are in C++. + * The launch function for reporters is in Reporter.c since it is + * in C and does not need a special launching function. + * ------------------------------------------------------------------- */ + +#include "headers.h" +#include "Thread.h" +#include "Settings.hpp" +#include "Client.hpp" +#include "Listener.hpp" +#include "Server.hpp" +#include "PerfSocket.hpp" +#include "active_hosts.h" +#include "SocketAddr.h" +#include "delay.h" + +static int fullduplex_startstop_barrier (struct BarrierMutex *barrier) { + int rc = 0; + assert(barrier != NULL); + Condition_Lock(barrier->await); + ++barrier->count; +#ifdef HAVE_THREAD_DEBUG + thread_debug("Fullduplex barrier incr to %d %p ", barrier->count, (void *)&barrier->await, rc); +#endif + if (barrier->count == 2) { + rc = 1; + // last one wake's up everyone else' +#ifdef HAVE_THREAD_DEBUG + thread_debug("Fullduplex startstop broadcast on condition %p ", (void *)&barrier->await, rc); +#endif + Condition_Broadcast(&barrier->await); + } else { + int timeout = barrier->timeout; + while ((barrier->count != 2) && (timeout > 0)) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Fullduplex startstop barrier wait %p %d/2 (%d)", (void *)&barrier->await, barrier->count, timeout); +#endif + Condition_TimedWait(&barrier->await, 1); + timeout--; + if ((timeout == 0) && (barrier->count != 2)) { + fprintf(stdout, "Barrier timeout per full duplex traffic\n"); + Condition_Unlock(barrier->await); + return -1; + } + } + barrier->count=0; + } + Condition_Unlock(barrier->await); + return rc; +} +int fullduplex_start_barrier (struct BarrierMutex *barrier) { + int rc = fullduplex_startstop_barrier(barrier); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Fullduplex start barrier done on condition %p rc=%d", (void *)&barrier->await, rc); +#endif + return rc; +} +int fullduplex_stop_barrier (struct BarrierMutex *barrier) { + int rc = fullduplex_startstop_barrier(barrier); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Fullduplex stop barrier done on condition %p rc=%d", (void *)&barrier->await, rc); +#endif + return rc; +} + +/* + * listener_spawn is responsible for creating a Listener class + * and launching the listener. It is provided as a means for + * the C thread subsystem to launch the listener C++ object. + */ +void listener_spawn(struct thread_Settings *thread) { + Listener *theListener = NULL; + // the Listener need to trigger a settings report + setReport(thread); + // start up a listener + theListener = new Listener(thread); + // Start listening + theListener->Run(); + DELETE_PTR(theListener); +} + +/* + * server_spawn is responsible for creating a Server class + * and launching the server. It is provided as a means for + * the C thread subsystem to launch the server C++ object. + */ +void server_spawn(struct thread_Settings *thread) { + Server *theServer = NULL; +#ifdef HAVE_THREAD_DEBUG + if (isBounceBack(thread)) { + thread_debug("spawn server bounce-back"); + } else { + thread_debug("spawn server settings=%p GroupSumReport=%p sock=%d", \ + (void *) thread, (void *)thread->mSumReport, thread->mSock); + } +#endif + // set traffic thread to realtime if needed +#if HAVE_SCHED_SETSCHEDULER + thread_setscheduler(thread); +#endif + // Start up the server + theServer = new Server(thread); + if (isTxStartTime(thread)) { + clock_usleep_abstime(&thread->txstart_epoch); + } + // Run the test + if (isUDP(thread)) { + theServer->RunUDP(); + } else { + if (isBounceBack(thread)) { + theServer->RunBounceBackTCP(); + } else { + theServer->RunTCP(); + } + } + DELETE_PTR(theServer); +} + +static void clientside_client_basic (struct thread_Settings *thread, Client *theClient) { + setTransferID(thread, 0); +#ifdef HAVE_THREAD_DEBUG + if (isBounceBack(thread)) { + thread_debug("Launch: spawn client bounce-back mode, size = %d", thread->mBurstSize); + } else { + thread_debug("Launch: client spawn thread basic (sock=%d)", thread->mSock); + } +#endif + SockAddr_remoteAddr(thread); + // Bounceback start delays the connect too + if (isBounceBack(thread)) { + if (isTxStartTime(thread)) { + theClient->mySockInit(); + clock_usleep_abstime(&thread->txstart_epoch); + } else if (isTxHoldback(thread)) { + unsetTxHoldback(thread); + theClient->mySockInit(); + clock_usleep(&thread->txholdback_timer); + } + } + theClient->my_connect(true); + if ((thread->mThreads > 1) && !isNoConnectSync(thread) && !isCompat(thread)) + // When -P > 1 then all threads finish connect before starting traffic + theClient->BarrierClient(thread->connects_done); + if (theClient->isConnected()) { + if ((thread->mThreads > 1) || isSumOnly(thread)) + Iperf_push_host(thread); + theClient->StartSynch(); + theClient->Run(); + } +} + +static void clientside_client_reverse (struct thread_Settings *thread, \ + struct thread_Settings *reverse_client, Client *theClient) { + setTransferID(thread, 0); + SockAddr_remoteAddr(thread); + theClient->my_connect(true); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Launch: client spawn thread reverse (sock=%d)", thread->mSock); +#endif + if ((thread->mThreads > 1) && !isNoConnectSync(thread)) + // When -P > 1 then all threads finish connect before starting traffic + theClient->BarrierClient(thread->connects_done); + if (theClient->isConnected()) { + FAIL((!reverse_client || !(thread->mSock > 0)), "Reverse test failed to start per thread settings or socket problem", thread); + setTransferID(reverse_client, 1); + theClient->StartSynch(); + reverse_client->mSock = thread->mSock; // use the same socket for both directions + reverse_client->mThreadMode = kMode_Server; + setReverse(reverse_client); + setNoUDPfin(reverse_client); // disable the fin report - no need + reverse_client->size_local = sizeof(iperf_sockaddr); + getsockname(reverse_client->mSock, reinterpret_cast<sockaddr*>(&reverse_client->local), &reverse_client->size_local); + if ((thread->mThreads > 1) || isSumOnly(thread)) + Iperf_push_host(reverse_client); + thread_start(reverse_client); + if (theClient->myJob) + FreeReport(theClient->myJob); + } +} + +static void clientside_client_fullduplex (struct thread_Settings *thread, \ + struct thread_Settings *reverse_client, Client *theClient) { + setTransferID(thread, 0); + SockAddr_remoteAddr(thread); + if (!isBounceBack(thread)) { + thread->mFullDuplexReport = InitSumReport(thread, -1, 1); + } + Settings_Copy(thread, &reverse_client, SHALLOW_COPY); + if ((thread->mThreads > 1) || isSumOnly(thread) || \ + (!(thread->mThreads > 1) && !isEnhanced(thread))) { + Iperf_push_host(thread); + Iperf_push_host(reverse_client); + } + assert(reverse_client != NULL); + setTransferID(reverse_client, 1); + theClient->my_connect(true); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Launch: client spawn thread fullduplex (sock=%d)", thread->mSock); +#endif + if ((thread->mThreads > 1) && !isNoConnectSync(thread)) + // When -P > 1 then all threads finish connect before starting traffic + theClient->BarrierClient(thread->connects_done); + if (theClient->isConnected()) { + thread->mFullDuplexReport->info.common->socket = thread->mSock; + FAIL((!reverse_client || !(thread->mSock > 0)), "Reverse test failed to start per thread settings or socket problem", thread); + reverse_client->mSock = thread->mSock; // use the same socket for both directions + reverse_client->mThreadMode = kMode_Server; + setReverse(reverse_client); + if (isModeTime(reverse_client)) { + reverse_client->mAmount += (SLOPSECS * 100); // add 2 sec for slop on reverse, units are 10 ms + } + thread_start(reverse_client); + if (theClient->StartSynch() != -1) { + theClient->Run(); + } + } +} + +static void serverside_client_fullduplex (struct thread_Settings *thread, Client *theClient) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Launch: Listener spawn client thread (fd sock=%d)", thread->mSock); +#endif + setTransferID(thread, 1); + if (theClient->StartSynch() != -1) { + theClient->Run(); + } +} + +static void serverside_client_bidir (struct thread_Settings *thread, Client *theClient) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Launch: Listener spawn client thread (bidir sock=%d)", thread->mSock); +#endif + setTransferID(thread, 1); + SockAddr_zeroAddress(&thread->peer); + SockAddr_remoteAddr(thread); + if (thread->mReportMode == kReport_CSV) { + setNoSettReport(thread); + setNoConnReport(thread); + } else { + unsetNoSettReport(thread); + unsetNoConnReport(thread); + } + setReport(thread); + theClient->my_connect(false); + if (theClient->isConnected()) { + Iperf_push_host(thread); + if (theClient->StartSynch() != -1) { + theClient->Run(); + } + } +} + +/* + * client_spawn is responsible for creating a Client class + * and launching the client. It is provided as a means for + * the C thread subsystem to launch the client C++ object. + * + * There are a few different client startup modes + * o) Normal + * o) Dual (-d or -r) (legacy) + * o) Reverse (Client side) (client acts like server) + * o) FullDuplex (Client side) client starts server + * o) ServerReverse (Server side) (listener starts a client) + * o) FullDuplex (Server side) (listener starts server & client) + * o) WriteAck + * + * Note: This runs in client thread context + */ +void client_spawn (struct thread_Settings *thread) { + Client *theClient = NULL; + + // set traffic thread to realtime if needed +#if HAVE_SCHED_SETSCHEDULER + thread_setscheduler(thread); +#endif + // start up the client + setTransferID(thread, 0); + theClient = new Client(thread); + // let the reporter thread go first in the case of -P greater than 1 + Condition_Lock(reporter_state.await); + while (!reporter_state.ready) { + Condition_TimedWait(&reporter_state.await, 1); + } + Condition_Unlock(reporter_state.await); + + if (isConnectOnly(thread)) { + theClient->ConnectPeriodic(); + } else if (!isServerReverse(thread)) { + // These are the client side spawning of clients + if (!isReverse(thread) && !isFullDuplex(thread)) { + clientside_client_basic(thread, theClient); + } else if (isReverse(thread) && !isFullDuplex(thread)) { + struct thread_Settings *reverse_thread = NULL; + Settings_Copy(thread, &reverse_thread, DEEP_COPY); + FAIL((reverse_thread == NULL), "Reverse thread alloc failed", thread); + clientside_client_reverse(thread, reverse_thread, theClient); + } else if (isFullDuplex(thread)) { + struct thread_Settings *reverse_thread = NULL; + Settings_Copy(thread, &reverse_thread, DEEP_COPY); + FAIL((reverse_thread == NULL), "Reverse in full-duplex thread alloc failed", thread); + clientside_client_fullduplex(thread, reverse_thread, theClient); + } else { + fprintf(stdout, "Program error in client side client_spawn"); + _exit(-1); + } + } else { + if (thread->mMode != kTest_Normal) { + setCompat(thread); + // These are the server or listener side spawning of clients + serverside_client_bidir(thread, theClient); + } else { + serverside_client_fullduplex(thread, theClient); + } + } + // Call the client's destructor + DELETE_PTR(theClient); +} + +/* + * client_init handles multiple threaded connects. It creates + * a listener object if either the dual test or tradeoff were + * specified. It also creates settings structures for all the + * threads and arranges them so they can be managed and started + * via the one settings structure that was passed in. + * + * Note: This runs in main thread context + */ +void client_init(struct thread_Settings *clients) { + struct thread_Settings *itr = NULL; + struct thread_Settings *next = NULL; + + itr = clients; + setReport(clients); + // See if we need to start a listener as well + Settings_GenerateListenerSettings(clients, &next); +#ifdef HAVE_THREAD + if (next != NULL) { + // We have threads and we need to start a listener so + // have it ran before the client is launched + itr->runNow = next; + itr = next; + } + // For each of the needed threads create a copy of the + // provided settings, unsetting the report flag and add + // to the list of threads to start + for (int i = 1; i < clients->mThreads; i++) { + Settings_Copy(clients, &next, DEEP_COPY); + // printf("*****port/thread = %d/%d\n", next->mPort + i, i); + if (next) { + if (isIncrSrcIP(clients) && (clients->mLocalhost != NULL)) { + next->incrsrcip = i; + } + if (isIncrDstIP(clients)) { + next->incrdstip = i; + // force a setHostname + SockAddr_zeroAddress(&next->peer); + } else if (clients->mBindPort) { + // Increment the source port of none of the quintuple is being change or the user requests it + if ((!isIncrDstPort(clients) && !isIncrDstIP(clients) && !isIncrSrcIP(clients)) || isIncrSrcPort(clients)) { + // case -B with src port and -P > 1 + next->incrsrcport = i; + } + } + if (isIncrDstPort(clients)) { + next->mPort += i; + SockAddr_zeroAddress(&next->peer); + } + } + itr->runNow = next; + itr = next; + } + if ((isBounceBack(clients) || isConnectOnly(clients) || isPeriodicBurst(clients)) \ + && (isWorkingLoadUp(clients) || isWorkingLoadDown(clients))) { + int working_load_threads = (clients->mWorkingLoadThreads == 0) ? 1 : clients->mWorkingLoadThreads; + while (working_load_threads--) { + Settings_Copy(clients, &next, DEEP_COPY); + if (next != NULL) { + unsetBounceBack(next); + unsetConnectOnly(next); + unsetPeriodicBurst(next); + unsetTxHoldback(next); // don't delay working load threads + next->mTOS = 0; // disable any QoS on the congestion stream +#if HAVE_DECL_TCP_NOTSENT_LOWAT + next->mWritePrefetch = SMALL_WRITE_PREFETCH; + setWritePrefetch(next); +#endif + if (isWorkingLoadUp(clients) && isWorkingLoadDown(clients)) { + setFullDuplex(next); + } else if (isWorkingLoadDown(clients)) { + setReverse(next); + } + if (isBounceBack(clients) && (clients->mWorkingLoadThreads > 1)) { + Iperf_push_host(clients); + } + // Bump the bounceback time to include the delay time + if (next->txholdback_timer.tv_sec || next->txholdback_timer.tv_usec) { + // mAmount units are 10 ms + next->mAmount += (next->txholdback_timer.tv_sec * 100); + next->mAmount += (next->txholdback_timer.tv_usec / 10000); + } + itr->runNow = next; + itr = next; + } + } + } +#else + if (next != NULL) { + // We don't have threads and we need to start a listener so + // have it ran after the client is finished + itr->runNext = next; + } +#endif +} + +void listeners_init(struct thread_Settings *listener) { + struct thread_Settings *itr = listener; + struct thread_Settings *next = NULL; + for (int ix = 1; ix < (listener->mPortLast - listener->mPort + 1); ix++) { + Settings_Copy(listener, &next, DEEP_COPY); + if (next != NULL) { + setNoSettReport(next); + next->mPort = listener->mPort + ix; + next->mThreadMode = kMode_Listener; + itr->runNow = next; + itr = next; + } + } +} diff --git a/src/Listener.cpp b/src/Listener.cpp new file mode 100644 index 0000000..a517cbc --- /dev/null +++ b/src/Listener.cpp @@ -0,0 +1,1447 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Listener.cpp + * by Mark Gates <mgates@nlanr.net> + * & Ajay Tirumala <tirumala@ncsa.uiuc.edu> + * rewritten by Robert McMahon + * ------------------------------------------------------------------- + * Listener sets up a socket listening on the server host. For each + * connected socket that accept() returns, this creates a Server + * socket and spawns a thread for it. + * + * Changes to the latest version. Listener will run as a daemon + * Multicast Server is now Multi-threaded + * ------------------------------------------------------------------- + * headers + * uses + * <stdlib.h> + * <stdio.h> + * <string.h> + * <errno.h> + * + * <sys/types.h> + * <unistd.h> + * + * <netdb.h> + * <netinet/in.h> + * <sys/socket.h> + * ------------------------------------------------------------------- */ +#define HEADERS() + +#include "headers.h" +#include "Listener.hpp" +#include "SocketAddr.h" +#include "PerfSocket.hpp" +#include "active_hosts.h" +#include "util.h" +#include "version.h" +#include "Locale.h" +#include "SocketAddr.h" +#include "payloads.h" +#include "delay.h" + +/* ------------------------------------------------------------------- + + * Stores local hostname and socket info. + * ------------------------------------------------------------------- */ + +Listener::Listener (thread_Settings *inSettings) { + mClients = inSettings->mThreads; + ListenSocket = INVALID_SOCKET; + /* + * These thread settings are stored in three places + * + * 1) Listener thread + * 2) Reporter Thread (per the ReportSettings()) + * 3) Server thread + */ + mSettings = inSettings; +} // end Listener + +/* ------------------------------------------------------------------- + * Delete memory (buffer). + * ------------------------------------------------------------------- */ +Listener::~Listener () { +#if HAVE_THREAD_DEBUG + thread_debug("Listener destructor close sock=%d", ListenSocket); +#endif + if (ListenSocket != INVALID_SOCKET) { + int rc = close(ListenSocket); + WARN_errno(rc == SOCKET_ERROR, "listener close"); + } +} // end ~Listener + +/* ------------------------------------------------------------------- + * This is the main Listener thread loop, listens and accept new + * connections and starts traffic threads + * + * Flow is + * o) suspend on traffic done for single client case + * o) hang a select() then accept() on the listener socket + * o) read or, more accurately, peak the socket for initial messages + * o) determine and set server's settings flags + * o) instantiate new settings for listener's clients if needed + * o) instantiate and bind sum and bidir report objects as needed + * o) start the threads needed + * + * ------------------------------------------------------------------- */ +void Listener::Run () { + // mCount is set True if -P was passed to the server + int mCount = ((mSettings->mThreads != 0) ? mSettings->mThreads : -1); + + // This is a listener launched by the client per -r or -d + if (mSettings->clientListener) { + SockAddr_remoteAddr(mSettings); + } + if (!isUDP(mSettings)) { + // TCP needs just one listen + my_listen(); // This will set ListenSocket to a new sock fd + } + bool mMode_Time = isServerModeTime(mSettings) && !isDaemon(mSettings); + if (mMode_Time) { + mEndTime.setnow(); + mEndTime.add(mSettings->mAmount / 100.0); + } else if (isPermitKey(mSettings) && (mSettings->mListenerTimeout > 0)) { + mEndTime.setnow(); + mEndTime.add(mSettings->mListenerTimeout); + } + Timestamp now; +#define SINGLECLIENTDELAY_DURATION 50000 // units is microseconds + while (!sInterupted && mCount) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener main loop port %d ", mSettings->mPort); +#endif + now.setnow(); + if ((mMode_Time || (mSettings->mListenerTimeout > 0)) && mEndTime.before(now)) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener port %d (loop timer expired)", mSettings->mPort); +#endif + break; + } + // Serialize in the event the -1 option or --singleclient is set + int tc; + if ((isSingleClient(mSettings) || isMulticast(mSettings)) && \ + mCount && (tc = (thread_numtrafficthreads()) > 0)) { + // Start with a delay in the event some traffic + // threads are pending to be scheduled and haven't + // had a chance to update the traffic thread count. + // An event system between listener thread and traffic threads + // might better but also more complex. This delay + // really should be good enough unless the os scheduler sucks + delay_loop(SINGLECLIENTDELAY_DURATION); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener single client loop mc/t/mcast/sc %d/%d/%d/%d",mCount, tc, isMulticast(mSettings), isSingleClient(mSettings)); +#endif + continue; + } + if (isUDP(mSettings)) { + // UDP needs a new listen per every new socket + my_listen(); // This will set ListenSocket to a new sock fd + } + // Use a select() with a timeout if -t is set or if this is a v1 -r or -d test + fd_set set; + if (((mMode_Time || isCompat(mSettings)) && (!isPermitKey(mSettings) && (mSettings->mAmount != 0))) \ + || (isPermitKey(mSettings) && (mSettings->mListenerTimeout != 0))) { + // Hang a select w/timeout on the listener socket + struct timeval timeout; + if (!isPermitKey(mSettings)) { + timeout.tv_sec = mSettings->mAmount / 100; + timeout.tv_usec = (mSettings->mAmount % 100) * 10000; + } else { + timeout.tv_sec = static_cast<long>(mSettings->mListenerTimeout); + timeout.tv_usec = (static_cast<long>(mSettings->mListenerTimeout) * 1000000) % 1000000; + } + if (isTxStartTime(mSettings)) { + now.setnow(); + long adjsecs = (mSettings->txstart_epoch.tv_sec - now.getSecs()); + if (adjsecs > 0) + timeout.tv_sec += adjsecs + 1; + } + FD_ZERO(&set); + FD_SET(ListenSocket, &set); + if (!(select(ListenSocket + 1, &set, NULL, NULL, &timeout) > 0)) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener select timeout"); +#endif + if (isCompat(mSettings)) { + fprintf(stderr, "ERROR: expected reverse connect did not occur\n"); + break; + } else + continue; + } + } + if (!setsock_blocking(mSettings->mSock, true)) { + WARN(1, "Failed setting socket to blocking mode"); + } + // Instantiate another settings object to be used by the server thread + Settings_Copy(mSettings, &server, DEEP_COPY); + FAIL(!server, "Failed memory allocation for server settings", mSettings); + server->mThreadMode = kMode_Server; + if (!isDataReport(mSettings)) + setNoDataReport(server); + + // accept a new socket and assign it to the server thread + int accept_sock = my_accept(server); + if (!(accept_sock > 0)) { + assert(server != mSettings); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener thread accept fail %d", accept_sock); +#endif + Settings_Destroy(server); + continue; + } + +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener thread accepted server sock=%d transferID", server->mSock, server->mTransferID); +#endif + // Decrement the -P counter, commonly usd to kill the listener + // after one test, i.e. -s -P 1 + if (mCount > 0) { + mCount--; + } + // These are some exception cases where the accepted socket shouldn't have been + // accepted but the accept() was first required to figure this out + // + // 1) When a client started the listener per -d or -r (but not --reverse.) + // What's done here is to see if the server peer opening the + // socket matches the expected peer per a compare of the ip addresses + // For the case of a *client Listener* the server and host must match + // Note: it's a good idea to prefer --reverse and full duplex socket vs this + // -d,-r legacy approach. Still support it though in the name of legacy usage + // + // 2) The peer is using a V6 address but the listener/server didn't get -V (for v6) on + // it's command line + // + if ((mSettings->clientListener && SockAddr_Hostare_Equal(&mSettings->peer, &server->peer)) || \ + (!isIPV6(mSettings) && SockAddr_isIPv6(&server->peer))) { + // Not allowed, reset things and restart the loop + // Don't forget to delete the UDP entry (inserted in my_accept) + Iperf_remove_host(server); + if (!isUDP(server)) + close(server->mSock); + assert(server != mSettings); + Settings_Destroy(server); + continue; + } + // isCompat is a version 1.7 test, basically it indicates there is nothing + // in the first messages so don't try to process them. Later iperf versions use + // the first message to convey test request and test settings information. This flag + // is also used for threads that are children so-to-speak, e.g. a -d or -r client, + // which cannot have test flags otherwise there would be "test setup recursion" + // Time to read the very first packet received (per UDP) or the test flags (TCP) + // to get the client's requested test information. + // Note 1: It's important to know that this will also populate mBuf with + // enough information for the listener to perform test info exchange later in the code + // Note 2: The mBuf read is a peek so the server's traffic thread started later + // will also process the first message from an accounting perspective. + // This is required for accurate traffic statistics + if (!isCompat(server) && (isConnectOnly(server) || !apply_client_settings(server))) { + if (isConnectionReport(server) && !isSumOnly(server)) { + struct ReportHeader *reporthdr = InitConnectionReport(server); + struct ConnectionInfo *cr = static_cast<struct ConnectionInfo *>(reporthdr->this_report); + cr->connect_timestamp.tv_sec = server->accept_time.tv_sec; + cr->connect_timestamp.tv_usec = server->accept_time.tv_usec; + assert(reporthdr); + PostReport(reporthdr); + } + Iperf_remove_host(server); + close(server->mSock); + assert(server != mSettings); + Settings_Destroy(server); + continue; + } + // server settings flags should now be set per the client's first message exchange + // so the server setting's flags per the client can now be checked + if (isUDP(server)){ + if (!isCompat(mSettings) && !isTapDev(mSettings) && (isL2LengthCheck(mSettings) || isL2LengthCheck(server)) && !L2_setup(server, server->mSock)) { + // Requested L2 testing but L2 setup failed + Iperf_remove_host(server); + assert(server != mSettings); + Settings_Destroy(server); + continue; + } + } + // Force compat mode to use 64 bit seq numbers + if (isUDP(server) && isCompat(mSettings)) { + setSeqNo64b(server); + } + setTransferID(server, 0); + if ((mSettings->mReportMode == kReport_CSV) && server->mSumReport && !server->mSumReport->sum_reverse_set) { + format_ips_port_string(&server->mSumReport->info, 1); + server->mSumReport->sum_reverse_set = true; + } else if (isTripTime(server) && server->mSumReport) { + SetSumHandlers(server, server->mSumReport); // this needs to be done again after first read + } + + // Read any more test settings and test values (not just the flags) and instantiate + // any settings objects for client threads (e.g. bidir or full duplex) + // This will set the listener_client_settings to NULL if + // there is no need for the Listener to start a client + // + // Note: the packet payload pointer for this information has different + // offsets per TCP or UDP. Basically, TCP starts at byte 0 but UDP + // has to skip over the UDP seq no, etc. + // + if (!isCompat(server) && !isCompat(mSettings) && \ + (isFullDuplex(server) || isServerReverse(server) || (server->mMode != kTest_Normal))) { + thread_Settings *listener_client_settings = NULL; + // read client header for reverse settings + Settings_GenerateClientSettings(server, &listener_client_settings, server->mBuf); + if (listener_client_settings) { + if (server->mMode != kTest_Normal) + listener_client_settings->mTransferID = 0; + setTransferID(listener_client_settings, 1); + if (isFullDuplex(listener_client_settings) || isReverse(listener_client_settings)) + Iperf_push_host(listener_client_settings); + if (isFullDuplex(server)) { + assert(server->mSumReport != NULL); + if (!server->mSumReport->sum_fd_set) { + // Reset the sum output routine for the server sum report + // now that it's know to be full duplex. This wasn't known + // during accept() + SetSumHandlers(server, server->mSumReport); + server->mSumReport->sum_fd_set = 1; + } + server->mFullDuplexReport = InitSumReport(server, server->mSock, 1); + listener_client_settings->mFullDuplexReport = server->mFullDuplexReport; +#if HAVE_THREAD_DEBUG + thread_debug("FullDuplex report client=%p/%p server=%p/%p", (void *) listener_client_settings, (void *) listener_client_settings->mFullDuplexReport, (void *) server, (void *) server->mFullDuplexReport); +#endif + server->runNow = listener_client_settings; + } else if (server->mMode != kTest_Normal) { +#if HAVE_THREAD_DEBUG + thread_debug("V1 test (-d or -r) sum report client=%p/%p server=%p/%p", (void *) listener_client_settings, (void *) listener_client_settings->mFullDuplexReport, (void *) server, (void *) server->mFullDuplexReport); +#endif + if (listener_client_settings->mMode == kTest_DualTest) { +#ifdef HAVE_THREAD + server->runNow = listener_client_settings; +#else + server->runNext = listener_client_settings; +#endif + } else { + server->runNext = listener_client_settings; + } + } + } + } + setTransferID(server, 0); + if (isConnectionReport(server) && !isSumOnly(server)) { + struct ReportHeader *reporthdr = InitConnectionReport(server); + struct ConnectionInfo *cr = static_cast<struct ConnectionInfo *>(reporthdr->this_report); + cr->connect_timestamp.tv_sec = server->accept_time.tv_sec; + cr->connect_timestamp.tv_usec = server->accept_time.tv_usec; + assert(reporthdr); + PostReport(reporthdr); + } + // Now start the server side traffic threads + thread_start_all(server); + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Listener exiting port/sig/threads %d/%d/%d", mSettings->mPort, sInterupted, mCount); +#endif +} // end Run + +/* ------------------------------------------------------------------- + * Setup a socket listening on a port. + * For TCP, this calls bind() and listen(). + * For UDP, this just calls bind(). + * If inLocalhost is not null, bind to that address rather than the + * wildcard server address, specifying what incoming interface to + * accept connections on. + * ------------------------------------------------------------------- */ +void Listener::my_listen () { + int rc; + int type; + int domain; + SockAddr_localAddr(mSettings); + +#if (((HAVE_TUNTAP_TUN) || (HAVE_TUNTAP_TAP)) && (AF_PACKET)) + if (isTapDev(mSettings)) { + ListenSocket = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); + FAIL_errno(ListenSocket == SOCKET_ERROR, "tuntap socket()", mSettings); + mSettings->mSock = ListenSocket; + rc = SockAddr_v4_Accept_BPF(ListenSocket, mSettings->mPort); + WARN_errno((rc == SOCKET_ERROR), "tap accept bpf"); + SetSocketOptions(mSettings); + } else +#endif + { + // create an AF_INET socket for the accepts + // for the case of L2 testing and UDP, a new AF_PACKET + // will be created to supercede this one + type = (isUDP(mSettings) ? SOCK_DGRAM : SOCK_STREAM); + domain = (SockAddr_isIPv6(&mSettings->local) ? +#if HAVE_IPV6 + AF_INET6 +#else + AF_INET +#endif + : AF_INET); + +#ifdef WIN32 + if (SockAddr_isMulticast(&mSettings->local)) { + // Multicast on Win32 requires special handling + ListenSocket = WSASocket(domain, type, 0, 0, 0, WSA_FLAG_MULTIPOINT_C_LEAF | WSA_FLAG_MULTIPOINT_D_LEAF); + WARN_errno(ListenSocket == INVALID_SOCKET, "socket"); + + } else +#endif + { + ListenSocket = socket(domain, type, 0); + WARN_errno(ListenSocket == INVALID_SOCKET, "socket"); + } + mSettings->mSock = ListenSocket; + SetSocketOptions(mSettings); + // reuse the address, so we can run if a former server was killed off + int boolean = 1; + Socklen_t len = sizeof(boolean); + rc = setsockopt(ListenSocket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&boolean), len); + // bind socket to server address +#ifdef WIN32 + if (SockAddr_isMulticast(&mSettings->local)) { + // Multicast on Win32 requires special handling + rc = WSAJoinLeaf(ListenSocket, (sockaddr*) &mSettings->local, mSettings->size_local,0,0,0,0,JL_BOTH); + WARN_errno(rc == SOCKET_ERROR, "WSAJoinLeaf (aka bind)"); + } else +#endif + { + rc = bind(ListenSocket, reinterpret_cast<sockaddr*>(&mSettings->local), mSettings->size_local); + FAIL_errno(rc == SOCKET_ERROR, "listener bind", mSettings); + } + } + + // update the reporter thread + if (isReport(mSettings) && isSettingsReport(mSettings)) { + struct ReportHeader *report_settings = InitSettingsReport(mSettings); + assert(report_settings != NULL); + // disable future settings reports, listener should only do it once + unsetReport(mSettings); + PostReport(report_settings); + } + + // listen for connections (TCP only). + // use large (INT_MAX) backlog allowing multiple simultaneous connections + if (!isUDP(mSettings)) { + if (isSingleClient(mSettings)) { + rc = listen(ListenSocket, 0 + mSettings->mThreads); + } else { + rc = listen(ListenSocket, INT_MAX); + } + WARN_errno(rc == SOCKET_ERROR, "listen"); + } else { +#ifndef WIN32 + // if UDP and multicast, join the group + if (SockAddr_isMulticast(&mSettings->local)) { +#ifdef HAVE_MULTICAST + my_multicast_join(); +#else + fprintf(stderr, "Multicast not supported"); +#endif // HAVE_MULTICAST + } +#endif + } +} // end my_listen() + +/* ------------------------------------------------------------------- + * Joins the multicast group or source and group (SSM S,G) + * + * taken from: https://www.ibm.com/support/knowledgecenter/en/SSLTBW_2.1.0/com.ibm.zos.v2r1.hale001/ipv6d0141001708.htm + * + * Multicast function IPv4 IPv6 Protocol-independent + * ================== ==== ==== ==================== + * Level of specified option on setsockopt()/getsockopt() IPPROTO_IP IPPROTO_IPV6 IPPROTO_IP or IPPROTO_IPV6 + * Join a multicast group IP_ADD_MEMBERSHIP IPV6_JOIN_GROUP MCAST_JOIN_GROUP + * Leave a multicast group or leave all sources of that + * multicast group IP_DROP_MEMBERSHIP IPV6_LEAVE_GROUP MCAST_LEAVE_GROUP + * Select outbound interface for sending multicast datagrams IP_MULTICAST_IF IPV6_MULTICAST_IF NA + * Set maximum hop count IP_MULTICAST_TTL IPV6_MULTICAST_HOPS NA + * Enable multicast loopback IP_MULTICAST_LOOP IPV6_MULTICAST_LOOP NA + * Join a source multicast group IP_ADD_SOURCE_MEMBERSHIP NA MCAST_JOIN_SOURCE_GROUP + * Leave a source multicast group IP_DROP_SOURCE_MEMBERSHIP NA MCAST_LEAVE_SOURCE_GROUP + * Block data from a source to a multicast group IP_BLOCK_SOURCE NA MCAST_BLOCK_SOURCE + * Unblock a previously blocked source for a multicast group IP_UNBLOCK_SOURCE NA MCAST_UNBLOCK_SOURCE + * + * + * Reminder: The os will decide which version of IGMP or MLD to use. This may be controlled by system settings, e.g.: + * + * [rmcmahon@lvnvdb0987:~/Code/ssm/iperf2-code] $ sysctl -a | grep mld | grep force + * net.ipv6.conf.all.force_mld_version = 0 + * net.ipv6.conf.default.force_mld_version = 0 + * net.ipv6.conf.lo.force_mld_version = 0 + * net.ipv6.conf.eth0.force_mld_version = 0 + * + * [rmcmahon@lvnvdb0987:~/Code/ssm/iperf2-code] $ sysctl -a | grep igmp | grep force + * net.ipv4.conf.all.force_igmp_version = 0 + * net.ipv4.conf.default.force_igmp_version = 0 + * net.ipv4.conf.lo.force_igmp_version = 0 + * net.ipv4.conf.eth0.force_igmp_version = 0 + * + * ------------------------------------------------------------------- */ +void Listener::my_multicast_join () { + // This is the older mulitcast join code. Both SSM and binding the + // an interface requires the newer socket options. Using the older + // code here will maintain compatiblity with previous iperf versions + if (!isSSMMulticast(mSettings) && !mSettings->mIfrname) { + if (!SockAddr_isIPv6(&mSettings->local)) { + struct ip_mreq mreq; + memcpy(&mreq.imr_multiaddr, SockAddr_get_in_addr(&mSettings->local), \ + sizeof(mreq.imr_multiaddr)); + mreq.imr_interface.s_addr = htonl(INADDR_ANY); + int rc = setsockopt(ListenSocket, IPPROTO_IP, IP_ADD_MEMBERSHIP, + reinterpret_cast<char*>(&mreq), sizeof(mreq)); + WARN_errno(rc == SOCKET_ERROR, "multicast join"); +#if HAVE_DECL_IP_MULTICAST_ALL + int mc_all = 0; + rc = setsockopt(ListenSocket, IPPROTO_IP, IP_MULTICAST_ALL, (void*) &mc_all, sizeof(mc_all)); + WARN_errno(rc == SOCKET_ERROR, "ip_multicast_all"); +#endif + } else { +#if (HAVE_IPV6 && HAVE_IPV6_MULTICAST && (HAVE_DECL_IPV6_JOIN_GROUP || HAVE_DECL_IPV6_ADD_MEMBERSHIP)) + struct ipv6_mreq mreq; + memcpy(&mreq.ipv6mr_multiaddr, SockAddr_get_in6_addr(&mSettings->local), sizeof(mreq.ipv6mr_multiaddr)); + mreq.ipv6mr_interface = 0; +#if HAVE_DECL_IPV6_JOIN_GROUP + int rc = setsockopt(ListenSocket, IPPROTO_IPV6, IPV6_JOIN_GROUP, \ + reinterpret_cast<char*>(&mreq), sizeof(mreq)); +#else + int rc = setsockopt(ListenSocket, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, \ + reinterpret_cast<char*>(&mreq), sizeof(mreq)); +#endif + FAIL_errno(rc == SOCKET_ERROR, "multicast v6 join", mSettings); +#else + fprintf(stderr, "IPv6 multicast is not supported on this platform\n"); +#endif + } + } else { + int rc; +#ifdef HAVE_SSM_MULTICAST + // Here it's either an SSM S,G multicast join or a *,G with an interface specifier + // Use the newer socket options when these are specified + socklen_t socklen = sizeof(struct sockaddr_storage); + int iface=0; +#ifdef HAVE_NET_IF_H + /* Set the interface or any */ + if (mSettings->mIfrname) { + iface = if_nametoindex(mSettings->mIfrname); + FAIL_errno(!iface, "mcast if_nametoindex",mSettings); + } else { + iface = 0; + } +#endif + + if (isIPV6(mSettings)) { +#if HAVE_IPV6_MULTICAST + if (mSettings->mSSMMulticastStr) { + struct group_source_req group_source_req; + struct sockaddr_in6 *group; + struct sockaddr_in6 *source; + + memset(&group_source_req, 0, sizeof(struct group_source_req)); + + group_source_req.gsr_interface = iface; + group=reinterpret_cast<struct sockaddr_in6*>(&group_source_req.gsr_group); + source=reinterpret_cast<struct sockaddr_in6*>(&group_source_req.gsr_source); + source->sin6_family = AF_INET6; + group->sin6_family = AF_INET6; + /* Set the group */ + rc=getsockname(ListenSocket,reinterpret_cast<struct sockaddr *>(group), &socklen); + FAIL_errno(rc == SOCKET_ERROR, "mcast join source group getsockname",mSettings); + group->sin6_port = 0; /* Ignored */ + + /* Set the source, apply the S,G */ + rc=inet_pton(AF_INET6, mSettings->mSSMMulticastStr,&source->sin6_addr); + FAIL_errno(rc != 1, "mcast v6 join source group pton",mSettings); + source->sin6_port = 0; /* Ignored */ +#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_LEN + source->sin6_len = group->sin6_len; +#endif + rc = -1; +#if HAVE_DECL_MCAST_JOIN_SOURCE_GROUP + rc = setsockopt(ListenSocket,IPPROTO_IPV6,MCAST_JOIN_SOURCE_GROUP, reinterpret_cast<const char *>(&group_source_req), + sizeof(group_source_req)); +#endif + FAIL_errno(rc == SOCKET_ERROR, "mcast v6 join source group",mSettings); + } else { + struct group_req group_req; + struct sockaddr_in6 *group; + + memset(&group_req, 0, sizeof(struct group_req)); + + group_req.gr_interface = iface; + group=reinterpret_cast<struct sockaddr_in6*>(&group_req.gr_group); + group->sin6_family = AF_INET6; + /* Set the group */ + rc=getsockname(ListenSocket,reinterpret_cast<struct sockaddr *>(group), &socklen); + FAIL_errno(rc == SOCKET_ERROR, "mcast v6 join group getsockname",mSettings); + group->sin6_port = 0; /* Ignored */ + rc = -1; +#if HAVE_DECL_MCAST_JOIN_GROUP + rc = setsockopt(ListenSocket,IPPROTO_IPV6,MCAST_JOIN_GROUP, reinterpret_cast<const char *>(&group_req), + sizeof(group_source_req)); +#endif + FAIL_errno(rc == SOCKET_ERROR, "mcast v6 join group",mSettings); + } +#else + fprintf(stderr, "Unfortunately, IPv6 multicast is not supported on this platform\n"); +#endif + } else { + if (mSettings->mSSMMulticastStr) { + struct sockaddr_in *group; + struct sockaddr_in *source; + + // Fill out both structures because we don't which one will succeed + // and both may need to be tried +#ifdef HAVE_STRUCT_IP_MREQ_SOURCE + struct ip_mreq_source imr; + memset (&imr, 0, sizeof (imr)); +#endif +#ifdef HAVE_STRUCT_GROUP_SOURCE_REQ + struct group_source_req group_source_req; + memset(&group_source_req, 0, sizeof(struct group_source_req)); + group_source_req.gsr_interface = iface; + group=reinterpret_cast<struct sockaddr_in*>(&group_source_req.gsr_group); + source=reinterpret_cast<struct sockaddr_in*>(&group_source_req.gsr_source); +#else + struct sockaddr_in imrgroup; + struct sockaddr_in imrsource; + group = &imrgroup; + source = &imrsource; +#endif + source->sin_family = AF_INET; + group->sin_family = AF_INET; + /* Set the group */ + rc=getsockname(ListenSocket,reinterpret_cast<struct sockaddr *>(group), &socklen); + FAIL_errno(rc == SOCKET_ERROR, "mcast join source group getsockname",mSettings); + group->sin_port = 0; /* Ignored */ + + /* Set the source, apply the S,G */ + rc=inet_pton(AF_INET,mSettings->mSSMMulticastStr,&source->sin_addr); + FAIL_errno(rc != 1, "mcast join source pton",mSettings); +#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN + source->sin_len = group->sin_len; +#endif + source->sin_port = 0; /* Ignored */ + rc = -1; + +#if HAVE_DECL_MCAST_JOIN_SOURCE_GROUP + rc = setsockopt(ListenSocket,IPPROTO_IP,MCAST_JOIN_SOURCE_GROUP, reinterpret_cast<const char *>(&group_source_req), + sizeof(group_source_req)); +#endif + +#if HAVE_DECL_IP_ADD_SOURCE_MEMBERSHIP +#ifdef HAVE_STRUCT_IP_MREQ_SOURCE + // Some operating systems will have MCAST_JOIN_SOURCE_GROUP but still fail + // In those cases try the IP_ADD_SOURCE_MEMBERSHIP + if (rc < 0) { +#ifdef HAVE_STRUCT_IP_MREQ_SOURCE_IMR_MULTIADDR_S_ADDR + imr.imr_multiaddr = ((const struct sockaddr_in *)group)->sin_addr; + imr.imr_sourceaddr = ((const struct sockaddr_in *)source)->sin_addr; +#else + // Some Android versions declare mreq_source without an s_addr + imr.imr_multiaddr = ((const struct sockaddr_in *)group)->sin_addr.s_addr; + imr.imr_sourceaddr = ((const struct sockaddr_in *)source)->sin_addr.s_addr; +#endif + rc = setsockopt (ListenSocket, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, reinterpret_cast<char*>(&imr), sizeof (imr)); + } +#endif +#endif + FAIL_errno(rc == SOCKET_ERROR, "mcast join source group",mSettings); + } else { + struct group_req group_req; + struct sockaddr_in *group; + + memset(&group_req, 0, sizeof(struct group_req)); + + group_req.gr_interface = iface; + group=reinterpret_cast<struct sockaddr_in*>(&group_req.gr_group); + group->sin_family = AF_INET; + /* Set the group */ + rc=getsockname(ListenSocket,reinterpret_cast<struct sockaddr *>(group), &socklen); + FAIL_errno(rc == SOCKET_ERROR, "mcast join group getsockname",mSettings); + group->sin_port = 0; /* Ignored */ + rc = -1; +#if HAVE_DECL_MCAST_JOIN_GROUP + rc = setsockopt(ListenSocket,IPPROTO_IP,MCAST_JOIN_GROUP, reinterpret_cast<const char *>(&group_req), + sizeof(group_source_req)); +#endif + FAIL_errno(rc == SOCKET_ERROR, "mcast join group",mSettings); + } + } + +#else + fprintf(stderr, "Unfortunately, SSM is not supported on this platform\n"); + exit(-1); +#endif + } +} +// end my_multicast_join() + +bool Listener::L2_setup (thread_Settings *server, int sockfd) { +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + // + // Supporting parallel L2 UDP threads is a bit tricky. Below are some notes as to why and the approach used. + // + // The primary issues for UDP are: + // + // 1) We want the listener thread to hand off the flow to a server thread and not be burdened by that flow + // 2) For -P support, the listener thread neads to detect new flows which will share the same UDP port + // and UDP is stateless + // + // The listener thread needs to detect new traffic flows and hand them to a new server thread, and then + // rehang a listen/accept. For standard iperf the "flow routing" is done using connect() per the ip quintuple. + // The OS will then route established connected flows to the socket descriptor handled by a server thread and won't + // burden the listener thread with these packets. + // + // For L2 verification, we have to create a two sockets that will exist for the life of the flow. A + // new packet socket (AF_PACKET) will receive L2 frames and bypasses + // the OS network stack. The original AF_INET socket will still send up packets + // to the network stack. + // + // When using packet sockets there is inherent packet duplication, the hand off to a server + // thread is not so straight forward as packets will continue being sent up to the listener thread + // (technical problem is that packet sockets do not support connect() which binds the IP quintuple as the + // forwarding key) Since the Listener uses recvfrom(), there is no OS mechanism to detect new flows nor + // to drop packets. The listener can't listen on quintuple based connected flows because the client's source + // port is unknown. Therefore the Listener thread will continue to receive packets from all established + // flows sharing the same dst port which will impact CPU utilization and hence performance. + // + // The technique used to address this is to open an AF_PACKET socket and leave the AF_INET socket open. + // (This also aligns with BSD based systems) The original AF_INET socket will remain in the (connected) + // state so the network stack has it's connected state. A cBPF is then used to cause the kernel to fast drop + // those packets. A cBPF is set up to drop such packets. The test traffic will then only come over the + // packet (raw) socket and not the AF_INET socket. If we were to try to close the original AF_INET socket + // (vs leave it open w/the fast drop cBPF) then the existing traffic will be sent up by the network stack + // to he Listener thread, flooding it with packets, again something we want to avoid. + // + // On the packet (raw) socket itself, we do two more things to better handle performance + // + // 1) Use a full quintuple cBPF allowing the kernel to filter packets (allow) per the quintuple + // 2) Use the packet fanout option to assign a CBPF to a socket and hence to a single server thread minimizing + // duplication (reduce all cBPF's filtering load) + // + struct sockaddr *p = reinterpret_cast<sockaddr *>(&server->peer); + struct sockaddr *l = reinterpret_cast<sockaddr *>(&server->local); + int rc = 0; + + // + // Establish a packet (raw) socket to be used by the server thread giving it full L2 packets + // + struct sockaddr s; + socklen_t len = sizeof(s); + getpeername(sockfd, &s, &len); + if (isIPV6(server)) { + server->mSock = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IPV6)); + WARN_errno(server->mSock == INVALID_SOCKET, "ip6 packet socket (AF_PACKET)"); + server->l4offset = IPV6HDRLEN + sizeof(struct ether_header); + } else { + server->mSock = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP)); + WARN_errno(server->mSock == INVALID_SOCKET, "ip packet socket (AF_PACKET)"); + unsetIPV6(server); + server->l4offset = sizeof(struct iphdr) + sizeof(struct ether_header); + } + // Didn't get a valid socket, return now + if (server->mSock < 0) { + return false; + } + // More per thread settings based on using a packet socket + server->l4payloadoffset = server->l4offset + sizeof(struct udphdr); + server->recvflags = MSG_TRUNC; + // The original AF_INET socket only exists to keep the connected state + // in the OS for this flow. Fast drop packets there as + // now packets will use the AF_PACKET (raw) socket + // Also, store the original AF_INET socket descriptor so it can be + // closed in the Server's destructor. (Note: closing the + // socket descriptors will also free the cBPF.) + // + server->mSockDrop = sockfd; + rc = SockAddr_Drop_All_BPF(sockfd); + WARN_errno(rc == SOCKET_ERROR, "l2 all drop bpf"); + + // Now optimize packet flow up the raw socket + // Establish the flow BPF to forward up only "connected" packets to this raw socket + if (l->sa_family == AF_INET6) { +#if HAVE_IPV6 + struct in6_addr *v6peer = SockAddr_get_in6_addr(&server->peer); + struct in6_addr *v6local = SockAddr_get_in6_addr(&server->local); + if (isIPV6(server)) { + rc = SockAddr_v6_Connect_BPF(server->mSock, v6local, v6peer, (reinterpret_cast<struct sockaddr_in6 *>(l))->sin6_port, (reinterpret_cast<struct sockaddr_in6 *>(p))->sin6_port); + WARN_errno(rc == SOCKET_ERROR, "l2 connect ipv6 bpf"); + } else { + // This is an ipv4 address in a v6 family (structure), just pull the lower 32 bits for the v4 addr + rc = SockAddr_v4_Connect_BPF(server->mSock, v6local->s6_addr32[3], v6peer->s6_addr32[3], (reinterpret_cast<struct sockaddr_in6 *>(l))->sin6_port, (reinterpret_cast<struct sockaddr_in6 *>(p))->sin6_port); + WARN_errno(rc == SOCKET_ERROR, "l2 v4in6 connect ip bpf"); + } +#else + fprintf(stderr, "Unfortunately, IPv6 is not supported on this platform\n"); + return false; +#endif /* HAVE_IPV6 */ + } else { + rc = SockAddr_v4_Connect_BPF(server->mSock, (reinterpret_cast<struct sockaddr_in *>(l))->sin_addr.s_addr, (reinterpret_cast<struct sockaddr_in *>(p))->sin_addr.s_addr, (reinterpret_cast<struct sockaddr_in *>(l))->sin_port, (reinterpret_cast<struct sockaddr_in *>(p))->sin_port); + WARN_errno(rc == SOCKET_ERROR, "l2 connect ip bpf"); + } + return rc >= 0; +#else + fprintf(stderr, "Client requested --l2checks but not supported on this platform\n"); + return false; +#endif +} + +bool Listener::tap_setup (thread_Settings *server, int sockfd) { +#if defined(HAVE_IF_TUNTAP) && defined(HAVE_AF_PACKET) && defined(HAVE_DECL_SO_BINDTODEVICE) + struct sockaddr *p = reinterpret_cast<sockaddr *>(&server->peer); + struct sockaddr *l = reinterpret_cast<sockaddr *>(&server->local); + int rc = 0; + + // + // Establish a packet (raw) socket to be used by the server thread giving it full L2 packets + // + struct sockaddr s; + socklen_t len = sizeof(s); + getpeername(sockfd, &s, &len); + if (isIPV6(server)) { + server->l4offset = IPV6HDRLEN + sizeof(struct ether_header); + } else { + server->l4offset = sizeof(struct iphdr) + sizeof(struct ether_header); + } + // Didn't get a valid socket, return now + if (server->mSock < 0) { + return false; + } + // More per thread settings based on using a packet socket + server->l4payloadoffset = server->l4offset + sizeof(struct udphdr); + server->recvflags = MSG_TRUNC; + // Now optimize packet flow up the raw socket + // Establish the flow BPF to forward up only "connected" packets to this raw socket + if (l->sa_family == AF_INET6) { +#if HAVE_IPV6 + struct in6_addr *v6peer = SockAddr_get_in6_addr(&server->peer); + struct in6_addr *v6local = SockAddr_get_in6_addr(&server->local); + if (isIPV6(server)) { + rc = SockAddr_v6_Connect_BPF(server->mSock, v6local, v6peer, (reinterpret_cast<struct sockaddr_in6 *>(l))->sin6_port, (reinterpret_cast<struct sockaddr_in6 *>(p))->sin6_port); + WARN_errno(rc == SOCKET_ERROR, "l2 connect ipv6 bpf"); + } else { + // This is an ipv4 address in a v6 family (structure), just pull the lower 32 bits for the v4 addr + rc = SockAddr_v4_Connect_BPF(server->mSock, v6local->s6_addr32[3], v6peer->s6_addr32[3], (reinterpret_cast<struct sockaddr_in6 *>(l))->sin6_port, (reinterpret_cast<struct sockaddr_in6 *>(p))->sin6_port); + WARN_errno(rc == SOCKET_ERROR, "l2 v4in6 connect ip bpf"); + } +#else + fprintf(stderr, "Unfortunately, IPv6 is not supported on this platform\n"); + return false; +#endif /* HAVE_IPV6 */ + } else { + rc = SockAddr_v4_Connect_BPF(server->mSock, (reinterpret_cast<struct sockaddr_in *>(l))->sin_addr.s_addr, (reinterpret_cast<struct sockaddr_in *>(p))->sin_addr.s_addr, (reinterpret_cast<struct sockaddr_in *>(l))->sin_port, (reinterpret_cast<struct sockaddr_in *>(p))->sin_port); + WARN_errno(rc == SOCKET_ERROR, "l2 connect ip bpf"); + } + return rc >= 0; +#else + fprintf(stderr, "Client requested --l2checks but not supported on this platform\n"); + return false; +#endif +} + +/* ------------------------------------------------------------------------ + * Do the equivalent of an accept() call for UDP sockets. This checks + * a listening UDP socket for new or first received datagram + * ------------------------------------------------------------------- ----*/ +int Listener::udp_accept (thread_Settings *server) { + assert(server != NULL); + int nread = 0; + assert(ListenSocket > 0); + // Preset the server socket to INVALID, hang recvfrom on the Listener's socket + // The INVALID socket is used to keep the while loop going + server->mSock = INVALID_SOCKET; + intmax_t packetID; + struct UDP_datagram* mBuf_UDP = reinterpret_cast<struct UDP_datagram*>(server->mBuf); + // Look for a UDP packet with a postive seq no while draining any neg seq no packets + // The UDP client traffic thread uses negative seq numbers to indicate to the server that + // traffic is over. Some of those "final" packets can be in the stack/network pipeline after the server + // thread has ended and closed its reporting. The Listener will now receive them as if they are + // "first packets. Any "new" packets seen by the Listener causes a new "udp accept" + // per UDP's stateless design. So, in the case of negative seq nos, we know that this is + // most likely not a new client thread requiring a new server thread, but remnants of an + // old one that already ended. Hence, the Listener should ignore "first packets" when + // they have negative seq numbers. + do { + packetID = 0; + nread = recvfrom(ListenSocket, server->mBuf, server->mBufLen, 0, \ + reinterpret_cast<struct sockaddr*>(&server->peer), &server->size_peer); + if (nread > 0) { + // filter and ignore negative sequence numbers, these can be heldover from a previous run + if (isSeqNo64b(mSettings)) { + // New client - Signed PacketID packed into unsigned id2,id + packetID = (static_cast<uint32_t>(ntohl(mBuf_UDP->id))) | (static_cast<uintmax_t>(ntohl(mBuf_UDP->id2)) << 32); + } else { + // Old client - Signed PacketID in Signed id + packetID = static_cast<int32_t>(ntohl(mBuf_UDP->id)); + } + } + } while ((nread > 0) && (packetID < 0) && !sInterupted); + FAIL_errno(nread == SOCKET_ERROR, "recvfrom", mSettings); + if ((nread > 0) && !sInterupted) { + Timestamp now; + server->accept_time.tv_sec = now.getSecs(); + server->accept_time.tv_usec = now.getUsecs(); +#if HAVE_THREAD_DEBUG + { + char tmpaddr[200]; + size_t len=200; + unsigned short port = SockAddr_getPort(&server->peer); + SockAddr_getHostAddress(&server->peer, tmpaddr, len); + thread_debug("rcvfrom peer: %s port %d len=%d", tmpaddr, port, nread); + } +#endif + // Handle connection for UDP sockets + int gid = Iperf_push_host_port_conditional(server); +#if HAVE_THREAD_DEBUG + if (gid < 0) + thread_debug("rcvfrom peer: drop duplicate"); +#endif + if (gid > 0) { + int rc; + // We have a new UDP flow (based upon key of quintuple) + // so let's hand off this socket + // to the server and create a new listener socket + server->mSock = ListenSocket; + ListenSocket = INVALID_SOCKET; + // This connect() will allow the OS to only + // send packets with the ip quintuple up to the server + // socket and, hence, to the server thread (yet to be created) + // This connect() routing is only supported with AF_INET or AF_INET6 sockets, + // e.g. AF_PACKET sockets can't do this. We'll handle packet sockets later + // All UDP accepts here will use AF_INET. This is intentional and needed + rc = connect(server->mSock, reinterpret_cast<struct sockaddr*>(&server->peer), server->size_peer); + FAIL_errno(rc == SOCKET_ERROR, "connect UDP", mSettings); + server->size_local = sizeof(iperf_sockaddr); + getsockname(server->mSock, reinterpret_cast<sockaddr*>(&server->local), &server->size_local); + SockAddr_Ifrname(server); + server->firstreadbytes = nread; + } + } + return server->mSock; +} + + +#if (((HAVE_TUNTAP_TUN) || (HAVE_TUNTAP_TAP)) && (AF_PACKET)) +int Listener::tuntap_accept(thread_Settings *server) { + int rc = recv(server->mSock, server->mBuf, (server->mBufLen + TAPBYTESSLOP + sizeof(struct iphdr) + sizeof(struct ether_header) + sizeof(struct udphdr)), 0); + if (rc <= 0) + return 0; +// rc = udpchecksum((void *)ip_hdr, (void *)udp_hdr, udplen, (isIPV6(mSettings) ? 1 : 0)); + struct iphdr *l3hdr = (struct iphdr *)((char *)server->mBuf + sizeof(struct ether_header)); + struct udphdr *l4hdr = (struct udphdr *)((char *)server->mBuf + sizeof(struct iphdr) + sizeof(struct ether_header)); +// uint16_t ipver = (uint16_t) ntohs(mBuf + sizeof(struct ether_header)); +// printf ("*** version = %d\n", ipver); + // Note: sockaddrs are stored in network bytes order + struct sockaddr_in *local = (struct sockaddr_in *) &server->local; + struct sockaddr_in *peer = (struct sockaddr_in *) &server->peer; + server->size_peer = sizeof(iperf_sockaddr); + server->size_local = sizeof(iperf_sockaddr); + peer->sin_family = AF_INET; + local->sin_family = AF_INET; + peer->sin_addr.s_addr = l3hdr->saddr; + local->sin_addr.s_addr = l3hdr->daddr; + peer->sin_port = l4hdr->source; + local->sin_port = l4hdr->dest; + server->l4offset = sizeof(struct iphdr) + sizeof(struct ether_header); + SockAddr_v4_Connect_TAP_BPF(server->mSock, local->sin_addr.s_addr, peer->sin_addr.s_addr, local->sin_port, peer->sin_port); + server->l4payloadoffset = sizeof(struct iphdr) + sizeof(struct ether_header) + sizeof(struct udphdr); + server->firstreadbytes = rc; + return server->mSock; +} +#endif +/* ------------------------------------------------------------------- + * This is called by the Listener thread main loop, return a socket or error + * ------------------------------------------------------------------- */ +int Listener::my_accept (thread_Settings *server) { + assert(server != NULL); +#ifdef HAVE_THREAD_DEBUG + if (isUDP(server)) { + thread_debug("Listener thread listening for UDP (sock=%d)", ListenSocket); + } else { + thread_debug("Listener thread listening for TCP (sock=%d)", ListenSocket); + } +#endif + SockAddr_zeroAddress(&server->peer); + server->size_peer = sizeof(iperf_sockaddr); + server->accept_time.tv_sec = 0; + server->accept_time.tv_usec = 0; + if (isUDP(server)) { +#if (((HAVE_TUNTAP_TUN) || (HAVE_TUNTAP_TAP)) && (AF_PACKET)) + if (isTapDev(server) || isTunDev(server)) { + server->mSock = tuntap_accept(server); + } else +#endif + { + server->mSock = udp_accept(server); + } + // note udp_accept will update the active host table + } else { + // accept a TCP connection + server->mSock = accept(ListenSocket, reinterpret_cast<sockaddr*>(&server->peer), &server->size_peer); + if (server->mSock > 0) { + Timestamp now; + server->accept_time.tv_sec = now.getSecs(); + server->accept_time.tv_usec = now.getUsecs(); + server->size_local = sizeof(iperf_sockaddr); + getsockname(server->mSock, reinterpret_cast<sockaddr*>(&server->local), &server->size_local); + SockAddr_Ifrname(server); + Iperf_push_host(server); + } + } + return server->mSock; +} // end my_accept + +// Read deep enough into the packet to get the client settings +// Read the headers but don't pull them from the queue in order to +// preserve server thread accounting, i.e. these exchanges will +// be part of traffic accounting. Return false if it's determined +// this traffic shouldn't be accepted for a test run +// Description of bits and fields is in include/payloads.h +bool Listener::apply_client_settings (thread_Settings *server) { + assert(server != NULL); + bool rc = false; + + // Set the receive timeout for the very first read + int sorcvtimer = TESTEXCHANGETIMEOUT; // 4 sec in usecs + SetSocketOptionsReceiveTimeout(server, sorcvtimer); + server->peer_version_u = 0; + server->peer_version_l = 0; + server->mMode = kTest_Normal; + + if (isUDP(server)) { + rc = apply_client_settings_udp(server); + } else if (!isConnectOnly(server)) { + rc = apply_client_settings_tcp(server); + } + if (isOverrideTOS(server)) { + SetSocketOptionsIPTos(server, server->mRTOS); + } else if (server->mTOS) { + SetSocketOptionsIPTos(server, server->mTOS); + } + return rc; +} + +inline bool Listener::test_permit_key(uint32_t flags, thread_Settings *server, int keyoffset) { + if (!(flags & HEADER_KEYCHECK)) { + server->mKeyCheck= false; + return false; + } + struct permitKey *thiskey = reinterpret_cast<struct permitKey *>(server->mBuf + (keyoffset - sizeof(thiskey->length))); + int keylen = ntohs(thiskey->length); + if ((keylen < MIN_PERMITKEY_LEN) || (keylen > MAX_PERMITKEY_LEN)) { + server->mKeyCheck= false; +// fprintf(stderr, "REJECT: key length bounds error (%d)\n", keylen); + return false; + } + if (keylen != static_cast<int>(strlen(server->mPermitKey))) { + server->mKeyCheck= false; +// fprintf(stderr, "REJECT: key length mismatch (%d!=%d)\n", keylen, (int) strlen(server->mPermitKey)); + return false; + } + if (!isUDP(server)) { + int nread = 0; + nread = recvn(server->mSock, reinterpret_cast<char *>(&thiskey->value), keylen, 0); + FAIL_errno((nread < keylen), "read key", server); + } + strncpy(server->mPermitKey, thiskey->value, MAX_PERMITKEY_LEN + 1); + if (strncmp(server->mPermitKey, mSettings->mPermitKey, keylen) != 0) { + server->mKeyCheck= false; +// fprintf(stderr, "REJECT: key value mismatch per %s\n", thiskey->value); + return false; + } + server->mKeyCheck= true; + return true; +} + +bool Listener::apply_client_settings_udp (thread_Settings *server) { + struct client_udp_testhdr *hdr = reinterpret_cast<struct client_udp_testhdr *>(server->mBuf + server->l4payloadoffset); + uint32_t flags = ntohl(hdr->base.flags); + uint16_t upperflags = 0; + if (flags & HEADER_SEQNO64B) { + setSeqNo64b(server); + } +#if HAVE_THREAD_DEBUG + thread_debug("UDP test flags = %X", flags); +#endif + if (flags & HEADER32_SMALL_TRIPTIMES) { +#if HAVE_THREAD_DEBUG + thread_debug("UDP small header"); +#endif + server->sent_time.tv_sec = ntohl(hdr->seqno_ts.tv_sec); + server->sent_time.tv_usec = ntohl(hdr->seqno_ts.tv_usec); + uint32_t seqno = ntohl(hdr->seqno_ts.id); + if (seqno != 1) { + fprintf(stderr, "WARN: first received packet (id=%d) was not first sent packet, report start time will be off\n", seqno); + } + Timestamp now; + if (!isTxStartTime(server) && ((abs(now.getSecs() - server->sent_time.tv_sec)) > (MAXDIFFTIMESTAMPSECS + 1))) { + fprintf(stdout,"WARN: ignore --trip-times because client didn't provide valid start timestamp within %d seconds of now\n", MAXDIFFTIMESTAMPSECS); + unsetTripTime(server); + } else { + setTripTime(server); + } + setEnhanced(server); + } else if ((flags & HEADER_VERSION1) || (flags & HEADER_VERSION2) || (flags & HEADER_EXTEND)) { + if ((flags & HEADER_VERSION1) && !(flags & HEADER_VERSION2)) { + if (flags & RUN_NOW) + server->mMode = kTest_DualTest; + else + server->mMode = kTest_TradeOff; + } + if (flags & HEADER_EXTEND) { + upperflags = htons(hdr->extend.upperflags); + server->mTOS = ntohs(hdr->extend.tos); + server->peer_version_u = ntohl(hdr->extend.version_u); + server->peer_version_l = ntohl(hdr->extend.version_l); + if (flags & HEADER_UDPTESTS) { + // Handle stateless flags + if (upperflags & HEADER_ISOCH) { + setIsochronous(server); + } + if (upperflags & HEADER_L2ETHPIPV6) { + setIPV6(server); + } else { + unsetIPV6(server); + } + if (upperflags & HEADER_L2LENCHECK) { + setL2LengthCheck(server); + } + if (upperflags & HEADER_NOUDPFIN) { + setNoUDPfin(server); + } + } + if (upperflags & HEADER_EPOCH_START) { + server->txstart_epoch.tv_sec = ntohl(hdr->start_fq.start_tv_sec); + server->txstart_epoch.tv_usec = ntohl(hdr->start_fq.start_tv_usec); + Timestamp now; + if ((abs(now.getSecs() - server->txstart_epoch.tv_sec)) > (MAXDIFFTXSTART + 1)) { + fprintf(stdout,"WARN: ignore --txstart-time because client didn't provide valid start timestamp within %d seconds of now\n", MAXDIFFTXSTART); + unsetTxStartTime(server); + } else { + setTxStartTime(server); + } + } + if (upperflags & HEADER_TRIPTIME) { + server->sent_time.tv_sec = ntohl(hdr->start_fq.start_tv_sec); + server->sent_time.tv_usec = ntohl(hdr->start_fq.start_tv_usec); + Timestamp now; + if (!isTxStartTime(server) && ((abs(now.getSecs() - server->sent_time.tv_sec)) > (MAXDIFFTIMESTAMPSECS + 1))) { + fprintf(stdout,"WARN: ignore --trip-times because client didn't provide valid start timestamp within %d seconds of now\n", MAXDIFFTIMESTAMPSECS); + unsetTripTime(server); + } else { + setTripTime(server); + setEnhanced(server); + } + } + } + if (flags & HEADER_VERSION2) { + upperflags = htons(hdr->extend.upperflags); + if (upperflags & HEADER_FULLDUPLEX) { + setFullDuplex(server); + setServerReverse(server); + } + if (upperflags & HEADER_REVERSE) { + server->mThreadMode=kMode_Client; + setServerReverse(server); + if (server->mSumReport != NULL) { + server->mSumReport->info.common->ThreadMode=kMode_Client; + setServerReverse(server->mSumReport->info.common); + } + setNoUDPfin(server); + unsetReport(server); + } + } + } + return true; +} +bool Listener::apply_client_settings_tcp (thread_Settings *server) { + bool rc = false; +#if HAVE_TCP_STATS + if (!isUDP(mSettings)) { + gettcpinfo(server->mSock, &server->tcpinitstats); + } +#endif + int nread = recvn(server->mSock, server->mBuf, sizeof(uint32_t), 0); + char *readptr = server->mBuf; + if (nread == 0) { + //peer closed the socket, with no writes e.g. a connect-only test + WARN(1, "read tcp flags (peer close)"); + goto DONE; + } + if (nread < (int) sizeof(uint32_t)) { + WARN(1, "read tcp flags (runt)"); + goto DONE; + } else { + rc = true; + readptr += nread; + struct client_tcp_testhdr *hdr = reinterpret_cast<struct client_tcp_testhdr *>(server->mBuf); + uint32_t flags = ntohl(hdr->base.flags); + if (flags & HEADER_BOUNCEBACK) { + if (!isServerModeTime(server)) { + unsetModeTime(server); + } + struct bounceback_hdr *bbhdr = reinterpret_cast<struct bounceback_hdr *>(server->mBuf); + setBounceBack(server); + nread = recvn(server->mSock, readptr, sizeof(struct bounceback_hdr), 0); + if (nread != sizeof(struct bounceback_hdr)) { + WARN(1, "read bounce back header failed"); + rc = false; + goto DONE; + } + readptr += nread; + server->mBounceBackBytes = ntohl(bbhdr->bbsize); + server->mBounceBackHold = ntohl(bbhdr->bbhold); + uint16_t bbflags = ntohs(bbhdr->bbflags); + if (bbflags & HEADER_BBCLOCKSYNCED) { + setTripTime(server); + server->sent_time.tv_sec = ntohl(bbhdr->bbclientTx_ts.sec); + server->sent_time.tv_usec = ntohl(bbhdr->bbclientTx_ts.usec); + } + if (bbflags & HEADER_BBTOS) { + server->mTOS = ntohs(bbhdr->tos); + } +#if HAVE_DECL_TCP_QUICKACK + if (bbflags & HEADER_BBQUICKACK) { + setTcpQuickAck(server); + } +#endif + int remaining = server->mBounceBackBytes - (sizeof(struct bounceback_hdr) + sizeof(uint32_t)); + if (remaining < 0) { + WARN(1, "bounce back bytes too small"); + rc = false; + goto DONE; + } else if (remaining > 0) { + nread = recvn(server->mSock, readptr, remaining, 0); + if (nread != remaining) { + WARN(1, "read bounce back payload failed"); + rc = false; + goto DONE; + } + } + Timestamp now; + bbhdr->bbserverRx_ts.sec = htonl(now.getSecs()); + bbhdr->bbserverRx_ts.usec = htonl(now.getUsecs()); + } else { + uint16_t upperflags = 0; + int readlen; + // figure out the length of the test header + if ((readlen = Settings_ClientTestHdrLen(flags, server)) > 0) { + // read the test settings passed to the server by the client + nread += recvn(server->mSock, readptr, (readlen - (int) sizeof(uint32_t)), 0); + FAIL_errno((nread < readlen), "read tcp test info", server); + if (isPermitKey(mSettings)) { + if (!test_permit_key(flags, server, readlen)) { + rc = false; + goto DONE; + } + } else if (flags & HEADER_KEYCHECK) { + rc = false; + server->mKeyCheck = false; + goto DONE; + } + server->firstreadbytes = nread; + struct client_tcp_testhdr *hdr = reinterpret_cast<struct client_tcp_testhdr*>(server->mBuf); + if ((flags & HEADER_VERSION1) && !(flags & HEADER_VERSION2)) { + if (flags & RUN_NOW) + server->mMode = kTest_DualTest; + else + server->mMode = kTest_TradeOff; + } + if (flags & HEADER_EXTEND) { + upperflags = htons(hdr->extend.upperflags); + server->mTOS = ntohs(hdr->extend.tos); + server->peer_version_u = ntohl(hdr->extend.version_u); + server->peer_version_l = ntohl(hdr->extend.version_l); + if (upperflags & HEADER_ISOCH) { + setIsochronous(server); + } + if (upperflags & HEADER_EPOCH_START) { + server->txstart_epoch.tv_sec = ntohl(hdr->start_fq.start_tv_sec); + server->txstart_epoch.tv_usec = ntohl(hdr->start_fq.start_tv_usec); + Timestamp now; + if ((abs(now.getSecs() - server->txstart_epoch.tv_sec)) > (MAXDIFFTXSTART + 1)) { + fprintf(stdout,"WARN: ignore --txstart-time because client didn't provide valid start timestamp within %d seconds of now\n", MAXDIFFTXSTART); + unsetTxStartTime(server); + } else { + setTxStartTime(server); + } + } + if (upperflags & HEADER_TRIPTIME) { + Timestamp now; + server->sent_time.tv_sec = ntohl(hdr->start_fq.start_tv_sec); + server->sent_time.tv_usec = ntohl(hdr->start_fq.start_tv_usec); + if (!isTxStartTime(server) && ((abs(now.getSecs() - server->sent_time.tv_sec)) > (MAXDIFFTIMESTAMPSECS + 1))) { + fprintf(stdout,"WARN: ignore --trip-times because client didn't provide valid start timestamp within %d seconds of now\n", MAXDIFFTIMESTAMPSECS); + unsetTripTime(server); + } else { + setTripTime(server); + setEnhanced(server); + } + } + if (upperflags & HEADER_PERIODICBURST) { + setEnhanced(server); + setFrameInterval(server); + setPeriodicBurst(server); + { + struct client_tcp_testhdr *hdr = reinterpret_cast<struct client_tcp_testhdr *>(server->mBuf); + server->mFPS = ntohl(hdr->isoch_settings.FPSl); + server->mFPS += ntohl(hdr->isoch_settings.FPSu) / static_cast<double>(rMillion); + } + if (!server->mFPS) { + server->mFPS = 1.0; + } + } + if (flags & HEADER_VERSION2) { + if (upperflags & HEADER_FULLDUPLEX) { + setFullDuplex(server); + setServerReverse(server); + } + if (upperflags & HEADER_REVERSE) { + server->mThreadMode=kMode_Client; + setServerReverse(server); + if (server->mSumReport != NULL) { + server->mSumReport->info.common->ThreadMode=kMode_Client; + setServerReverse(server->mSumReport->info.common); + } + } + } +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if ((isServerReverse(server) || isFullDuplex(server)) && (upperflags & HEADER_WRITEPREFETCH)) { + server->mWritePrefetch = ntohl(hdr->extend.TCPWritePrefetch); + if (server->mWritePrefetch > 0) { + setWritePrefetch(server); + } + } +#endif +#if HAVE_DECL_TCP_QUICKACK + if (upperflags & HEADER_TCPQUICKACK) { + setTcpQuickAck(server); + } +#endif + if (upperflags & HEADER_BOUNCEBACK) { + setBounceBack(server); + } + } + } + } + // Handle case that requires an ack back to the client + // Signaled by not UDP (only supported by TCP) + // and either 2.0.13 flags or the newer 2.0.14 flag of + // V2PEERDETECT + if (!isUDP(server) && !isCompat(mSettings) && \ + ((!(flags & HEADER_VERSION2) && (flags & HEADER_EXTEND)) || \ + (flags & HEADER_V2PEERDETECT))) { + client_test_ack(server); + } + } + DONE: + return rc; +} + +int Listener::client_test_ack(thread_Settings *server) { + if (isUDP(server)) + return 1; + + client_hdr_ack ack; + int sotimer = 0; + int size = sizeof(struct client_hdr_ack); + ack.typelen.type = htonl(CLIENTHDRACK); + + ack.flags = 0; + ack.reserved1 = 0; + ack.reserved2 = 0; + ack.version_u = htonl(IPERF_VERSION_MAJORHEX); + ack.version_l = htonl(IPERF_VERSION_MINORHEX); + if (isTripTime(server)) { + ack.ts.sent_tv_sec = htonl(server->sent_time.tv_sec); + ack.ts.sent_tv_usec = htonl(server->sent_time.tv_usec); + ack.ts.sentrx_tv_sec = htonl(server->accept_time.tv_sec); + ack.ts.sentrx_tv_usec = htonl(server->accept_time.tv_usec); + Timestamp now; + ack.ts.ack_tv_sec = htonl(now.getSecs()); + ack.ts.ack_tv_usec = htonl(now.getUsecs()); + } else { + size -= sizeof (struct client_hdr_ack_ts); + } + ack.typelen.length = htonl(size); + int rc = 1; + // This is a version 2.0.10 or greater client + // write back to the client so it knows the server + // version + + // sotimer units microseconds convert + if (server->mInterval) { + sotimer = static_cast<int>((server->mInterval) / 4); + } else if (isModeTime(server)) { + sotimer = static_cast<int>((server->mAmount * 10000) / 4); + } + if (sotimer > HDRXACKMAX) { + sotimer = HDRXACKMAX; + } else if (sotimer < HDRXACKMIN) { + sotimer = HDRXACKMIN; + } + SetSocketOptionsSendTimeout(server, sotimer); +#if HAVE_DECL_TCP_NODELAY + int optflag = 1; + // Disable Nagle to reduce latency of this intial message + if ((rc = setsockopt(server->mSock, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&optflag), sizeof(int))) < 0) { + WARN_errno(rc < 0, "tcpnodelay"); + } +#endif + if ((rc = send(server->mSock, reinterpret_cast<const char*>(&ack), size, 0)) < 0) { + WARN_errno(rc <= 0, "send_ack"); + rc = 0; + } +#if HAVE_DECL_TCP_NODELAY + // Re-nable Nagle + optflag = isNoDelay(server) ? 1 : 0; + if (!isUDP(server) && (rc = setsockopt(server->mSock, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char *>(&optflag), sizeof(int))) < 0) { + WARN_errno(rc < 0, "tcpnodelay"); + } +#endif + return rc; +} diff --git a/src/Locale.c b/src/Locale.c new file mode 100644 index 0000000..09333b0 --- /dev/null +++ b/src/Locale.c @@ -0,0 +1,757 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Locale.c + * by Ajay Tirumala <tirumala@ncsa.uiuc.edu> + * & Mark Gates <mgates@nlanr.net> + * ------------------------------------------------------------------- + * Strings and other stuff that is locale specific. + * ------------------------------------------------------------------- */ +#include "headers.h" +#include "version.h" + +#ifdef __cplusplus +extern "C" { +#endif +/* ------------------------------------------------------------------- + * usage + * ------------------------------------------------------------------- */ + +const char usage_short[] = "\ +Usage: %s [-s|-c host] [options]\n\ +Try `%s --help' for more information.\n"; + +const char usage_long1[] = "\ +Usage: iperf [-s|-c host] [options]\n\ + iperf [-h|--help] [-v|--version]\n\ +\n\ +Client/Server:\n\ + -b, --bandwidth #[kmgKMG | pps] bandwidth to read/send at in bits/sec or packets/sec\n\ + -e, --enhanced use enhanced reporting giving more tcp/udp and traffic information\n\ + -f, --format [kmgKMG] format to report: Kbits, Mbits, KBytes, MBytes\n\ + --hide-ips hide ip addresses and host names within outputs\n\ + -i, --interval # seconds between periodic bandwidth reports\n\ + -l, --len #[kmKM] length of buffer in bytes to read or write (Defaults: TCP=128K, v4 UDP=1470, v6 UDP=1450)\n\ + -m, --print_mss print TCP maximum segment size\n\ + -o, --output <filename> output the report or error message to this specified file\n\ + -p, --port # client/server port to listen/send on and to connect\n\ + --permit-key permit key to be used to verify client and server (TCP only)\n\ + --sum-only output sum only reports\n\ + -u, --udp use UDP rather than TCP\n\ + --utc use coordinated universal time (UTC) with time output\n\ + -w, --window #[KM] TCP window size (socket buffer size)\n" +#ifdef HAVE_SCHED_SETSCHEDULER +" -z, --realtime request realtime scheduler\n" +#endif +" -B, --bind <host>[:<port>][%<dev>] bind to <host>, ip addr (including multicast address) and optional port and device\n\ + -C, --compatibility for use with older versions does not sent extra msgs\n\ + --NUM_REPORT_STRUCTS increase the shared memory between the traffic threads and the reporter thread (default is 10,000 entries)\n\ + -M, --mss # set TCP maximum segment size using TCP_MAXSEG\n\ + -N, --nodelay set TCP no delay, disabling Nagle's Algorithm\n\ + -S, --tos # set the socket's IP_TOS (byte) field\n\ + -Z, --tcp-congestion <algo> set TCP congestion control algorithm (Linux only)\n\ +\n\ +Server specific:\n\ + -p, --port #[-#] server port(s) to listen on/connect to\n\ + -s, --server run in server mode\n\ + -1, --singleclient run one server at a time\n\ + --histograms enable latency histograms\n\ + --jitter-histograms enable jitter histograms\n\ + --permit-key-timeout set the timeout for a permit key in seconds\n\ + --tcp-rx-window-clamp set the TCP receive window clamp size in bytes\n\ + --tap-dev #[<dev>] use TAP device to receive at L2 layer\n\ + -t, --time # time in seconds to listen for new connections as well as to receive traffic (default not set)\n\ + -B, --bind <ip>[%<dev>] bind to multicast address and optional device\n\ + -U, --single_udp run in single threaded UDP mode\n\ + --sum-dstip sum traffic threads based upon destination ip address (default is src ip)\n\ + -D, --daemon run the server as a daemon\n" +#ifdef WIN32 +" -R, --remove remove service in win32\n" +#endif +" -V, --ipv6_domain Enable IPv6 reception by setting the domain and socket to AF_INET6 (Can receive on both IPv4 and IPv6)\n" +; + +const char usage_long2[] = "\ +\n\ +Client specific:\n\ + --bounceback request a bounceback test (use -l for size, defaults to 100 bytes)\n\ + --bounceback-hold request the server to insert a delay of n milliseconds between its read and write\n\ + --bounceback-period request the client schedule a send every n milliseconds\n\ + --bounceback-no-quickack request the server not set the TCP_QUICKACK socket option (disabling TCP ACK delays) during a bounceback test\n\ + -c, --client <host> run in client mode, connecting to <host>\n\ + --connect-only run a connect only test\n\ + --connect-retries # number of times to retry tcp connect\n\ + -d, --dualtest Do a bidirectional test simultaneously (multiple sockets)\n\ + --fq-rate #[kmgKMG] bandwidth to socket pacing\n\ + --full-duplex run full duplex test using same socket\n\ + --ipg set the the interpacket gap (milliseconds) for packets within an isochronous frame\n\ + --isochronous <frames-per-second>:<mean>,<stddev> send traffic in bursts (frames - emulate video traffic)\n\ + --incr-dstip Increment the destination ip with parallel (-P) traffic threads\n\ + --incr-dstport Increment the destination port with parallel (-P) traffic threads\n\ + --incr-srcip Increment the source ip with parallel (-P) traffic threads\n\ + --incr-srcport Increment the source port with parallel (-P) traffic threads\n\ + --local-only Set don't route on socket\n\ + --near-congestion=[w] Use a weighted write delay per the sampled TCP RTT (experimental)\n\ + --no-connect-sync No sychronization after connect when -P or parallel traffic threads\n\ + --no-udp-fin No final server to client stats at end of UDP test\n\ + -n, --num #[kmgKMG] number of bytes to transmit (instead of -t)\n\ + -r, --tradeoff Do a fullduplexectional test individually\n\ + --tcp-quickack set the socket's TCP_QUICKACK option (off by default)\n\ + --tcp-write-prefetch set the socket's TCP_NOTSENT_LOWAT value in bytes and use event based writes\n\ + --tcp-write-times measure the socket write times at the application level\n\ + -t, --time # time in seconds to transmit for (default 10 secs)\n\ + --trip-times enable end to end measurements (requires client and server clock sync)\n\ + --txdelay-time time in seconds to hold back after connect and before first write\n\ + --txstart-time unix epoch time to schedule first write and start traffic\n\ + -B, --bind [<ip> | <ip:port>] bind ip (and optional port) from which to source traffic\n\ + -F, --fileinput <name> input the data to be transmitted from a file\n\ + -H, --ssm-host <ip> set the SSM source, use with -B for (S,G) \n\ + -I, --stdin input the data to be transmitted from stdin\n\ + -L, --listenport # port to receive fullduplexectional tests back on\n\ + -P, --parallel # number of parallel client threads to run\n" +#ifndef WIN32 +" -R, --reverse reverse the test (client receives, server sends)\n" +#else +" -R Remove the windows service\n" +" --reverse reverse the test (client receives, server sends)\n" +#endif +" -S, --tos IP DSCP or tos settings\n\ + -T, --ttl # time-to-live, for multicast (default 1)\n\ + --working-load request a concurrent TCP stream\n\ + -V, --ipv6_domain Set the domain to IPv6 (send packets over IPv6)\n\ + -X, --peer-detect perform server version detection and version exchange\n\ +\n\ +Miscellaneous:\n\ + -x, --reportexclude [CDMSV] exclude C(connection) D(data) M(multicast) S(settings) V(server) reports\n\ + -y, --reportstyle C report as a Comma-Separated Values\n\ + -h, --help print this message and quit\n\ + -v, --version print version information and quit\n\ +\n\ +[kmgKMG] Indicates options that support a k,m,g,K,M or G suffix\n\ +Lowercase format characters are 10^3 based and uppercase are 2^n based\n\ +(e.g. 1k = 1000, 1K = 1024, 1m = 1,000,000 and 1M = 1,048,576)\n\ +\n\ +Accepted tos values are: af11, af12, af13, af21, af22, af23, af31, af32, af33, af41, af42, af43,\n\ +cs0, cs1, cs2, cs3, cs4, cs5, cs6, cs7, ef, le, nqb, nqb2, ac_be, ac_bk, ac_vi, ac_vo, lowdelay, throughput,\n\ +reliability, or a numeric value.\n\ +\n\ +The TCP window size option can be set by the environment variable\n\ +TCP_WINDOW_SIZE. Most other options can be set by an environment variable\n\ +IPERF_<long option name>, such as IPERF_BANDWIDTH.\n\ +\n\ +Source at <http://sourceforge.net/projects/iperf2/>\n\ +Report bugs to <iperf-users@lists.sourceforge.net>\n"; + +// include a description of the threading in the version +#if defined( HAVE_POSIX_THREAD ) + #define IPERF_THREADS "pthreads" +#elif defined( HAVE_WIN32_THREAD ) + #define IPERF_THREADS "win32 threads" +#else + #define IPERF_THREADS "single threaded" +#endif + +const char version[] = +"iperf version " IPERF_VERSION " (" IPERF_VERSION_DATE ") " IPERF_THREADS "\n"; + +/* ------------------------------------------------------------------- + * settings + * ------------------------------------------------------------------- */ + +const char separator_line[] = +"------------------------------------------------------------\n"; + +const char server_port[] = +"Server listening on %s port %d\n"; + +const char client_port[] = +"Client connecting to %s, %s port %d\n"; + +const char server_pid_port[] = +"Server listening on %s port %d with pid %d\n"; + +const char server_pid_portrange[] = +"Server listening on %s ports %d-%d with pid %d\n"; + +const char client_pid_port[] = +"Client connecting to %s, %s port %d with pid %d (%d flows)\n"; + +const char client_pid_port_dev[] = +"Client connecting to %s, %s port %d with pid %d via %s (%d flows)\n"; + +const char bind_address[] = +"Binding to local address %s\n"; + +const char bind_address_iface[] = +"Binding to local address %s and iface %s\n"; + +const char bind_address_iface_taptun[] = +"Using virtual iface %s (AF_PACKET & SOCK_RAW)\n"; + +const char multicast_ttl[] = +"Setting multicast TTL to %d\n"; + +const char join_multicast[] = +"Joining multicast group %s\n"; + +const char join_multicast_sg[] = +"Joining multicast (S,G)=%s,%s\n"; + +const char join_multicast_starg_dev[] = +"Joining multicast (*,G)=*,%s w/iface %s\n"; + +const char join_multicast_sg_dev[] = +"Joining multicast (S,G)=%s,%s w/iface %s\n"; + +const char client_datagram_size[] = +"Sending %d byte datagrams, IPG target: %.2f us\n"; + +const char client_datagram_size_kalman[] = +"Sending %d byte datagrams, IPG target: %.2f us (kalman adjust)\n"; + +const char server_datagram_size[] = +"Receiving %d byte datagrams\n"; + +const char tcp_window_size[] = +"TCP window size"; + +const char udp_buffer_size[] = +"UDP buffer size"; + +const char window_default[] = +"(default)"; + +const char wait_server_threads[] = +"Waiting for server threads to complete. Interrupt again to force quit.\n"; + +const char client_isochronous[] = +"Isochronous: %0.2f frames/sec mean=%s/s, stddev=%s/s, Period/IPG=%0.2f/%.3f ms\n"; + +const char client_burstperiod[] = +"Bursting: %s every %0.2f second(s)\n"; + +const char client_burstperiodcount[] = +"Bursting: %s writes %d times every %0.2f second(s)\n"; + +const char client_bounceback[] = +"Bounce-back test (size=%s) (server hold req=%d usecs & tcp_quickack)\n"; + +const char client_bounceback_noqack[] = +"Bounce-back test (size=%s) (server hold req=%d usecs)\n"; + +const char server_burstperiod[] = +"Burst wait timeout set to (2 * %0.2f) seconds (use --burst-period=<n secs> to change)\n"; + +const char client_fq_pacing [] = +"fair-queue socket pacing set to %s/s\n"; + +/* ------------------------------------------------------------------- + * Legacy reports + * ------------------------------------------------------------------- */ + +const char report_bw_header[] = +"[ ID] Interval Transfer Bandwidth\n"; + +const char report_bw_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_sum_bw_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_sumcnt_bw_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_bw_jitter_loss_header[] = +"[ ID] Interval Transfer Bandwidth Jitter Lost/Total Datagrams\n"; + +const char report_bw_jitter_loss_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%)\n"; + +const char report_sum_bw_jitter_loss_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " (%.2g%%)\n"; + +const char report_sumcnt_bw_jitter_loss_header[] = +"[SUM-cnt] Interval Transfer Bandwidth Lost/Total PPS\n"; + +const char report_sumcnt_bw_jitter_loss_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %8.0f pps\n"; + +/* ------------------------------------------------------------------- + * Enhanced reports (per -e) + * ------------------------------------------------------------------- */ +const char report_sumcnt_bw_header[] = +"[SUM-cnt] Interval Transfer Bandwidth\n"; + +const char client_report_epoch_start_current[] = +"[%3d] Client traffic to start in %d seconds at %s current time is %s\n"; + +const char client_write_size[] = +"Write buffer size"; + +const char server_read_size[] = +"Read buffer size"; + +const char report_bw_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_sum_bw_enhanced_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_bw_read_enhanced_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Reads=Dist\n"; + +const char report_bw_read_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +const char report_sumcnt_bw_read_enhanced_header[] = +"[SUM-cnt] Interval" IPERFTimeSpace "Transfer Bandwidth Reads=Dist\n"; + +const char report_sumcnt_bw_read_enhanced_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +const char report_sumcnt_bw_read_triptime_header[] = +"[SUM-cnt] Interval" IPERFTimeSpace "Transfer Bandwidth InP Reads=Dist\n"; + +const char report_sumcnt_bw_read_triptime_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %s %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +const char report_bw_read_enhanced_netpwr_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Burst Latency avg/min/max/stdev (cnt/size) inP NetPwr Reads=Dist\n"; + +const char report_bw_read_enhanced_netpwr_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %.3f/%.3f/%.3f/%.3f ms (%d/%d) %s %s %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +const char report_bw_isoch_enhanced_netpwr_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Burst Latency avg/min/max/stdev (cnt/size) NetPwr Reads=Dist\n"; + +const char report_bw_isoch_enhanced_netpwr_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %.3f/%.3f/%.3f/%.3f ms (%d/%d) %s %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +const char report_sum_bw_read_enhanced_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +const char report_triptime_enhanced_format[] = +"%s" IPERFTimeFrmt " trip-time (3WHS done->fin+finack) = %.4f sec\n"; + +#if HAVE_TCP_STATS +const char report_client_bb_bw_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth BB cnt=avg/min/max/stdev Rtry Cwnd/RTT RPS\n"; + +const char report_client_bb_bw_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "=%.3f/%.3f/%.3f/%.3f ms %4d %4dK/%u us %s rps\n"; +#else +const char report_client_bb_bw_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth BB cnt=avg/min/max/stdev RPS\n"; + +const char report_client_bb_bw_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "=%.3f/%.3f/%.3f/%.3f ms %s rps\n"; +#endif +const char report_client_bb_bw_triptime_format[] = +"%s" IPERFTimeFrmt " sec OWD Delays (ms) Cnt=%" PRIdMAX " To=%.3f/%.3f/%.3f/%.3f From=%.3f/%.3f/%.3f/%.3f Asymmetry=%.3f/%.3f/%.3f/%.3f %s rps\n"; + +const char report_write_enhanced_write_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err Rtry Cwnd/RTT NetPwr write-times avg/min/max/stdev (cnt)\n"; + +const char report_write_enhanced_write_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %10" PRIdMAX "%8dK/%u us %s %.3f/%.3f/%.3f/%.3f ms (%" PRIdMAX ")\n"; + +const char report_write_enhanced_nocwnd_write_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %10" PRIdMAX " NA/%u us %s %.3f/%.3f/%.3f/%.3f ms (%" PRIdMAX ")\n"; + + +#if HAVE_TCP_STATS +const char report_bw_write_enhanced_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err Rtry Cwnd/RTT(var) NetPwr\n"; + +const char report_sum_bw_write_enhanced_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "%10" PRIdMAX "\n"; + +const char report_bw_write_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "%10" PRIdMAX " %8dK/%u(%u) us %s\n"; + +const char report_bw_write_enhanced_nocwnd_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %10" PRIdMAX " NA/%u us %s\n"; + +const char report_write_enhanced_isoch_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err Rtry Cwnd/RTT isoch:tx/miss/slip NetPwr\n"; + +const char report_write_enhanced_isoch_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %8d %8dK/%u us %9" PRIuMAX "/%" PRIuMAX "/%" PRIuMAX " %s\n"; + +const char report_write_enhanced_isoch_nocwnd_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %10" PRIdMAX " NA/%u us %9" PRIuMAX "/%" PRIuMAX "/%" PRIuMAX " %s\n"; + +#else + +const char report_bw_write_enhanced_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err\n"; + +const char report_bw_write_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "\n"; + +const char report_sum_bw_write_enhanced_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "\n"; + +const char report_write_enhanced_isoch_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err isoch:tx/miss/slip\n"; + +const char report_write_enhanced_isoch_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "%9" PRIuMAX "/%" PRIuMAX "/%" PRIuMAX "\n"; +#endif + +const char report_sumcnt_bw_write_enhanced_header[] = +"[SUM-cnt] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err Rtry\n"; + +const char report_sumcnt_bw_write_enhanced_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "%10" PRIdMAX "\n"; + +const char report_bw_pps_enhanced_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err PPS\n"; + +const char report_bw_pps_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %8.0f pps\n"; + +const char report_sumcnt_bw_pps_enhanced_header[] = +"[SUM-cnt] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err PPS\n"; + +const char report_sumcnt_bw_pps_enhanced_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %8.0f pps\n"; + +const char report_sumcnt_udp_enhanced_header[] = +"[SUM-cnt] Interval" IPERFTimeSpace "Transfer Bandwidth Lost/Total PPS\n"; + +const char report_sumcnt_udp_enhanced_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %8.0f pps\n"; + +const char report_sumcnt_udp_triptime_header[] = +"[SUM-cnt] Interval" IPERFTimeSpace "Transfer Bandwidth Lost/Total Rx/inP PPS\n"; + +const char report_sumcnt_udp_triptime_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX " %" PRIdMAX "/%.0f %8.0f pps\n"; + +const char report_bw_pps_enhanced_isoch_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Write/Err PPS isoch:tx/miss/slip\n"; + +const char report_bw_pps_enhanced_isoch_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "%8.0f pps %3" PRIuMAX "/%" PRIuMAX "/%" PRIuMAX "\n"; + +const char report_sum_bw_pps_enhanced_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "/%" PRIdMAX "%8.0f pps\n"; + +const char report_bw_jitter_loss_pps_header[] = +"[ ID] Interval Transfer Bandwidth Jitter Lost/Total Datagrams PPS\n"; + +const char report_bw_jitter_loss_pps_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %8.0f pps\n"; + +const char report_bw_jitter_loss_enhanced_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Jitter Lost/Total \ + Latency avg/min/max/stdev PPS NetPwr\n"; + +const char report_bw_jitter_loss_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %.3f/%.3f/%.3f/%.3f ms %.0f pps %s\n"; + +const char report_bw_jitter_loss_enhanced_triptime_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Jitter Lost/Total \ + Latency avg/min/max/stdev PPS Rx/inP NetPwr\n"; + +const char report_bw_jitter_loss_enhanced_triptime_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %.3f/%.3f/%.3f/%.3f ms %.0f pps %" PRIdMAX "/%s %s\n"; + +const char report_bw_jitter_loss_enhanced_isoch_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Jitter Lost/Total \ + Latency avg/min/max/stdev PPS NetPwr Isoch:rx/lost\n"; + +const char report_bw_jitter_loss_enhanced_isoch_triptime_header[] = +"[ ID] Interval" IPERFTimeSpace "Transfer Bandwidth Jitter Lost/Total \ +Latency avg/min/max/stdev PPS Frame:rx/lost Frame-latency avg/min/max/stdev NetPwr\n"; + +const char report_bw_jitter_loss_enhanced_isoch_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %.3f/%.3f/%.3f/%.3f ms %.0f pps %3d/%d %.3f/%.3f/%.3f/%.3f ms %s\n"; + +const char report_sum_bw_jitter_loss_enhanced_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %.0f pps\n"; + +const char report_sumcnt_bw_jitter_loss_enhanced_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %.0f pps\n"; + +const char report_bw_jitter_loss_suppress_enhanced_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) -/-/-/- ms %.0f pps\n"; + +/* + * Frame interval reports + */ +#define IPERFFTimeFrmt "%4.4f-%4.4f" +#define IPERFFTimeSpace " " +const char report_frame_jitter_loss_enhanced_header[] = +"[ ID] Interval(f-transit)" IPERFFTimeSpace "Transfer Bandwidth FrameID Jitter Lost/Total \ + Latency avg/min/max/stdev PPS inP NetPwr\n"; + +const char report_frame_jitter_loss_enhanced_format[] = +"%s" IPERFFTimeFrmt "(%0.4f) sec %ss %ss/sec %" PRIdMAX " %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) %.3f/%.3f/%.3f/%.3f ms %.0f pps %2.0f pkts %s\n"; + +const char report_frame_jitter_loss_suppress_enhanced_format[] = +"%s" IPERFTimeFrmt "(%0.4f) sec %" PRIdMAX " %ss %ss/sec %" PRIdMAX " %6.3f ms %" PRIdMAX "/%" PRIdMAX " (%.2g%%) -/-/-/- ms %.0f pps\n"; + +const char report_frame_tcp_enhanced_header[] = +"[ ID] Interval(f-transit)" IPERFFTimeSpace "Transfer Bandwidth FrameID\n"; + +const char report_burst_read_tcp_header[] = +"[ ID] Burst (start-end)" IPERFFTimeSpace "Transfer Bandwidth XferTime (DC%) Reads=Dist NetPwr\n"; + +const char report_burst_read_tcp_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms (%.2g%%) %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d %s\n"; + +const char report_burst_read_tcp_final_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %.3f/%.3f/%.3f/%.3f ms %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; +#if HAVE_TCP_STATS +const char report_burst_write_tcp_header[] = +"[ ID] Burst (start-end)" IPERFFTimeSpace "Transfer Bandwidth XferTime Write/Err Rtry Cwnd/RTT NetPwr\n"; + +const char report_burst_write_tcp_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX "%10" PRIdMAX "%8dK/%u %s\n"; + +#else +const char report_burst_write_tcp_header[] = +"[ ID] Burst (start-end)" IPERFFTimeSpace "Transfer Bandwidth XferTime Write/Err\n"; + +const char report_burst_write_tcp_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX"\n"; +#endif + +const char report_burst_write_tcp_nocwnd_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %6.3f ms %" PRIdMAX "/%" PRIdMAX "%10" PRIdMAX "NA/%u %s\n"; + +const char report_burst_write_tcp_final_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "=%d:%d:%d:%d:%d:%d:%d:%d\n"; + +/* ------------------------------------------------------------------- + * Fullduplex reports + * ------------------------------------------------------------------- */ +const char report_bw_sum_fullduplex_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_bw_sum_fullduplex_enhanced_format[] = +"[FD%d] " IPERFTimeFrmt " sec %ss %ss/sec\n"; + +const char report_udp_fullduplex_header[] = +"[ ID] Interval Transfer Bandwidth Datagrams PPS\n"; + +const char report_sumcnt_udp_fullduplex_header[] = +"[SUM-cnt] Interval Transfer Bandwidth Datagrams PPS\n"; + +const char report_sumcnt_udp_fullduplex_format[] = +"[SUM-%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "%8.0f pps\n"; + +const char report_udp_fullduplex_format[] = +"%s" IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "%8.0f pps\n"; + +const char report_udp_fullduplex_enhanced_format[] = +"[FD%d] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "%8.0f pps\n"; + +const char report_udp_fullduplex_sum_format[] = +"[SUM] " IPERFTimeFrmt " sec %ss %ss/sec %" PRIdMAX "%8.0f pps\n"; + +/* ------------------------------------------------------------------- + * Misc reports + * ------------------------------------------------------------------- */ +const char report_outoforder[] = +"%s" IPERFTimeFrmt " sec %d datagrams received out-of-order\n"; + +const char report_sumcnt_outoforder[] = +"[SUM-%d] " IPERFTimeFrmt " sec %d datagrams received out-of-order\n"; + +const char report_l2statistics[] = +"%s" IPERFTimeFrmt " sec L2 processing detected errors, total(length/checksum/unknown) = %" PRIdMAX "(%" PRIdMAX "/%" PRIdMAX "/%" PRIdMAX ")\n"; + +const char report_sum_outoforder[] = +"[SUM] " IPERFTimeFrmt " sec %d datagrams received out-of-order\n"; + +const char report_peer [] = +"%slocal %s port %u connected with %s port %u%s\n"; + +const char report_peer_dev [] = +"%slocal %s%%%s port %u connected with %s port %u%s\n"; + +const char report_peer_fail [] = +"[drop] local %s port %u connection with %s port %u%s (permit key fail)\n"; + +const char report_mss_unsupported[] = +"%sMSS and MTU size unknown (TCP_MAXSEG not supported)\n"; + +const char report_default_mss[] = +"MSS size %d bytes\n"; + +const char report_mss[] = +"MSS req size %d bytes (per TCP_MAXSEG)\n"; + +const char report_datagrams[] = +"[%3d] Sent %d datagrams\n"; + +const char report_sumcnt_datagrams[] = +"[SUM-%d] Sent %d datagrams\n"; + +const char report_sum_datagrams[] = +"[SUM] Sent %d datagrams\n"; + +const char server_reporting[] = +"[%3d] Server Report:\n"; + +const char reportCSV_peer[] = +"%s,%u,%s,%u"; + +const char report_l2length_error[] = +"%s" IPERFTimeFrmt " sec %d datagrams received out-of-order\n"; + +/*------------------------------------------------------------------- + * CSV outputs + *------------------------------------------------------------------*/ +const char reportCSV_bw_format[] = +"%s,%s,%d,%.1f-%.1f,%" PRIdMAX ",%" PRIdMAX "\n"; + +const char reportCSV_bw_read_enhanced_format[] = +"%s,%s,%d,%.1f-%.1f,%" PRIdMAX ",%" PRIdMAX ",%" PRIdMAX ",%d,%d,%d,%d,%d,%d,%d,%d\n"; + +const char reportCSV_bw_write_enhanced_format[] = +"%s,%s,%d,%.1f-%.1f,%" PRIdMAX ",%" PRIdMAX ",%" PRIdMAX ",%" PRIdMAX ",%" PRIdMAX ",%d,%u,%u\n"; + +const char reportCSV_bw_jitter_loss_format[] = +"%s,%s,%d,%.1f-%.1f,%" PRIdMAX ",%" PRIdMAX ",%.3f,%" PRIdMAX ",%" PRIdMAX ",%.3f,%" PRIdMAX "\n"; + +const char reportCSV_bw_jitter_loss_pps_format[] = +"%s,%s,%d,%.1f-%.1f,%" PRIdMAX ",%" PRIdMAX ",%.3f,%" PRIdMAX ",%" PRIdMAX ",%.3f,%" PRIdMAX ",%" PRIdMAX ",%" PRIdMAX ",%f\n"; + +/* ------------------------------------------------------------------- + * warnings + * ------------------------------------------------------------------- */ + +const char warn_window_requested[] = +" (WARNING: requested %s)"; + +const char warn_window_small[] = "\ +WARNING: TCP window size set to %d bytes. A small window size\n\ +will give poor performance. See the Iperf documentation.\n"; + +const char warn_delay_large[] = +"WARNING: delay too large, reducing from %.1f to 1.0 seconds.\n"; + +const char warn_no_pathmtu[] = +"WARNING: Path MTU Discovery may not be enabled.\n"; + +const char warn_no_ack[]= +"[%3d] WARNING: did not receive ack of last datagram after %d tries.\n"; + +const char warn_ack_failed[]= +"[%3d] WARNING: ack of last datagram failed.\n"; + +const char warn_fileopen_failed[]= +"WARNING: Unable to open file stream for transfer\n\ +Using default data stream. \n"; + +const char unable_to_change_win[]= +"WARNING: Unable to change the window size\n"; + +const char opt_estimate[]= +"Optimal Estimate\n"; + +#ifdef HAVE_FASTSAMPLING +const char report_interval_small[] = +"WARNING: interval too small, increasing to %3.4f milliseconds.\n"; +#else +const char report_interval_small[] = +"WARNING: interval too small, increasing to %3.3f milliseconds.\n"; +#endif +const char warn_invalid_server_option[] = +"WARNING: option -%c is not valid for server mode\n"; + +const char warn_invalid_client_option[] = +"WARNING: option -%c is not valid for client mode\n"; + +const char warn_invalid_compatibility_option[] = +"WARNING: option -%c is not valid in compatibility mode\n"; + +const char warn_implied_udp[] = +"WARNING: option -%c implies udp testing\n"; + +const char warn_implied_compatibility[] = +"WARNING: option -%c has implied compatibility mode\n"; + +const char warn_buffer_too_small[] = +"WARNING: %s socket buffer size (-l value) increased to %d bytes for proper operation\n"; + +const char warn_invalid_single_threaded[] = +"WARNING: option -%c is not valid in single threaded versions\n"; + +const char warn_invalid_report_style[] = +"WARNING: unknown reporting style \"%s\", switching to default\n"; + +const char warn_invalid_report[] = +"WARNING: unknown reporting type \"%c\", ignored\n valid options are:\n\t exclude: C(connection) D(data) M(multicast) S(settings) V(server) report\n\n"; + +const char warn_server_old[] = +"WARNING: iperf server version is likely very old\n"; + +const char warn_test_exchange_failed[] = +"WARNING: client/server version exchange failed\n"; + +const char warn_len_too_small_peer_exchange[] = +"WARNING: %s option -l value of %d is too small for peer exchange (suggested min value is %d bytes)\n"; + +const char warn_compat_and_peer_exchange[] = +"WARNING: Options of '-C' '--compatibility' AND '-X' '--peerdetect' are mutually exclusive, --peerdetect ignored\n"; + +const char warn_start_before_now[] = +"[%3d] WARNING: --txstart-time (%" PRIdMAX ".%" PRIdMAX ") %s is before now %s\n"; + +const char error_starttime_exceeds[] = +"ERROR: --txstart-time (%" PRIdMAX ".%" PRIdMAX ") %s exceeds max scheduled delay of %d secs\n"; + +const char error_delaytime_exceeds[] = +"ERROR: --txdelay-time of %d seconds is more than the supported delay of %d seconds\n"; + +#ifdef __cplusplus +} /* end extern "C" */ +#endif diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..37db611 --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,71 @@ +bin_PROGRAMS = iperf + +LIBCOMPAT_LDADDS = @STRIP_BEGIN@ \ + $(top_builddir)/compat/libcompat.a \ + @STRIP_END@ + +AM_CPPFLAGS = @STRIP_BEGIN@ \ + -I$(top_srcdir)/include \ + -I$(top_builddir)/include \ + @STRIP_END@ + +AM_CXXFLAGS = -Wall +AM_CFLAGS = -Wall + +if DEBUG_SYMBOLS +AM_CFLAGS += -g3 -O0 +AM_CXXFLAGS += -g3 -O0 +else +AM_CFLAGS += -O2 +AM_CXXFLAGS += -O2 +endif + + +iperf_LDFLAGS = @CFLAGS@ @PTHREAD_CFLAGS@ @WEB100_CFLAGS@ @DEFS@ + +iperf_SOURCES = \ + Client.cpp \ + Extractor.c \ + isochronous.cpp \ + Launch.cpp \ + active_hosts.cpp \ + Listener.cpp \ + Locale.c \ + PerfSocket.cpp \ + Reporter.c \ + Reports.c \ + ReportOutputs.c \ + Server.cpp \ + Settings.cpp \ + SocketAddr.c \ + gnu_getopt.c \ + gnu_getopt_long.c \ + histogram.c \ + main.cpp \ + service.c \ + socket_io.c \ + stdio.c \ + packet_ring.c \ + tcp_window_size.c \ + pdfs.c \ + dscp.c \ + iperf_formattime.c +iperf_LDADD = $(LIBCOMPAT_LDADDS) + + +if CHECKPROGRAMS +noinst_PROGRAMS = checkdelay checkpdfs checkisoch igmp_querier +checkdelay_SOURCES = checkdelay.c +checkdelay_LDADD = $(LIBCOMPAT_LDADDS) +checkpdfs_SOURCES = pdfs.c checkpdfs.c stdio.c +checkpdfs_LDADD = -lm +checkisoch_SOURCES = checkisoch.cpp isochronous.cpp pdfs.c stdio.c +igmp_querier_SOURCES = igmp_querier.c +checkisoch_LDADD = $(LIBCOMPAT_LDADDS) +endif + + +if AF_PACKET +iperf_SOURCES += checksums.c +endif + diff --git a/src/Makefile.in b/src/Makefile.in new file mode 100644 index 0000000..a8ab595 --- /dev/null +++ b/src/Makefile.in @@ -0,0 +1,829 @@ +# Makefile.in generated by automake 1.16.2 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994-2020 Free Software Foundation, Inc. + +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +am__is_gnu_make = { \ + if test -z '$(MAKELEVEL)'; then \ + false; \ + elif test -n '$(MAKE_HOST)'; then \ + true; \ + elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ + true; \ + else \ + false; \ + fi; \ +} +am__make_running_with_option = \ + case $${target_option-} in \ + ?) ;; \ + *) echo "am__make_running_with_option: internal error: invalid" \ + "target option '$${target_option-}' specified" >&2; \ + exit 1;; \ + esac; \ + has_opt=no; \ + sane_makeflags=$$MAKEFLAGS; \ + if $(am__is_gnu_make); then \ + sane_makeflags=$$MFLAGS; \ + else \ + case $$MAKEFLAGS in \ + *\\[\ \ ]*) \ + bs=\\; \ + sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ + | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ + esac; \ + fi; \ + skip_next=no; \ + strip_trailopt () \ + { \ + flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ + }; \ + for flg in $$sane_makeflags; do \ + test $$skip_next = yes && { skip_next=no; continue; }; \ + case $$flg in \ + *=*|--*) continue;; \ + -*I) strip_trailopt 'I'; skip_next=yes;; \ + -*I?*) strip_trailopt 'I';; \ + -*O) strip_trailopt 'O'; skip_next=yes;; \ + -*O?*) strip_trailopt 'O';; \ + -*l) strip_trailopt 'l'; skip_next=yes;; \ + -*l?*) strip_trailopt 'l';; \ + -[dEDm]) skip_next=yes;; \ + -[JT]) skip_next=yes;; \ + esac; \ + case $$flg in \ + *$$target_option*) has_opt=yes; break;; \ + esac; \ + done; \ + test $$has_opt = yes +am__make_dryrun = (target_option=n; $(am__make_running_with_option)) +am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +bin_PROGRAMS = iperf$(EXEEXT) +@DEBUG_SYMBOLS_TRUE@am__append_1 = -g3 -O0 +@DEBUG_SYMBOLS_TRUE@am__append_2 = -g3 -O0 +@DEBUG_SYMBOLS_FALSE@am__append_3 = -O2 +@DEBUG_SYMBOLS_FALSE@am__append_4 = -O2 +@CHECKPROGRAMS_TRUE@noinst_PROGRAMS = checkdelay$(EXEEXT) \ +@CHECKPROGRAMS_TRUE@ checkpdfs$(EXEEXT) checkisoch$(EXEEXT) \ +@CHECKPROGRAMS_TRUE@ igmp_querier$(EXEEXT) +@AF_PACKET_TRUE@am__append_5 = checksums.c +subdir = src +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/ax_create_stdint_h.m4 \ + $(top_srcdir)/m4/dast.m4 $(top_srcdir)/m4/ax_pthread.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__installdirs = "$(DESTDIR)$(bindir)" +PROGRAMS = $(bin_PROGRAMS) $(noinst_PROGRAMS) +am__checkdelay_SOURCES_DIST = checkdelay.c +@CHECKPROGRAMS_TRUE@am_checkdelay_OBJECTS = checkdelay.$(OBJEXT) +checkdelay_OBJECTS = $(am_checkdelay_OBJECTS) +am__DEPENDENCIES_1 = $(top_builddir)/compat/libcompat.a +@CHECKPROGRAMS_TRUE@checkdelay_DEPENDENCIES = $(am__DEPENDENCIES_1) +am__checkisoch_SOURCES_DIST = checkisoch.cpp isochronous.cpp pdfs.c \ + stdio.c +@CHECKPROGRAMS_TRUE@am_checkisoch_OBJECTS = checkisoch.$(OBJEXT) \ +@CHECKPROGRAMS_TRUE@ isochronous.$(OBJEXT) pdfs.$(OBJEXT) \ +@CHECKPROGRAMS_TRUE@ stdio.$(OBJEXT) +checkisoch_OBJECTS = $(am_checkisoch_OBJECTS) +@CHECKPROGRAMS_TRUE@checkisoch_DEPENDENCIES = $(am__DEPENDENCIES_1) +am__checkpdfs_SOURCES_DIST = pdfs.c checkpdfs.c stdio.c +@CHECKPROGRAMS_TRUE@am_checkpdfs_OBJECTS = pdfs.$(OBJEXT) \ +@CHECKPROGRAMS_TRUE@ checkpdfs.$(OBJEXT) stdio.$(OBJEXT) +checkpdfs_OBJECTS = $(am_checkpdfs_OBJECTS) +checkpdfs_DEPENDENCIES = +am__igmp_querier_SOURCES_DIST = igmp_querier.c +@CHECKPROGRAMS_TRUE@am_igmp_querier_OBJECTS = igmp_querier.$(OBJEXT) +igmp_querier_OBJECTS = $(am_igmp_querier_OBJECTS) +igmp_querier_LDADD = $(LDADD) +am__iperf_SOURCES_DIST = Client.cpp Extractor.c isochronous.cpp \ + Launch.cpp active_hosts.cpp Listener.cpp Locale.c \ + PerfSocket.cpp Reporter.c Reports.c ReportOutputs.c Server.cpp \ + Settings.cpp SocketAddr.c gnu_getopt.c gnu_getopt_long.c \ + histogram.c main.cpp service.c socket_io.c stdio.c \ + packet_ring.c tcp_window_size.c pdfs.c dscp.c \ + iperf_formattime.c checksums.c +@AF_PACKET_TRUE@am__objects_1 = checksums.$(OBJEXT) +am_iperf_OBJECTS = Client.$(OBJEXT) Extractor.$(OBJEXT) \ + isochronous.$(OBJEXT) Launch.$(OBJEXT) active_hosts.$(OBJEXT) \ + Listener.$(OBJEXT) Locale.$(OBJEXT) PerfSocket.$(OBJEXT) \ + Reporter.$(OBJEXT) Reports.$(OBJEXT) ReportOutputs.$(OBJEXT) \ + Server.$(OBJEXT) Settings.$(OBJEXT) SocketAddr.$(OBJEXT) \ + gnu_getopt.$(OBJEXT) gnu_getopt_long.$(OBJEXT) \ + histogram.$(OBJEXT) main.$(OBJEXT) service.$(OBJEXT) \ + socket_io.$(OBJEXT) stdio.$(OBJEXT) packet_ring.$(OBJEXT) \ + tcp_window_size.$(OBJEXT) pdfs.$(OBJEXT) dscp.$(OBJEXT) \ + iperf_formattime.$(OBJEXT) $(am__objects_1) +iperf_OBJECTS = $(am_iperf_OBJECTS) +iperf_DEPENDENCIES = $(am__DEPENDENCIES_1) +iperf_LINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(iperf_LDFLAGS) \ + $(LDFLAGS) -o $@ +AM_V_P = $(am__v_P_@AM_V@) +am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) +am__v_P_0 = false +am__v_P_1 = : +AM_V_GEN = $(am__v_GEN_@AM_V@) +am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) +am__v_GEN_0 = @echo " GEN " $@; +am__v_GEN_1 = +AM_V_at = $(am__v_at_@AM_V@) +am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) +am__v_at_0 = @ +am__v_at_1 = +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__maybe_remake_depfiles = depfiles +am__depfiles_remade = ./$(DEPDIR)/Client.Po ./$(DEPDIR)/Extractor.Po \ + ./$(DEPDIR)/Launch.Po ./$(DEPDIR)/Listener.Po \ + ./$(DEPDIR)/Locale.Po ./$(DEPDIR)/PerfSocket.Po \ + ./$(DEPDIR)/ReportOutputs.Po ./$(DEPDIR)/Reporter.Po \ + ./$(DEPDIR)/Reports.Po ./$(DEPDIR)/Server.Po \ + ./$(DEPDIR)/Settings.Po ./$(DEPDIR)/SocketAddr.Po \ + ./$(DEPDIR)/active_hosts.Po ./$(DEPDIR)/checkdelay.Po \ + ./$(DEPDIR)/checkisoch.Po ./$(DEPDIR)/checkpdfs.Po \ + ./$(DEPDIR)/checksums.Po ./$(DEPDIR)/dscp.Po \ + ./$(DEPDIR)/gnu_getopt.Po ./$(DEPDIR)/gnu_getopt_long.Po \ + ./$(DEPDIR)/histogram.Po ./$(DEPDIR)/igmp_querier.Po \ + ./$(DEPDIR)/iperf_formattime.Po ./$(DEPDIR)/isochronous.Po \ + ./$(DEPDIR)/main.Po ./$(DEPDIR)/packet_ring.Po \ + ./$(DEPDIR)/pdfs.Po ./$(DEPDIR)/service.Po \ + ./$(DEPDIR)/socket_io.Po ./$(DEPDIR)/stdio.Po \ + ./$(DEPDIR)/tcp_window_size.Po +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_@AM_V@) +am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) +am__v_CC_0 = @echo " CC " $@; +am__v_CC_1 = +CCLD = $(CC) +LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_@AM_V@) +am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) +am__v_CCLD_0 = @echo " CCLD " $@; +am__v_CCLD_1 = +CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \ + $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) +AM_V_CXX = $(am__v_CXX_@AM_V@) +am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@) +am__v_CXX_0 = @echo " CXX " $@; +am__v_CXX_1 = +CXXLD = $(CXX) +CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \ + -o $@ +AM_V_CXXLD = $(am__v_CXXLD_@AM_V@) +am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@) +am__v_CXXLD_0 = @echo " CXXLD " $@; +am__v_CXXLD_1 = +SOURCES = $(checkdelay_SOURCES) $(checkisoch_SOURCES) \ + $(checkpdfs_SOURCES) $(igmp_querier_SOURCES) $(iperf_SOURCES) +DIST_SOURCES = $(am__checkdelay_SOURCES_DIST) \ + $(am__checkisoch_SOURCES_DIST) $(am__checkpdfs_SOURCES_DIST) \ + $(am__igmp_querier_SOURCES_DIST) $(am__iperf_SOURCES_DIST) +am__can_run_installinfo = \ + case $$AM_UPDATE_INFO_DIR in \ + n|no|NO) false;; \ + *) (install-info --version) >/dev/null 2>&1;; \ + esac +am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) +# Read a list of newline-separated strings from the standard input, +# and print each of them once, without duplicates. Input order is +# *not* preserved. +am__uniquify_input = $(AWK) '\ + BEGIN { nonempty = 0; } \ + { items[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in items) print i; }; } \ +' +# Make sure the list of sources is unique. This is necessary because, +# e.g., the same source file might be shared among _SOURCES variables +# for different programs/libraries. +am__define_uniq_tagged_files = \ + list='$(am__tagged_files)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | $(am__uniquify_input)` +ETAGS = etags +CTAGS = ctags +am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CXX = @CXX@ +CXXDEPMODE = @CXXDEPMODE@ +CXXFLAGS = @CXXFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EXEEXT = @EXEEXT@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LTLIBOBJS = @LTLIBOBJS@ +MAINT = @MAINT@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +OBJEXT = @OBJEXT@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PTHREAD_CC = @PTHREAD_CC@ +PTHREAD_CFLAGS = @PTHREAD_CFLAGS@ +PTHREAD_LIBS = @PTHREAD_LIBS@ +RANLIB = @RANLIB@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +STRIP_BEGIN = @STRIP_BEGIN@ +STRIP_DUMMY = @STRIP_DUMMY@ +STRIP_END = @STRIP_END@ +VERSION = @VERSION@ +WEB100_CFLAGS = @WEB100_CFLAGS@ +WEB100_CONFIG = @WEB100_CONFIG@ +WEB100_LIBS = @WEB100_LIBS@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_CXX = @ac_ct_CXX@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +ax_pthread_config = @ax_pthread_config@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +runstatedir = @runstatedir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +LIBCOMPAT_LDADDS = @STRIP_BEGIN@ \ + $(top_builddir)/compat/libcompat.a \ + @STRIP_END@ + +AM_CPPFLAGS = @STRIP_BEGIN@ \ + -I$(top_srcdir)/include \ + -I$(top_builddir)/include \ + @STRIP_END@ + +AM_CXXFLAGS = -Wall $(am__append_2) $(am__append_4) +AM_CFLAGS = -Wall $(am__append_1) $(am__append_3) +iperf_LDFLAGS = @CFLAGS@ @PTHREAD_CFLAGS@ @WEB100_CFLAGS@ @DEFS@ +iperf_SOURCES = Client.cpp Extractor.c isochronous.cpp Launch.cpp \ + active_hosts.cpp Listener.cpp Locale.c PerfSocket.cpp \ + Reporter.c Reports.c ReportOutputs.c Server.cpp Settings.cpp \ + SocketAddr.c gnu_getopt.c gnu_getopt_long.c histogram.c \ + main.cpp service.c socket_io.c stdio.c packet_ring.c \ + tcp_window_size.c pdfs.c dscp.c iperf_formattime.c \ + $(am__append_5) +iperf_LDADD = $(LIBCOMPAT_LDADDS) +@CHECKPROGRAMS_TRUE@checkdelay_SOURCES = checkdelay.c +@CHECKPROGRAMS_TRUE@checkdelay_LDADD = $(LIBCOMPAT_LDADDS) +@CHECKPROGRAMS_TRUE@checkpdfs_SOURCES = pdfs.c checkpdfs.c stdio.c +@CHECKPROGRAMS_TRUE@checkpdfs_LDADD = -lm +@CHECKPROGRAMS_TRUE@checkisoch_SOURCES = checkisoch.cpp isochronous.cpp pdfs.c stdio.c +@CHECKPROGRAMS_TRUE@igmp_querier_SOURCES = igmp_querier.c +@CHECKPROGRAMS_TRUE@checkisoch_LDADD = $(LIBCOMPAT_LDADDS) +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .cpp .o .obj +$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu src/Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-binPROGRAMS: $(bin_PROGRAMS) + @$(NORMAL_INSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + if test -n "$$list"; then \ + echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \ + $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \ + fi; \ + for p in $$list; do echo "$$p $$p"; done | \ + sed 's/$(EXEEXT)$$//' | \ + while read p p1; do if test -f $$p \ + ; then echo "$$p"; echo "$$p"; else :; fi; \ + done | \ + sed -e 'p;s,.*/,,;n;h' \ + -e 's|.*|.|' \ + -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \ + sed 'N;N;N;s,\n, ,g' | \ + $(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \ + { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \ + if ($$2 == $$4) files[d] = files[d] " " $$1; \ + else { print "f", $$3 "/" $$4, $$1; } } \ + END { for (d in files) print "f", d, files[d] }' | \ + while read type dir files; do \ + if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \ + test -z "$$files" || { \ + echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \ + $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \ + } \ + ; done + +uninstall-binPROGRAMS: + @$(NORMAL_UNINSTALL) + @list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \ + files=`for p in $$list; do echo "$$p"; done | \ + sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \ + -e 's/$$/$(EXEEXT)/' \ + `; \ + test -n "$$list" || exit 0; \ + echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \ + cd "$(DESTDIR)$(bindir)" && rm -f $$files + +clean-binPROGRAMS: + -test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS) + +clean-noinstPROGRAMS: + -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS) + +checkdelay$(EXEEXT): $(checkdelay_OBJECTS) $(checkdelay_DEPENDENCIES) $(EXTRA_checkdelay_DEPENDENCIES) + @rm -f checkdelay$(EXEEXT) + $(AM_V_CCLD)$(LINK) $(checkdelay_OBJECTS) $(checkdelay_LDADD) $(LIBS) + +checkisoch$(EXEEXT): $(checkisoch_OBJECTS) $(checkisoch_DEPENDENCIES) $(EXTRA_checkisoch_DEPENDENCIES) + @rm -f checkisoch$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(checkisoch_OBJECTS) $(checkisoch_LDADD) $(LIBS) + +checkpdfs$(EXEEXT): $(checkpdfs_OBJECTS) $(checkpdfs_DEPENDENCIES) $(EXTRA_checkpdfs_DEPENDENCIES) + @rm -f checkpdfs$(EXEEXT) + $(AM_V_CCLD)$(LINK) $(checkpdfs_OBJECTS) $(checkpdfs_LDADD) $(LIBS) + +igmp_querier$(EXEEXT): $(igmp_querier_OBJECTS) $(igmp_querier_DEPENDENCIES) $(EXTRA_igmp_querier_DEPENDENCIES) + @rm -f igmp_querier$(EXEEXT) + $(AM_V_CCLD)$(LINK) $(igmp_querier_OBJECTS) $(igmp_querier_LDADD) $(LIBS) + +iperf$(EXEEXT): $(iperf_OBJECTS) $(iperf_DEPENDENCIES) $(EXTRA_iperf_DEPENDENCIES) + @rm -f iperf$(EXEEXT) + $(AM_V_CXXLD)$(iperf_LINK) $(iperf_OBJECTS) $(iperf_LDADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Client.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Extractor.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Launch.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Listener.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Locale.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/PerfSocket.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ReportOutputs.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Reporter.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Reports.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Server.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/Settings.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/SocketAddr.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/active_hosts.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checkdelay.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checkisoch.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checkpdfs.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/checksums.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dscp.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gnu_getopt.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gnu_getopt_long.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/histogram.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/igmp_querier.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/iperf_formattime.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isochronous.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/main.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/packet_ring.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pdfs.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/service.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/socket_io.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/stdio.Po@am__quote@ # am--include-marker +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tcp_window_size.Po@am__quote@ # am--include-marker + +$(am__depfiles_remade): + @$(MKDIR_P) $(@D) + @echo '# dummy' >$@-t && $(am__mv) $@-t $@ + +am--depfiles: $(am__depfiles_remade) + +.c.o: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< + +.c.obj: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cpp.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $< + +.cpp.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +ID: $(am__tagged_files) + $(am__define_uniq_tagged_files); mkid -fID $$unique +tags: tags-am +TAGS: tags + +tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + set x; \ + here=`pwd`; \ + $(am__define_uniq_tagged_files); \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: ctags-am + +CTAGS: ctags +ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) + $(am__define_uniq_tagged_files); \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" +cscopelist: cscopelist-am + +cscopelist-am: $(am__tagged_files) + list='$(am__tagged_files)'; \ + case "$(srcdir)" in \ + [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ + *) sdir=$(subdir)/$(srcdir) ;; \ + esac; \ + for i in $$list; do \ + if test -f "$$i"; then \ + echo "$(subdir)/$$i"; \ + else \ + echo "$$sdir/$$i"; \ + fi; \ + done >> $(top_builddir)/cscope.files + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(BUILT_SOURCES) + $(MAKE) $(AM_MAKEFLAGS) distdir-am + +distdir-am: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(PROGRAMS) +installdirs: + for dir in "$(DESTDIR)$(bindir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + if test -z '$(STRIP)'; then \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + install; \ + else \ + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ + fi +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-binPROGRAMS clean-generic clean-noinstPROGRAMS \ + mostlyclean-am + +distclean: distclean-am + -rm -f ./$(DEPDIR)/Client.Po + -rm -f ./$(DEPDIR)/Extractor.Po + -rm -f ./$(DEPDIR)/Launch.Po + -rm -f ./$(DEPDIR)/Listener.Po + -rm -f ./$(DEPDIR)/Locale.Po + -rm -f ./$(DEPDIR)/PerfSocket.Po + -rm -f ./$(DEPDIR)/ReportOutputs.Po + -rm -f ./$(DEPDIR)/Reporter.Po + -rm -f ./$(DEPDIR)/Reports.Po + -rm -f ./$(DEPDIR)/Server.Po + -rm -f ./$(DEPDIR)/Settings.Po + -rm -f ./$(DEPDIR)/SocketAddr.Po + -rm -f ./$(DEPDIR)/active_hosts.Po + -rm -f ./$(DEPDIR)/checkdelay.Po + -rm -f ./$(DEPDIR)/checkisoch.Po + -rm -f ./$(DEPDIR)/checkpdfs.Po + -rm -f ./$(DEPDIR)/checksums.Po + -rm -f ./$(DEPDIR)/dscp.Po + -rm -f ./$(DEPDIR)/gnu_getopt.Po + -rm -f ./$(DEPDIR)/gnu_getopt_long.Po + -rm -f ./$(DEPDIR)/histogram.Po + -rm -f ./$(DEPDIR)/igmp_querier.Po + -rm -f ./$(DEPDIR)/iperf_formattime.Po + -rm -f ./$(DEPDIR)/isochronous.Po + -rm -f ./$(DEPDIR)/main.Po + -rm -f ./$(DEPDIR)/packet_ring.Po + -rm -f ./$(DEPDIR)/pdfs.Po + -rm -f ./$(DEPDIR)/service.Po + -rm -f ./$(DEPDIR)/socket_io.Po + -rm -f ./$(DEPDIR)/stdio.Po + -rm -f ./$(DEPDIR)/tcp_window_size.Po + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-binPROGRAMS + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f ./$(DEPDIR)/Client.Po + -rm -f ./$(DEPDIR)/Extractor.Po + -rm -f ./$(DEPDIR)/Launch.Po + -rm -f ./$(DEPDIR)/Listener.Po + -rm -f ./$(DEPDIR)/Locale.Po + -rm -f ./$(DEPDIR)/PerfSocket.Po + -rm -f ./$(DEPDIR)/ReportOutputs.Po + -rm -f ./$(DEPDIR)/Reporter.Po + -rm -f ./$(DEPDIR)/Reports.Po + -rm -f ./$(DEPDIR)/Server.Po + -rm -f ./$(DEPDIR)/Settings.Po + -rm -f ./$(DEPDIR)/SocketAddr.Po + -rm -f ./$(DEPDIR)/active_hosts.Po + -rm -f ./$(DEPDIR)/checkdelay.Po + -rm -f ./$(DEPDIR)/checkisoch.Po + -rm -f ./$(DEPDIR)/checkpdfs.Po + -rm -f ./$(DEPDIR)/checksums.Po + -rm -f ./$(DEPDIR)/dscp.Po + -rm -f ./$(DEPDIR)/gnu_getopt.Po + -rm -f ./$(DEPDIR)/gnu_getopt_long.Po + -rm -f ./$(DEPDIR)/histogram.Po + -rm -f ./$(DEPDIR)/igmp_querier.Po + -rm -f ./$(DEPDIR)/iperf_formattime.Po + -rm -f ./$(DEPDIR)/isochronous.Po + -rm -f ./$(DEPDIR)/main.Po + -rm -f ./$(DEPDIR)/packet_ring.Po + -rm -f ./$(DEPDIR)/pdfs.Po + -rm -f ./$(DEPDIR)/service.Po + -rm -f ./$(DEPDIR)/socket_io.Po + -rm -f ./$(DEPDIR)/stdio.Po + -rm -f ./$(DEPDIR)/tcp_window_size.Po + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-binPROGRAMS + +.MAKE: install-am install-strip + +.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \ + clean-binPROGRAMS clean-generic clean-noinstPROGRAMS \ + cscopelist-am ctags ctags-am distclean distclean-compile \ + distclean-generic distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-binPROGRAMS \ + install-data install-data-am install-dvi install-dvi-am \ + install-exec install-exec-am install-html install-html-am \ + install-info install-info-am install-man install-pdf \ + install-pdf-am install-ps install-ps-am install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-compile \ + mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \ + uninstall-am uninstall-binPROGRAMS + +.PRECIOUS: Makefile + + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/src/PerfSocket.cpp b/src/PerfSocket.cpp new file mode 100644 index 0000000..bad4074 --- /dev/null +++ b/src/PerfSocket.cpp @@ -0,0 +1,445 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * PerfSocket.cpp + * by Mark Gates <mgates@nlanr.net> + * Ajay Tirumala <tirumala@ncsa.uiuc.edu> + * ------------------------------------------------------------------- + * Has routines the Client and Server classes use in common for + * performance testing the network. + * Changes in version 1.2.0 + * for extracting data from files + * ------------------------------------------------------------------- + * headers + * uses + * <stdlib.h> + * <stdio.h> + * <string.h> + * + * <sys/types.h> + * <sys/socket.h> + * <unistd.h> + * + * <arpa/inet.h> + * <netdb.h> + * <netinet/in.h> + * <sys/socket.h> + * ------------------------------------------------------------------- */ +#define HEADERS() + +#include "headers.h" +#include "PerfSocket.hpp" +#include "SocketAddr.h" +#include "util.h" + +/* ------------------------------------------------------------------- + * Set socket options before the listen() or connect() calls. + * These are optional performance tuning factors. + * ------------------------------------------------------------------- */ +void SetSocketOptions (struct thread_Settings *inSettings) { + // set the TCP window size (socket buffer sizes) + // also the UDP buffer size + // must occur before call to accept() for large window sizes + setsock_tcp_windowsize(inSettings->mSock, inSettings->mTCPWin, + (inSettings->mThreadMode == kMode_Client ? 1 : 0)); + + if (isCongestionControl(inSettings)) { +#ifdef TCP_CONGESTION + Socklen_t len = strlen(inSettings->mCongestion) + 1; + int rc = setsockopt(inSettings->mSock, IPPROTO_TCP, TCP_CONGESTION, + inSettings->mCongestion, len); + if (rc == SOCKET_ERROR) { + fprintf(stderr, "Attempt to set '%s' congestion control failed: %s\n", + inSettings->mCongestion, strerror(errno)); + unsetCongestionControl(inSettings); + } +#else + fprintf(stderr, "The -Z option is not available on this operating system\n"); +#endif + } + + +#if ((HAVE_TUNTAP_TAP) && (HAVE_TUNTAP_TUN)) + if (isTunDev(inSettings) || isTapDev(inSettings)) { + char **device = (inSettings->mThreadMode == kMode_Client) ? &inSettings->mIfrnametx : &inSettings->mIfrname; + struct ifreq ifr; + struct sockaddr_ll saddr; + memset(&ifr, 0, sizeof(ifr)); + if (*device) { + snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", *device); +// ifr.ifr_flags = IFF_MULTI_QUEUE; + } + inSettings->tuntapdev = open("/dev/net/tun", O_RDWR); + FAIL_errno((inSettings->tuntapdev == -1), "open tun dev", inSettings); + ifr.ifr_flags |= isTapDev(inSettings) ? IFF_TAP : IFF_TUN; + ifr.ifr_flags |= IFF_NO_PI; + int rc = ioctl(inSettings->tuntapdev, TUNSETIFF, (void*) &ifr); + FAIL_errno((rc == -1), "tunsetiff", inSettings); + if (!(*device)) { + int len = snprintf(NULL, 0, "tap%d", inSettings->tuntapdev); + len++; // Trailing null byte + extra + (*device) = static_cast<char *>(calloc(0,len)); + len = snprintf(*device, len, "tap%d", inSettings->tuntapdev); + } + memset(&saddr, 0, sizeof(saddr)); + saddr.sll_family = AF_PACKET; + saddr.sll_protocol = htons(ETH_P_ALL); + saddr.sll_ifindex = if_nametoindex(*device); + if (!saddr.sll_ifindex) { + fprintf(stderr, "tuntap device of %s used for index lookup\n", (*device)); + FAIL_errno(!saddr.sll_ifindex, "tuntap nametoindex", inSettings); + } + saddr.sll_pkttype = PACKET_HOST; + rc = bind(inSettings->mSock, reinterpret_cast<sockaddr*>(&saddr), sizeof(saddr)); + FAIL_errno((rc == SOCKET_ERROR), "tap bind", inSettings); +#ifdef HAVE_THREAD_DEBUG + thread_debug("tuntap device of %s configured", inSettings->mIfrname); +#endif + } else +#endif +#if (HAVE_DECL_SO_BINDTODEVICE) + { + char **device = (inSettings->mThreadMode == kMode_Client) ? &inSettings->mIfrnametx : &inSettings->mIfrname; + if (*device) { + struct ifreq ifr; + memset(&ifr, 0, sizeof(ifr)); + snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", *device); + if (setsockopt(inSettings->mSock, SOL_SOCKET, SO_BINDTODEVICE, (void *)&ifr, sizeof(ifr)) < 0) { + char *buf; + int len = snprintf(NULL, 0, "%s %s", "bind to device", *device); + len++; // Trailing null byte + extra + buf = static_cast<char *>(malloc(len)); + len = snprintf(buf, len, "%s %s", "bind to device", *device); + WARN_errno(1, buf); + free(buf); + free(*device); + *device = NULL; + FAIL(1, "setsockopt() SO_BINDTODEVICE", inSettings); + } + } + } +#endif + + // check if we're sending multicast + if (isMulticast(inSettings)) { +#ifdef HAVE_MULTICAST + if (!isUDP(inSettings)) { + FAIL(1, "Multicast requires -u option ", inSettings); + exit(1); + } + // check for default TTL, multicast is 1 and unicast is the system default + if (inSettings->mTTL == -1) { + inSettings->mTTL = 1; + } + if (inSettings->mTTL > 0) { + // set TTL + if (!isIPV6(inSettings)) { + unsigned char cval = inSettings->mTTL; + int rc = setsockopt(inSettings->mSock, IPPROTO_IP, IP_MULTICAST_TTL, \ + reinterpret_cast<const char *>(&cval), sizeof(cval)); + WARN_errno(rc == SOCKET_ERROR, "multicast v4 ttl"); + } else +# ifdef HAVE_IPV6_MULTICAST + { + int val = inSettings->mTTL; + int rc = setsockopt(inSettings->mSock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, \ + reinterpret_cast<char *>(&val), static_cast<Socklen_t>(sizeof(val))); + WARN_errno(rc == SOCKET_ERROR, "multicast v6 ttl"); + } +# else + FAIL_errno(1, "v6 multicast not supported", inSettings); +# endif + } +#endif + } else if (inSettings->mTTL > 0) { + int val = inSettings->mTTL; + int rc = setsockopt(inSettings->mSock, IPPROTO_IP, IP_TTL, \ + reinterpret_cast<char *>(&val), static_cast<Socklen_t>(sizeof(val))); + WARN_errno(rc == SOCKET_ERROR, "v4 ttl"); + } + +#if HAVE_DECL_IP_TOS + SetSocketOptionsIPTos(inSettings, inSettings->mTOS); +#endif + + if (!isUDP(inSettings)) { + if (isTCPMSS(inSettings)) { + // set the TCP maximum segment size + setsock_tcp_mss(inSettings->mSock, inSettings->mMSS); + } +#if HAVE_DECL_TCP_NODELAY + { + int nodelay = 1; + Socklen_t len = sizeof(nodelay); + int rc = 0; + // set TCP nodelay option + if (isNoDelay(inSettings)) { + rc = setsockopt(inSettings->mSock, IPPROTO_TCP, TCP_NODELAY, + reinterpret_cast<char*>(&nodelay), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_NODELAY"); + } + // Read the socket setting, could be set on by kernel + if (isEnhanced(inSettings) && (rc == 0)) { + rc = getsockopt(inSettings->mSock, IPPROTO_TCP, TCP_NODELAY, + reinterpret_cast<char*>(&nodelay), &len); + WARN_errno(rc == SOCKET_ERROR, "getsockopt TCP_NODELAY"); + if (rc == 0) { + if (nodelay) + setNoDelay(inSettings); + else + unsetNoDelay(inSettings); + } + } + } +#endif +#if HAVE_DECL_TCP_WINDOW_CLAMP + // set TCP clamp option + if (isRxClamp(inSettings)) { + int clamp = inSettings->mClampSize; + Socklen_t len = sizeof(clamp); + int rc = setsockopt(inSettings->mSock, IPPROTO_TCP, TCP_WINDOW_CLAMP, + reinterpret_cast<char*>(&clamp), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_WINDOW_CLAMP"); + } +#endif +#if HAVE_DECL_TCP_NOTSENT_LOWAT + // set TCP not sent low watermark + if (isWritePrefetch(inSettings)) { + int bytecnt = inSettings->mWritePrefetch; + Socklen_t len = sizeof(bytecnt); + int rc = setsockopt(inSettings->mSock, IPPROTO_TCP, TCP_NOTSENT_LOWAT, + reinterpret_cast<char*>(&bytecnt), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_NOTSENT_LOWAT"); + } +#endif + } + +#if HAVE_DECL_SO_MAX_PACING_RATE + /* If socket pacing is specified try to enable it. */ + if (isFQPacing(inSettings) && inSettings->mFQPacingRate > 0) { + int rc = setsockopt(inSettings->mSock, SOL_SOCKET, SO_MAX_PACING_RATE, &inSettings->mFQPacingRate, sizeof(inSettings->mFQPacingRate)); + WARN_errno(rc == SOCKET_ERROR, "setsockopt SO_MAX_PACING_RATE"); + } +#endif /* HAVE_SO_MAX_PACING_RATE */ +#if HAVE_DECL_SO_DONTROUTE + /* If socket pacing is specified try to enable it. */ + if (isDontRoute(inSettings)) { + int option = 1; + Socklen_t len = sizeof(option); + int rc = setsockopt(inSettings->mSock, SOL_SOCKET, SO_DONTROUTE, reinterpret_cast<char*>(&option), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt SO_DONTROUTE"); + } +#endif /* HAVE_DECL_SO_DONTROUTE */ +} + +// Note that timer units are microseconds, be careful +void SetSocketOptionsSendTimeout (struct thread_Settings *mSettings, int timer) { + assert (timer > 0); +#ifdef WIN32 + // Windows SO_SNDTIMEO uses ms + DWORD timeout = (double) timer / 1e3; +#else + struct timeval timeout; + timeout.tv_sec = timer / 1000000; + timeout.tv_usec = timer % 1000000; +#endif + if (setsockopt(mSettings->mSock, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<char *>(&timeout), sizeof(timeout)) < 0) { + WARN_errno(mSettings->mSock == SO_SNDTIMEO, "socket"); + } +// fprintf(stderr,"**** tx timeout %d usecs\n", timer); +} + +void SetSocketOptionsReceiveTimeout (struct thread_Settings *mSettings, int timer) { + assert(timer>0); +#ifdef WIN32 + // Windows SO_RCVTIMEO uses ms + DWORD timeout = (double) timer / 1e3; +#else + struct timeval timeout; + timeout.tv_sec = timer / 1000000; + timeout.tv_usec = timer % 1000000; +#endif + if (setsockopt(mSettings->mSock, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<char *>(&timeout), sizeof(timeout)) < 0) { + WARN_errno(mSettings->mSock == SO_RCVTIMEO, "socket"); + } +// fprintf(stderr,"**** rx timeout %d usecs\n", timer); +} + + +void SetSocketOptionsIPTos (struct thread_Settings *mSettings, int tos) { +#if HAVE_DECL_IP_TOS +#ifdef HAVE_THREAD_DEBUG + thread_debug("Set socket IP_TOS to 0x%x", tos); +#endif +#if HAVE_DECL_IPV6_TCLASS && ! defined HAVE_WINSOCK2_H + // IPV6_TCLASS is defined on Windows but not implemented. + if (isIPV6(mSettings)) { + const int dscp = tos; + int rc = setsockopt(mSettings->mSock, IPPROTO_IPV6, IPV6_TCLASS, (char*) &dscp, sizeof(dscp)); + WARN_errno(rc == SOCKET_ERROR, "setsockopt IPV6_TCLASS"); + } else +#endif + // set IP TOS (type-of-service) field + if (isOverrideTOS(mSettings) || (tos > 0)) { + int reqtos = tos; + Socklen_t len = sizeof(reqtos); + int rc = setsockopt(mSettings->mSock, IPPROTO_IP, IP_TOS, + reinterpret_cast<char*>(&reqtos), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt IP_TOS"); + rc = getsockopt(mSettings->mSock, IPPROTO_IP, IP_TOS, + reinterpret_cast<char*>(&reqtos), &len); + WARN_errno(rc == SOCKET_ERROR, "getsockopt IP_TOS"); + WARN((reqtos != tos), "IP_TOS setting failed"); + } +#endif +} + + +/* + * Set a socket to blocking or non-blocking +* + * Returns true on success, or false if there was an error +*/ +bool setsock_blocking (int fd, bool blocking) { + if (fd < 0) return false; +#ifdef WIN32 + unsigned long mode = blocking ? 0 : 1; + return (ioctlsocket(fd, FIONBIO, &mode) == 0) ? true : false; +#else + int flags = fcntl(fd, F_GETFL, 0); + if (flags < 0) return false; + flags = blocking ? (flags&~O_NONBLOCK) : (flags|O_NONBLOCK); + return (fcntl(fd, F_SETFL, flags) == 0) ? true : false; +#endif +} + +/* ------------------------------------------------------------------- + * If inMSS > 0, set the TCP maximum segment size for inSock. + * Otherwise leave it as the system default. + * ------------------------------------------------------------------- */ + +const char warn_mss_fail[] = "\ +WARNING: attempt to set TCP maxmimum segment size to %d failed\n"; + +void setsock_tcp_mss (int inSock, int inMSS) { +#if HAVE_DECL_TCP_MAXSEG + int rc; + int newMSS; + Socklen_t len; + + assert(inSock != INVALID_SOCKET); + + if (inMSS > 0) { + /* set */ + newMSS = inMSS; + len = sizeof(newMSS); + rc = setsockopt(inSock, IPPROTO_TCP, TCP_MAXSEG, (char*) &newMSS, len); + if (rc == SOCKET_ERROR) { + fprintf(stderr, warn_mss_fail, newMSS); + return; + } + } +#endif +} /* end setsock_tcp_mss */ + +/* ------------------------------------------------------------------- + * returns the TCP maximum segment size + * ------------------------------------------------------------------- */ + +int getsock_tcp_mss (int inSock) { + int theMSS = -1; +#if HAVE_DECL_TCP_MAXSEG + int rc; + Socklen_t len; + assert(inSock >= 0); + + /* query for MSS */ + len = sizeof(theMSS); + rc = getsockopt(inSock, IPPROTO_TCP, TCP_MAXSEG, (char*)&theMSS, &len); + WARN_errno(rc == SOCKET_ERROR, "getsockopt TCP_MAXSEG"); +#endif + return theMSS; +} /* end getsock_tcp_mss */ + +#ifdef DEFAULT_PAYLOAD_LEN_PER_MTU_DISCOVERY +#define UDPMAXSIZE ((1024 * 64) - 64) // 16 bit field for UDP +void checksock_max_udp_payload (struct thread_Settings *inSettings) { +#if HAVE_DECL_SIOCGIFMTU + struct ifreq ifr; + if (!isBuflenSet(inSettings) && inSettings->mIfrname) { + strncpy(ifr.ifr_name, inSettings->mIfrname, (size_t) (IFNAMSIZ - 1)); + if (!ioctl(inSettings->mSock, SIOCGIFMTU, &ifr)) { + int max; + if (!isIPV6(inSettings)) { + max = ifr.ifr_mtu - IPV4HDRLEN - UDPHDRLEN; + } else { + max = ifr.ifr_mtu - IPV6HDRLEN - UDPHDRLEN; + } + if ((max > 0) && (max != inSettings->mBufLen)) { + if (max > UDPMAXSIZE) { + max = UDPMAXSIZE; + } + if (max > inSettings->mBufLen) { + char *tmp = new char[max]; + assert(tmp!=NULL); + if (tmp) { + pattern(tmp, max); + memcpy(tmp, inSettings->mBuf, inSettings->mBufLen); + DELETE_ARRAY(inSettings->mBuf); + inSettings->mBuf = tmp; + inSettings->mBufLen = max; + } + } else { + inSettings->mBufLen = max; + } + } + } + } +#endif +} +#endif + +// end SetSocketOptions diff --git a/src/ReportOutputs.c b/src/ReportOutputs.c new file mode 100644 index 0000000..e977433 --- /dev/null +++ b/src/ReportOutputs.c @@ -0,0 +1,2019 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2020 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * reporter output routines + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- + */ +#include <math.h> +#include "headers.h" +#include "Settings.hpp" +#include "Reporter.h" +#include "Locale.h" +#include "SocketAddr.h" +#include "iperf_formattime.h" + +// These static variables are not thread safe but ok to use becase only +// the repoter thread usses them +#define SNBUFFERSIZE 512 +#define SNBUFFEREXTENDSIZE 512 +static char outbuffer[SNBUFFERSIZE]; // Buffer for printing +static char outbufferext[SNBUFFEREXTENDSIZE]; // Buffer for printing + +#define LLAWBUFSIZE 100 +static char netpower_buf[100]; + +static int HEADING_FLAG(report_bw) = 0; +static int HEADING_FLAG(report_client_bb_bw) = 0; +static int HEADING_FLAG(report_bw_jitter_loss) = 0; +static int HEADING_FLAG(report_bw_read_enhanced) = 0; +static int HEADING_FLAG(report_bw_read_enhanced_netpwr) = 0; +static int HEADING_FLAG(report_bw_write_enhanced) = 0; +static int HEADING_FLAG(report_write_enhanced_write) = 0; +static int HEADING_FLAG(report_bw_write_enhanced_netpwr) = 0; +static int HEADING_FLAG(report_bw_pps_enhanced) = 0; +static int HEADING_FLAG(report_bw_pps_enhanced_isoch) = 0; +static int HEADING_FLAG(report_bw_jitter_loss_pps) = 0; +static int HEADING_FLAG(report_bw_jitter_loss_enhanced) = 0; +static int HEADING_FLAG(report_bw_jitter_loss_enhanced_isoch) = 0; +static int HEADING_FLAG(report_write_enhanced_isoch) = 0; +static int HEADING_FLAG(report_frame_jitter_loss_enhanced) = 0; +static int HEADING_FLAG(report_frame_tcp_enhanced) = 0; +static int HEADING_FLAG(report_frame_read_tcp_enhanced_triptime) = 0; +static int HEADING_FLAG(report_udp_fullduplex) = 0; +static int HEADING_FLAG(report_sumcnt_bw) = 0; +static int HEADING_FLAG(report_sumcnt_udp_fullduplex) = 0; +static int HEADING_FLAG(report_sumcnt_bw_read_enhanced) = 0; +static int HEADING_FLAG(report_sumcnt_bw_read_triptime) = 0; +static int HEADING_FLAG(report_sumcnt_bw_write_enhanced) = 0; +static int HEADING_FLAG(report_sumcnt_bw_pps_enhanced) = 0; +static int HEADING_FLAG(report_bw_jitter_loss_enhanced_triptime) = 0; +static int HEADING_FLAG(report_bw_jitter_loss_enhanced_isoch_triptime) = 0; +static int HEADING_FLAG(report_sumcnt_bw_jitter_loss) = 0; +static int HEADING_FLAG(report_burst_read_tcp) = 0; +static int HEADING_FLAG(report_burst_write_tcp) = 0; +static int HEADING_FLAG(report_bw_isoch_enhanced_netpwr) = 0; +static int HEADING_FLAG(report_sumcnt_udp_enhanced) = 0; +static int HEADING_FLAG(report_sumcnt_udp_triptime) = 0; + +void reporter_default_heading_flags (int flag) { + HEADING_FLAG(report_bw) = flag; + HEADING_FLAG(report_client_bb_bw) = flag; + HEADING_FLAG(report_sumcnt_bw) = flag; + HEADING_FLAG(report_sumcnt_udp_fullduplex) = flag; + HEADING_FLAG(report_bw_jitter_loss) = flag; + HEADING_FLAG(report_bw_read_enhanced) = flag; + HEADING_FLAG(report_bw_read_enhanced_netpwr) = flag; + HEADING_FLAG(report_bw_write_enhanced) = flag; + HEADING_FLAG(report_write_enhanced_write) = flag; + HEADING_FLAG(report_write_enhanced_isoch) = flag; + HEADING_FLAG(report_bw_write_enhanced_netpwr) = flag; + HEADING_FLAG(report_bw_pps_enhanced) = flag; + HEADING_FLAG(report_bw_pps_enhanced_isoch) = flag; + HEADING_FLAG(report_bw_jitter_loss_pps) = flag; + HEADING_FLAG(report_bw_jitter_loss_enhanced) = flag; + HEADING_FLAG(report_bw_jitter_loss_enhanced_isoch) = flag; + HEADING_FLAG(report_frame_jitter_loss_enhanced) = flag; + HEADING_FLAG(report_frame_tcp_enhanced) = flag; + HEADING_FLAG(report_frame_read_tcp_enhanced_triptime) = flag; + HEADING_FLAG(report_sumcnt_bw_read_enhanced) = flag; + HEADING_FLAG(report_sumcnt_bw_read_triptime) = flag; + HEADING_FLAG(report_sumcnt_bw_write_enhanced) = flag; + HEADING_FLAG(report_udp_fullduplex) = flag; + HEADING_FLAG(report_sumcnt_bw_jitter_loss) = flag; + HEADING_FLAG(report_sumcnt_bw_pps_enhanced) = flag; + HEADING_FLAG(report_burst_read_tcp) = flag; + HEADING_FLAG(report_burst_write_tcp) = flag; + HEADING_FLAG(report_bw_isoch_enhanced_netpwr) = flag; + HEADING_FLAG(report_sumcnt_udp_enhanced) = flag; + HEADING_FLAG(report_sumcnt_udp_triptime) = flag; +} +static inline void _print_stats_common (struct TransferInfo *stats) { + assert(stats!=NULL); + outbuffer[0] = '\0'; + outbufferext[0] = '\0'; + byte_snprintf(outbuffer, sizeof(outbuffer), (double) stats->cntBytes, toupper((int)stats->common->Format)); + if (stats->ts.iEnd < SMALLEST_INTERVAL_SEC) { + stats->cntBytes = 0; + } + byte_snprintf(outbufferext, sizeof(outbufferext), (double)stats->cntBytes / (stats->ts.iEnd - stats->ts.iStart), \ + stats->common->Format); + outbuffer[sizeof(outbuffer)-1]='\0'; + outbufferext[sizeof(outbufferext)-1]='\0'; +} + +static inline void _output_outoforder(struct TransferInfo *stats) { + if (stats->cntOutofOrder > 0) { + printf(report_outoforder, + stats->common->transferIDStr, stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + if (stats->l2counts.cnt) { + printf(report_l2statistics, + stats->common->transferIDStr, stats->ts.iStart, + stats->ts.iEnd, stats->l2counts.cnt, stats->l2counts.lengtherr, + stats->l2counts.udpcsumerr, stats->l2counts.unknown); + } +} + +// +// Little's law is L = lambda * W, where L is queue depth, +// lambda the arrival rate and W is the processing time +// +#define LLAW_LOWERBOUNDS -1e7 + +static inline void human_format_llawbuf(char *dststr, size_t len, double inP) { + if (inP < LLAW_LOWERBOUNDS) { + char oobstr[] = "OBL"; + if (len > sizeof(oobstr)) + strcpy(dststr, oobstr); + } else { + //force to adpative bytes for human readable + byte_snprintf(dststr, len, inP, 'A'); + dststr[len-1] = '\0'; + } +} + +#if 0 +static inline void set_llawbuf_frames (int lambda, double meantransit, double variance, intmax_t framecnt) { + int Lvar = 0; + int L = round(lambda * meantransit); + if (variance > 0.0) { + Lvar = round(lambda * variance); + } else { + Lvar = 0; + } + snprintf(llaw_buf, sizeof(llaw_buf), "%" PRIdMAX "/%d(%d) frames", framecnt, L, Lvar); + llaw_buf[sizeof(llaw_buf) - 1] = '\0'; +} +#endif + +#define NETPWR_LOWERBOUNDS -1e7 +static inline void set_netpowerbuf(double meantransit, struct TransferInfo *stats) { + if (meantransit == 0.0) { + strcpy(netpower_buf, "NAN"); + } else { + double netpwr = NETPOWERCONSTANT * (((double) stats->cntBytes) / (stats->ts.iEnd - stats->ts.iStart) / meantransit); + if (netpwr < NETPWR_LOWERBOUNDS) { + strcpy(netpower_buf, "OBL"); + } else if (netpwr > 100) { + snprintf(netpower_buf, sizeof(netpower_buf), "%.0f", netpwr); + } else if (netpwr > 10) { + snprintf(netpower_buf, sizeof(netpower_buf), "%.2f", netpwr); + } else { + snprintf(netpower_buf, sizeof(netpower_buf), "%.6f", netpwr); + } + } +} + +//TCP Output +void tcp_output_fullduplex (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_bw_sum_fullduplex_format, stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext); + fflush(stdout); +} + +void tcp_output_fullduplex_sum (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_sum_bw_format, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext); + fflush(stdout); +} + +void tcp_output_fullduplex_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_bw_sum_fullduplex_enhanced_format, stats->common->transferID, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext); + fflush(stdout); +} + +void tcp_output_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_bw_format, stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext); + fflush(stdout); +} +//TCP read or server output +void tcp_output_read_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_read_enhanced); + _print_stats_common(stats); + printf(report_bw_read_enhanced_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + fflush(stdout); +} +void tcp_output_read_triptime (struct TransferInfo *stats) { + double meantransit; + HEADING_PRINT_COND(report_bw_read_enhanced_netpwr); + char llaw_bufstr[LLAWBUFSIZE]; + human_format_llawbuf(llaw_bufstr, sizeof(llaw_bufstr), ((stats->final) ? stats->fInP : stats->iInP)); + _print_stats_common(stats); + if (!stats->final) { + meantransit = (stats->transit.current.cnt > 0) ? (stats->transit.current.sum / stats->transit.current.cnt) : 0; + set_netpowerbuf(meantransit, stats); + printf(report_bw_read_enhanced_netpwr_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (meantransit * 1e3), + (stats->transit.current.cnt < 2) ? 0 : stats->transit.current.min * 1e3, + (stats->transit.current.cnt < 2) ? 0 : stats->transit.current.max * 1e3, + (stats->transit.current.cnt < 2) ? 0 : 1e3 * (sqrt(stats->transit.current.m2 / (stats->transit.current.cnt - 1))), + stats->transit.current.cnt, + stats->transit.current.cnt ? (long) ((double)stats->cntBytes / (double) stats->transit.current.cnt) : 0, + llaw_bufstr, + netpower_buf, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + } else { + meantransit = (stats->transit.total.cnt > 0) ? (stats->transit.total.sum / stats->transit.total.cnt) : 0; + set_netpowerbuf(meantransit, stats); + printf(report_bw_read_enhanced_netpwr_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (meantransit * 1e3), + stats->transit.total.min * 1e3, + stats->transit.total.max * 1e3, + (stats->transit.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->transit.total.m2 / (stats->transit.total.cnt - 1))), + stats->transit.total.cnt, + stats->transit.total.cnt ? (long) ((double)stats->cntBytes / (double) stats->transit.total.cnt) : 0, + llaw_bufstr, + netpower_buf, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + } + if (stats->framelatency_histogram) { + histogram_print(stats->framelatency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + fflush(stdout); +} +void tcp_output_read_enhanced_isoch (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_isoch_enhanced_netpwr); + _print_stats_common(stats); + double meantransit; + if (!stats->final) { + meantransit = (stats->isochstats.transit.current.cnt > 0) ? (stats->isochstats.transit.current.sum / stats->isochstats.transit.current.cnt) : 0; + set_netpowerbuf(meantransit, stats); + printf(report_bw_isoch_enhanced_netpwr_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (meantransit * 1e3), + (stats->isochstats.transit.current.cnt < 2) ? 0 : stats->isochstats.transit.current.min * 1e3, + (stats->isochstats.transit.current.cnt < 2) ? 0 : stats->isochstats.transit.current.max * 1e3, + (stats->isochstats.transit.current.cnt < 2) ? 0 : 1e3 * (sqrt(stats->isochstats.transit.current.m2 / (stats->isochstats.transit.current.cnt - 1))), + stats->isochstats.transit.current.cnt, + stats->isochstats.transit.current.cnt ? (long) ((double)stats->cntBytes / (double) stats->isochstats.transit.current.cnt) : 0, + netpower_buf, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + } else { + meantransit = (stats->isochstats.transit.total.cnt > 0) ? (stats->isochstats.transit.total.sum / stats->isochstats.transit.total.cnt) : 0; + set_netpowerbuf(meantransit, stats); + printf(report_bw_isoch_enhanced_netpwr_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (meantransit * 1e3), + stats->isochstats.transit.total.min * 1e3, + stats->isochstats.transit.total.max * 1e3, + (stats->isochstats.transit.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->isochstats.transit.total.m2 / (stats->isochstats.transit.total.cnt - 1))), + stats->isochstats.transit.total.cnt, + stats->isochstats.transit.total.cnt ? (long) ((double)stats->cntBytes / (double) stats->isochstats.transit.total.cnt) : 0, + netpower_buf, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + } + if (stats->framelatency_histogram) { + histogram_print(stats->framelatency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + fflush(stdout); +} + +void tcp_output_frame_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_frame_tcp_enhanced); + _print_stats_common(stats); + printf(report_bw_read_enhanced_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + fflush(stdout); +} +void tcp_output_frame_read_triptime (struct TransferInfo *stats) { + fprintf(stderr, "FIXME\n"); +} +void tcp_output_burst_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_burst_read_tcp); + _print_stats_common(stats); + if (!stats->final) { + set_netpowerbuf(stats->transit.current.mean, stats); + printf(report_burst_read_tcp_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->transit.current.mean * 1e3, + (1e2 * stats->transit.current.mean * stats->common->FPS), // (1e3 / 100%) + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7], + netpower_buf); + } else { + printf(report_burst_read_tcp_final_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->transit.total.mean * 1e3, + (stats->transit.total.cnt < 2) ? 0 : stats->transit.total.min * 1e3, + (stats->transit.total.cnt < 2) ? 0 : stats->transit.total.max * 1e3, + (stats->transit.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->transit.total.m2 / (stats->transit.total.cnt - 1))), + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + } + fflush(stdout); +} + +//TCP write or client output +void tcp_output_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_bw_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} + +void tcp_output_write_bb (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_client_bb_bw); + _print_stats_common(stats); + char rps_string[80]; + if (stats->final) { + double rps = ((stats->fBBrunning > 0) && (stats->bbrtt.total.cnt > 0)) ? ((double) stats->bbrtt.total.cnt / stats->fBBrunning) : 0; + if (rps < 10) + snprintf(rps_string, sizeof(rps_string), "%0.1f", rps); + else + snprintf(rps_string, sizeof(rps_string), "%0.0f", rps); + rps_string[sizeof(rps_string) - 1] = '\0'; + +#if HAVE_TCP_STATS + printf(report_client_bb_bw_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->bbrtt.total.cnt, + (stats->bbrtt.total.mean * 1e3), + (stats->bbrtt.total.cnt < 2) ? 0 : (stats->bbrtt.total.min * 1e3), + (stats->bbrtt.total.cnt < 2) ? 0 : (stats->bbrtt.total.max * 1e3), + (stats->bbrtt.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbrtt.total.m2 / (stats->bbrtt.total.cnt - 1))), + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + rps_string); +#else + printf(report_client_bb_bw_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->bbrtt.total.cnt, + (stats->bbrtt.total.mean * 1e3), + (stats->bbrtt.total.cnt < 2) ? 0 : (stats->bbrtt.total.min * 1e3), + (stats->bbrtt.total.cnt < 2) ? 0 : (stats->bbrtt.total.max * 1e3), + (stats->bbrtt.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbrtt.total.m2 / (stats->bbrtt.total.cnt - 1))), + rps_string); +#endif + if (isTripTime(stats->common)) { + printf(report_client_bb_bw_triptime_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + stats->bbowdto.total.cnt, + (stats->bbowdto.total.mean * 1e3), + (stats->bbowdto.total.cnt < 2) ? 0 : (stats->bbowdto.total.min * 1e3), + (stats->bbowdto.total.cnt < 2) ? 0 : (stats->bbowdto.total.max * 1e3), + (stats->bbowdto.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbowdto.total.m2 / (stats->bbowdto.total.cnt - 1))), + (stats->bbowdfro.total.mean * 1e3), + (stats->bbowdfro.total.cnt < 2) ? 0 : (stats->bbowdfro.total.min * 1e3), + (stats->bbowdfro.total.cnt < 2) ? 0 : (stats->bbowdfro.total.max * 1e3), + (stats->bbowdfro.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbowdfro.total.m2 / (stats->bbowdfro.total.cnt - 1))), + (stats->bbasym.total.mean * 1e3), + (stats->bbasym.total.cnt < 2) ? 0 : (stats->bbasym.total.min * 1e3), + (stats->bbasym.total.cnt < 2) ? 0 : (stats->bbasym.total.max * 1e3), + (stats->bbasym.total.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbasym.total.m2 / (stats->bbasym.total.cnt - 1))), + rps_string); + } + if (stats->bbrtt_histogram) { + histogram_print(stats->bbrtt_histogram, stats->ts.iStart, stats->ts.iEnd); + } + } else { + double rps = ((stats->bbrtt.current.cnt > 0) && (stats->iBBrunning > 0)) ? ((double) stats->bbrtt.current.cnt / stats->iBBrunning) : 0; + if (rps < 10) + snprintf(rps_string, sizeof(rps_string), "%0.1f", rps); + else + snprintf(rps_string, sizeof(rps_string), "%0.0f", rps); + rps_string[sizeof(rps_string) - 1] = '\0'; + +#if HAVE_TCP_STATS + printf(report_client_bb_bw_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->bbrtt.current.cnt, + (stats->bbrtt.current.mean * 1e3), + (stats->bbrtt.current.cnt < 2) ? 0 : (stats->bbrtt.current.min * 1e3), + (stats->bbrtt.current.cnt < 2) ? 0 : (stats->bbrtt.current.max * 1e3), + (stats->bbrtt.current.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbrtt.current.m2 / (stats->bbrtt.current.cnt - 1))), + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + rps_string); +#else + printf(report_client_bb_bw_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->bbrtt.current.cnt, + (stats->bbrtt.current.mean * 1e3), + (stats->bbrtt.current.cnt < 2) ? 0 : (stats->bbrtt.current.min * 1e3), + (stats->bbrtt.current.cnt < 2) ? 0 : (stats->bbrtt.current.max * 1e3), + (stats->bbrtt.current.cnt < 2) ? 0 : 1e3 * (sqrt(stats->bbrtt.current.m2 / (stats->bbrtt.current.cnt - 1))), + rps_string); +#endif + } + fflush(stdout); +} + +void tcp_output_burst_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_burst_write_tcp); + _print_stats_common(stats); +#if HAVE_TCP_STATS + set_netpowerbuf((stats->transit.current.mean + stats->sock_callstats.write.tcpstats.rtt), stats); + printf(report_burst_write_tcp_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->transit.current.mean, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + netpower_buf); + #else + printf(report_burst_write_tcp_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->transit.current.mean, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr); +#endif + fflush(stdout); +} + +void tcp_output_write_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_write_enhanced); + _print_stats_common(stats); +#if !(HAVE_TCP_STATS) + printf(report_bw_write_enhanced_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr); +#else + set_netpowerbuf(stats->sock_callstats.write.tcpstats.rtt * 1e-6, stats); + if (stats->sock_callstats.write.tcpstats.cwnd > 0) { + printf(report_bw_write_enhanced_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + stats->sock_callstats.write.tcpstats.rttvar, + netpower_buf); + } else { + printf(report_bw_write_enhanced_nocwnd_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.rtt, + netpower_buf); + } +#endif +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (stats->latency_histogram) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } +#endif + fflush(stdout); +} + +void tcp_output_write_enhanced_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_write_enhanced_write); + _print_stats_common(stats); +#if !(HAVE_TCP_STATS) + printf(report_write_enhanced_write_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->write_mmm.current.mean * 1e3, + stats->write_mmm.current.min * 1e3, + stats->write_mmm.current.max * 1e3, + (stats->write_mmm.current.cnt < 2) ? 0 : (1e-3 * sqrt(stats->write_mmm.current.m2 / (stats->write_mmm.current.cnt - 1))), + stats->write_mmm.current.cnt); +#else + set_netpowerbuf(stats->sock_callstats.write.tcpstats.rtt * 1e-6, stats); + if (stats->sock_callstats.write.tcpstats.cwnd > 0) { + printf(report_write_enhanced_write_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + netpower_buf, + stats->write_mmm.current.mean * 1e-3, + stats->write_mmm.current.min * 1e-3, + stats->write_mmm.current.max * 1e-3, + (stats->write_mmm.current.cnt < 2) ? 0 : (1e-3 * sqrt(stats->write_mmm.current.m2 / (stats->write_mmm.current.cnt - 1))), + stats->write_mmm.current.cnt); + } else { + printf(report_write_enhanced_nocwnd_write_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.rtt, + netpower_buf, + stats->write_mmm.current.mean * 1e3, + stats->write_mmm.current.min * 1e3, + stats->write_mmm.current.max * 1e3, + (stats->write_mmm.current.cnt < 2) ? 0 : (1e3 * sqrt(stats->write_mmm.current.m2 / (stats->write_mmm.current.cnt - 1))), + stats->write_mmm.current.cnt); + } +#endif + if (stats->latency_histogram) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if (stats->write_histogram) { + histogram_print(stats->write_histogram, stats->ts.iStart, stats->ts.iEnd); + } + fflush(stdout); +} + +void tcp_output_write_enhanced_isoch (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_write_enhanced_isoch); + _print_stats_common(stats); +#if !(HAVE_TCP_STATS) + printf(report_write_enhanced_isoch_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->isochstats.cntFrames, stats->isochstats.cntFramesMissed, stats->isochstats.cntSlips); +#else + set_netpowerbuf(stats->sock_callstats.write.tcpstats.rtt * 1e-6, stats); + if (stats->sock_callstats.write.tcpstats.cwnd > 0) { + printf(report_write_enhanced_isoch_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + stats->isochstats.cntFrames, stats->isochstats.cntFramesMissed, stats->isochstats.cntSlips, + netpower_buf); + } else { + printf(report_write_enhanced_isoch_nocwnd_format, + stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.rtt, + stats->isochstats.cntFrames, stats->isochstats.cntFramesMissed, stats->isochstats.cntSlips, + netpower_buf); + } +#endif +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (stats->latency_histogram) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } +#endif + fflush(stdout); +} + + +//UDP output +void udp_output_fullduplex (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_udp_fullduplex); + _print_stats_common(stats); + printf(report_udp_fullduplex_format, stats->common->transferIDStr, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext, \ + stats->cntDatagrams, (stats->cntIPG && (stats->IPGsum > 0.0) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + fflush(stdout); +} + +void udp_output_fullduplex_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_udp_fullduplex); + _print_stats_common(stats); + printf(report_udp_fullduplex_enhanced_format, stats->common->transferID, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext, \ + stats->cntDatagrams, (stats->cntIPG && (stats->IPGsum > 0.0) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + fflush(stdout); +} + +void udp_output_fullduplex_sum (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_udp_fullduplex); + _print_stats_common(stats); + printf(report_udp_fullduplex_sum_format, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext, \ + stats->cntDatagrams, (stats->cntIPG && (stats->IPGsum > 0.0) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + fflush(stdout); +} + + +void udp_output_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_jitter_loss); + _print_stats_common(stats); + printf(report_bw_jitter_loss_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), \ + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams); + _output_outoforder(stats); + fflush(stdout); +} + +void udp_output_read_triptime (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_jitter_loss_enhanced_triptime); + _print_stats_common(stats); + if (!stats->cntIPG) { + printf(report_bw_jitter_loss_suppress_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + 0.0, stats->cntError, + stats->cntDatagrams, + 0.0,0.0,0.0,0.0,0.0,0.0); + } else { + if ((stats->transit.current.min > UNREALISTIC_LATENCYMINMAX) || + (stats->transit.current.min < UNREALISTIC_LATENCYMINMIN)) { + printf(report_bw_jitter_loss_suppress_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + (stats->cntIPG / stats->IPGsum)); + } else { + double meantransit; + double variance; + char llaw_bufstr[LLAWBUFSIZE]; + int lambda = ((stats->IPGsum > 0.0) ? (round (stats->cntIPG / stats->IPGsum)) : 0.0); + if (!stats->final) { + meantransit = (stats->transit.current.cnt > 0) ? (stats->transit.current.sum / stats->transit.current.cnt) : 0; + variance = (stats->transit.current.cnt < 2) ? 0 : \ + (sqrt(stats->transit.current.m2 / (stats->transit.current.cnt - 1))); + snprintf(llaw_bufstr, sizeof(llaw_bufstr), "%.0f(%.0f) pkts", stats->iInP, ((double) lambda * variance)); + } else { + meantransit = (stats->transit.total.cnt > 0) ? (stats->transit.total.sum / stats->transit.total.cnt) : 0; + variance = (stats->transit.total.cnt < 2) ? 0 : \ + (sqrt(stats->transit.total.m2 / (stats->transit.total.cnt - 1))); + snprintf(llaw_bufstr, sizeof(llaw_bufstr), "%.0f(%.0f) pkts", stats->fInP, ((double) lambda * variance)); + } + llaw_bufstr[sizeof(llaw_bufstr)-1] = '\0'; + set_netpowerbuf(meantransit, stats); + printf(report_bw_jitter_loss_enhanced_triptime_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), \ + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + (meantransit * 1e3), + ((stats->final ? stats->transit.total.min : stats->transit.current.min) * 1e3), + ((stats->final ? stats->transit.total.max : stats->transit.current.max) * 1e3), + (stats->final ? (stats->transit.total.cnt < 2) : (stats->transit.current.cnt < 2)) ? 0 : (1e3 * variance), // convert from sec to ms + (stats->cntIPG / stats->IPGsum), + stats->cntIPG, + llaw_bufstr, + netpower_buf); + } + } + if (stats->latency_histogram) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if (stats->jitter_histogram) { + histogram_print(stats->jitter_histogram, stats->ts.iStart, stats->ts.iEnd); + } + _output_outoforder(stats); + fflush(stdout); +} +void udp_output_read_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_jitter_loss_enhanced); + _print_stats_common(stats); + if (!stats->cntIPG) { + printf(report_bw_jitter_loss_suppress_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + 0.0, stats->cntError, + stats->cntDatagrams, + 0.0,0.0,0.0,0.0,0.0,0.0); + } else { + if ((stats->transit.current.min > UNREALISTIC_LATENCYMINMAX) || + (stats->transit.current.min < UNREALISTIC_LATENCYMINMIN)) { + printf(report_bw_jitter_loss_suppress_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + (stats->cntIPG / stats->IPGsum)); + } else { + double meantransit; + double variance; + if (!stats->final) { + meantransit = (stats->transit.current.cnt > 0) ? (stats->transit.current.sum / stats->transit.current.cnt) : 0; + variance = (stats->transit.current.cnt < 2) ? 0 : \ + (sqrt(stats->transit.current.m2 / (stats->transit.current.cnt - 1))); + } else { + meantransit = (stats->transit.total.cnt > 0) ? (stats->transit.total.sum / stats->transit.total.cnt) : 0; + variance = (stats->transit.total.cnt < 2) ? 0 : \ + (sqrt(stats->transit.total.m2 / (stats->transit.total.cnt - 1))); + } + set_netpowerbuf(meantransit, stats); + printf(report_bw_jitter_loss_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), \ + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + (meantransit * 1e3), + ((stats->final ? stats->transit.total.min : stats->transit.current.min) * 1e3), + ((stats->final ? stats->transit.total.max : stats->transit.current.max) * 1e3), + (stats->final ? (stats->transit.total.cnt < 2) : (stats->transit.current.cnt < 2)) ? 0 : (1e3 * variance), // convert from sec to ms + (stats->cntIPG / stats->IPGsum), + netpower_buf); + } + } + if (stats->latency_histogram) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if (stats->jitter_histogram) { + histogram_print(stats->jitter_histogram, stats->ts.iStart, stats->ts.iEnd); + } + _output_outoforder(stats); + fflush(stdout); +} +void udp_output_read_triptime_isoch (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_jitter_loss_enhanced_isoch_triptime); + _print_stats_common(stats); + if (!stats->cntIPG) { + printf(report_bw_jitter_loss_suppress_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + 0.0, stats->cntError, + stats->cntDatagrams, + 0.0,0.0,0.0,0.0,0.0,0.0); + + } else { + // If the min latency is out of bounds of a realistic value + // assume the clocks are not synched and suppress the + // latency output + if ((stats->transit.current.min > UNREALISTIC_LATENCYMINMAX) || + (stats->transit.current.min < UNREALISTIC_LATENCYMINMIN)) { + printf(report_bw_jitter_loss_suppress_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + (stats->cntIPG / stats->IPGsum)); + } else { + double frame_meantransit = (stats->isochstats.transit.current.cnt > 0) ? (stats->isochstats.transit.current.sum / stats->isochstats.transit.current.cnt) : 0; + double meantransit = (stats->transit.current.cnt > 0) ? (stats->transit.current.sum / stats->transit.current.cnt) : 0; + set_netpowerbuf(meantransit, stats); + printf(report_bw_jitter_loss_enhanced_isoch_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), \ + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + (meantransit * 1e3), + stats->transit.current.min * 1e3, + stats->transit.current.max * 1e3, + (stats->transit.current.cnt < 2) ? 0 : 1e3 * (sqrt(stats->transit.current.m2 / (stats->transit.current.cnt - 1))), + (stats->cntIPG / stats->IPGsum), + stats->isochstats.cntFrames, stats->isochstats.cntFramesMissed, + (frame_meantransit * 1e3), + stats->isochstats.transit.current.min * 1e3, + stats->isochstats.transit.current.max * 1e3, + (stats->isochstats.transit.current.cnt < 2) ? 0 : 1e3 * (sqrt(stats->isochstats.transit.current.m2 / (stats->isochstats.transit.current.cnt - 1))), + netpower_buf); +#if 0 + if (stats->final) { + printf("***** Jitter MMM = %f/%f/%f\n",stats->inline_jitter.total.mean, stats->inline_jitter.total.min, stats->inline_jitter.total.max); + } +#endif + } + } + if (stats->latency_histogram) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if (stats->jitter_histogram) { + histogram_print(stats->jitter_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if (stats->framelatency_histogram) { + histogram_print(stats->framelatency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + _output_outoforder(stats); + fflush(stdout); +} +void udp_output_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_bw_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} + +void udp_output_write_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_pps_enhanced); + _print_stats_common(stats); + printf(report_bw_pps_enhanced_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + (stats->cntIPG ? (stats->cntIPG / stats->IPGsum) : 0.0)); + fflush(stdout); +} +void udp_output_write_enhanced_isoch (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_pps_enhanced_isoch); + _print_stats_common(stats); + printf(report_bw_pps_enhanced_isoch_format, stats->common->transferIDStr, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + (stats->cntIPG ? (stats->cntIPG / stats->IPGsum) : 0.0), + stats->isochstats.cntFrames, stats->isochstats.cntFramesMissed, stats->isochstats.cntSlips); + fflush(stdout); +} + +// Sum reports +void udp_output_sum_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_sum_bw_jitter_loss_format, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams); + if ((stats->cntOutofOrder > 0) && stats->final) { + printf(report_sum_outoforder, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + fflush(stdout); +} +void udp_output_sumcnt (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw); + _print_stats_common(stats); + printf(report_sumcnt_bw_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + if ((stats->cntOutofOrder > 0) && stats->final) { + if (isSumOnly(stats->common)) { + printf(report_sumcnt_outoforder, + stats->threadcnt, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } else { + printf(report_outoforder, + stats->common->transferIDStr, stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + } + fflush(stdout); +} +void udp_output_sumcnt_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw_jitter_loss); + _print_stats_common(stats); + printf(report_sumcnt_bw_jitter_loss_format, stats->threadcnt, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext, \ + stats->cntError, stats->cntDatagrams, (stats->cntIPG && (stats->IPGsum > 0.0) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + if ((stats->cntOutofOrder > 0) && stats->final) { + if (isSumOnly(stats->common)) { + printf(report_sumcnt_outoforder, + stats->threadcnt, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } else { + printf(report_sum_outoforder, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + } + fflush(stdout); +} + +void udp_output_sumcnt_read_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw_read_enhanced); + _print_stats_common(stats); + printf(report_sumcnt_bw_read_enhanced_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), \ + stats->cntError, stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams); + if ((stats->cntOutofOrder > 0) && stats->final) { + if (isSumOnly(stats->common)) { + printf(report_sumcnt_outoforder, + stats->threadcnt, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } else { + printf(report_sum_outoforder, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + } + fflush(stdout); +} + +void udp_output_sumcnt_read_triptime (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_udp_triptime); + _print_stats_common(stats); + printf(report_sumcnt_udp_triptime_format, stats->threadcnt, stats->ts.iStart, stats->ts.iEnd, outbuffer, outbufferext, \ + stats->cntError, stats->cntDatagrams, stats->cntIPG, (stats->final ? stats->fInP : stats->iInP), (stats->cntIPG && (stats->IPGsum > 0.0) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + if ((stats->cntOutofOrder > 0) && stats->final) { + if (isSumOnly(stats->common)) { + printf(report_sumcnt_outoforder, + stats->threadcnt, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } else { + printf(report_sum_outoforder, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + } + fflush(stdout); +} + +void udp_output_sum_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_sum_bw_format, stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} +void udp_output_sumcnt_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw); + _print_stats_common(stats); + printf(report_sumcnt_bw_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} +void udp_output_sum_read_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_udp_enhanced); + _print_stats_common(stats); + printf(report_sumcnt_udp_enhanced_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->cntError, stats->cntDatagrams, + (stats->cntIPG ? (stats->cntIPG / stats->IPGsum) : 0.0)); + if (stats->latency_histogram && stats->final) { + histogram_print(stats->latency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if (stats->jitter_histogram && stats->final) { + histogram_print(stats->jitter_histogram, stats->ts.iStart, stats->ts.iEnd); + } + if ((stats->cntOutofOrder > 0) && stats->final) { + if (isSumOnly(stats->common)) { + printf(report_sumcnt_outoforder, + stats->threadcnt, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } else { + printf(report_sum_outoforder, + stats->ts.iStart, + stats->ts.iEnd, stats->cntOutofOrder); + } + } + fflush(stdout); +} +void udp_output_sum_write_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_pps_enhanced); + _print_stats_common(stats); + printf(report_sum_bw_pps_enhanced_format, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + ((stats->cntIPG && (stats->IPGsum > 0.0)) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + fflush(stdout); +} +void udp_output_sumcnt_write_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw_pps_enhanced); + _print_stats_common(stats); + printf(report_sumcnt_bw_pps_enhanced_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + ((stats->cntIPG && (stats->IPGsum > 0.0)) ? (stats->cntIPG / stats->IPGsum) : 0.0)); + fflush(stdout); +} + +void tcp_output_sum_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_sum_bw_format, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} +void tcp_output_sum_read_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_read_enhanced); + _print_stats_common(stats); + printf(report_sum_bw_read_enhanced_format, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + if (stats->framelatency_histogram && stats->final) { + histogram_print(stats->framelatency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + fflush(stdout); +} +void tcp_output_sumcnt_read (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw); + _print_stats_common(stats); + printf(report_sumcnt_bw_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} +void tcp_output_sumcnt_read_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw_read_enhanced); + _print_stats_common(stats); + printf(report_sumcnt_bw_read_enhanced_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + fflush(stdout); +} +void tcp_output_sumcnt_read_triptime (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw_read_triptime); + _print_stats_common(stats); + char llaw_bufstr[LLAWBUFSIZE]; + human_format_llawbuf(llaw_bufstr, sizeof(llaw_bufstr), ((stats->final) ? stats->fInP : stats->iInP)); + printf(report_sumcnt_bw_read_triptime_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + llaw_bufstr, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); + fflush(stdout); +} + +void tcp_output_sum_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw); + _print_stats_common(stats); + printf(report_sum_bw_format, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} +void tcp_output_sumcnt_write (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw); + _print_stats_common(stats); + printf(report_sumcnt_bw_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext); + fflush(stdout); +} +void tcp_output_sum_write_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_bw_write_enhanced); + _print_stats_common(stats); + printf(report_sum_bw_write_enhanced_format, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr +#if HAVE_TCP_STATS + ,stats->sock_callstats.write.tcpstats.retry +#endif + ); + fflush(stdout); +} +void tcp_output_sumcnt_write_enhanced (struct TransferInfo *stats) { + HEADING_PRINT_COND(report_sumcnt_bw_write_enhanced); + _print_stats_common(stats); + printf(report_sumcnt_bw_write_enhanced_format, stats->threadcnt, + stats->ts.iStart, stats->ts.iEnd, + outbuffer, outbufferext, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr +#if HAVE_TCP_STATS + ,stats->sock_callstats.write.tcpstats.retry +#endif + ); + fflush(stdout); +} + +// CSV outputs +void format_ips_port_string (struct TransferInfo *stats, bool sum) { + char local_addr[REPORT_ADDRLEN]; + char remote_addr[REPORT_ADDRLEN]; + uint16_t local_port; + uint16_t remote_port; + int swap = (stats->common->ThreadMode == kMode_Server); + int reverse = (isServerReverse(stats->common) || isReverse(stats->common)); + struct sockaddr *local = (swap ? (struct sockaddr*)&stats->common->peer : (struct sockaddr*)&stats->common->local); + struct sockaddr *peer = (swap ? (struct sockaddr*)&stats->common->local : (struct sockaddr*)&stats->common->peer); + + if (local->sa_family == AF_INET) { + if (isHideIPs(stats->common)) { + inet_ntop_hide(AF_INET, &((struct sockaddr_in*)local)->sin_addr, + local_addr, REPORT_ADDRLEN); + } else { + inet_ntop(AF_INET, &((struct sockaddr_in*)local)->sin_addr, + local_addr, REPORT_ADDRLEN); + } + if (!reverse && sum) + local_port = 0; + else + local_port = ntohs(((struct sockaddr_in*)local)->sin_port); + } else { +#if HAVE_IPV6 + if (local->sa_family == AF_INET6) { + inet_ntop(AF_INET6, &((struct sockaddr_in6*)local)->sin6_addr, + local_addr, REPORT_ADDRLEN); + if (swap && sum) + local_port = 0; + else + local_port = ntohs(((struct sockaddr_in6*)local)->sin6_port); + } else +#endif + { + local_addr[0] = '\0'; + local_port = 0; + } + } + + if (peer->sa_family == AF_INET) { + if (isHideIPs(stats->common)) { + inet_ntop_hide(AF_INET, &((struct sockaddr_in*)peer)->sin_addr, + remote_addr, REPORT_ADDRLEN); + } else { + inet_ntop(AF_INET, &((struct sockaddr_in*)peer)->sin_addr, + remote_addr, REPORT_ADDRLEN); + } + if (reverse && sum) + remote_port = 0; + else + remote_port = ntohs(((struct sockaddr_in*)peer)->sin_port); + } else { +#if HAVE_IPV6 + if (local->sa_family == AF_INET6) { + inet_ntop(AF_INET6, &((struct sockaddr_in6*)peer)->sin6_addr, + remote_addr, REPORT_ADDRLEN); + if (!swap && sum) + remote_port = 0; + else + remote_port = ntohs(((struct sockaddr_in6*)peer)->sin6_port); + } else +#endif + { + remote_addr[0] = '\0'; + remote_port = 0; + } + } + + snprintf((char *)&stats->csv_peer, CSVPEERLIMIT, reportCSV_peer, + local_addr, local_port, + remote_addr, remote_port); + stats->csv_peer[(CSVPEERLIMIT-1)] = '\0'; +#if 0 // use to debug CSV ouput + printf("*** output = %s swap=%d reverse=%d sum=%d\n", stats->csv_peer, swap, reverse, sum); +#endif +} + +void udp_output_basic_csv (struct TransferInfo *stats) { + char timestr[120]; + iperf_formattime(timestr, sizeof(timestr), (!stats->final ? stats->ts.nextTime : stats->ts.packetTime), \ + isEnhanced(stats->common), isUTC(stats->common), (isEnhanced(stats->common) ? CSVTZ : CSV)); + intmax_t speed = (intmax_t) (((stats->cntBytes > 0) && (stats->ts.iEnd - stats->ts.iStart) > 0.0) ? \ + (((double)stats->cntBytes * 8.0) / (stats->ts.iEnd - stats->ts.iStart)) : 0); + printf(reportCSV_bw_jitter_loss_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + (stats->final) ? ((stats->inline_jitter.total.sum / (double) stats->inline_jitter.total.cnt) * 1e3) : (stats->jitter * 1e3), + stats->cntError, + stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, stats->cntOutofOrder ); +} + +void udp_output_enhanced_csv (struct TransferInfo *stats) { + char timestr[80]; + iperf_formattime(timestr, sizeof(timestr), (!stats->final ? stats->ts.nextTime : stats->ts.packetTime), \ + isEnhanced(stats->common), isUTC(stats->common), + isEnhanced(stats->common) ? CSVTZ : CSV); + intmax_t speed = (intmax_t) (((stats->cntBytes > 0) && (stats->ts.iEnd - stats->ts.iStart) > 0.0) ? \ + (((double)stats->cntBytes * 8.0) / (stats->ts.iEnd - stats->ts.iStart)) : 0); + printf(reportCSV_bw_jitter_loss_pps_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + (stats->jitter * 1e3), + stats->cntError, + stats->cntDatagrams, + (100.0 * stats->cntError) / stats->cntDatagrams, + stats->cntOutofOrder, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + (stats->cntIPG ? (stats->cntIPG / stats->IPGsum) : 0.0)); +} + +void tcp_output_basic_csv (struct TransferInfo *stats) { + char timestr[80]; + iperf_formattime(timestr, sizeof(timestr), (!stats->final ? stats->ts.nextTime : stats->ts.packetTime), \ + isEnhanced(stats->common), isUTC(stats->common), (isEnhanced(stats->common) ? CSVTZ : CSV)); + intmax_t speed = (intmax_t) (((stats->cntBytes > 0) && (stats->ts.iEnd - stats->ts.iStart) > 0.0) ? \ + (((double)stats->cntBytes * 8.0) / (stats->ts.iEnd - stats->ts.iStart)) : 0); + printf(reportCSV_bw_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed); +} + +void tcp_output_read_enhanced_csv (struct TransferInfo *stats) { + char timestr[80]; + iperf_formattime(timestr, sizeof(timestr), (!stats->final ? stats->ts.nextTime : stats->ts.packetTime), \ + isEnhanced(stats->common), isUTC(stats->common), + isEnhanced(stats->common) ? CSVTZ : CSV); + intmax_t speed = (intmax_t) (((stats->cntBytes > 0) && (stats->ts.iEnd - stats->ts.iStart) > 0.0) ? \ + (((double)stats->cntBytes * 8.0) / (stats->ts.iEnd - stats->ts.iStart)) : 0); + printf(reportCSV_bw_read_enhanced_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + stats->sock_callstats.read.cntRead, + stats->sock_callstats.read.bins[0], + stats->sock_callstats.read.bins[1], + stats->sock_callstats.read.bins[2], + stats->sock_callstats.read.bins[3], + stats->sock_callstats.read.bins[4], + stats->sock_callstats.read.bins[5], + stats->sock_callstats.read.bins[6], + stats->sock_callstats.read.bins[7]); +} + +void tcp_output_write_enhanced_csv (struct TransferInfo *stats) { + char timestr[80]; + iperf_formattime(timestr, sizeof(timestr), (!stats->final ? stats->ts.nextTime : stats->ts.packetTime), \ + isEnhanced(stats->common), isUTC(stats->common), + isEnhanced(stats->common) ? CSVTZ : CSV); + intmax_t speed = (intmax_t) (((stats->cntBytes > 0) && (stats->ts.iEnd - stats->ts.iStart) > 0.0) ? \ + (((double)stats->cntBytes * 8.0) / (stats->ts.iEnd - stats->ts.iStart)) : 0); +#if !(HAVE_TCP_STATS) + printf(reportCSV_bw_write_enhanced_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + -1, + -1, + -1, + -1, + 0, + 0); +#else + if (stats->common->transferID == -1) { + /* Sums */ + printf(reportCSV_bw_write_enhanced_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + -1, + 0, + 0); + } else if (stats->sock_callstats.write.tcpstats.cwnd > 0) { + printf(reportCSV_bw_write_enhanced_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + stats->sock_callstats.write.tcpstats.cwnd, + stats->sock_callstats.write.tcpstats.rtt, + stats->sock_callstats.write.tcpstats.rttvar); + } else { + printf(reportCSV_bw_write_enhanced_format, + timestr, + stats->csv_peer, + stats->common->transferID, + stats->ts.iStart, + stats->ts.iEnd, + stats->cntBytes, + speed, + stats->sock_callstats.write.WriteCnt, + stats->sock_callstats.write.WriteErr, + stats->sock_callstats.write.tcpstats.retry, + -1, + stats->sock_callstats.write.tcpstats.rtt, + 0); + } +#endif +} + +/* + * Report the client or listener Settings in default style + */ +static void output_window_size (struct ReportSettings *report) { + int winsize = getsock_tcp_windowsize(report->common->socket, (report->common->ThreadMode != kMode_Client ? 0 : 1)); + byte_snprintf(outbuffer, sizeof(outbuffer), winsize, \ + ((toupper(report->common->Format) == 'B') ? 'B' : 'A')); + outbuffer[(sizeof(outbuffer)-1)] = '\0'; + printf("%s: %s", (isUDP(report->common) ? udp_buffer_size : tcp_window_size), outbuffer); + if (report->common->winsize_requested == 0) { + printf(" %s", window_default); + } else if (winsize != report->common->winsize_requested) { + byte_snprintf(outbuffer, sizeof(outbuffer), report->common->winsize_requested, + toupper((int)report->common->Format)); + outbuffer[(sizeof(outbuffer)-1)] = '\0'; + printf(warn_window_requested, outbuffer); + } + fflush(stdout); +} +static void reporter_output_listener_settings (struct ReportSettings *report) { + if (report->common->PortLast > report->common->Port) { + printf(server_pid_portrange, (isUDP(report->common) ? "UDP" : "TCP"), \ + report->common->Port, report->common->PortLast, report->pid); + } else { + printf(isEnhanced(report->common) ? server_pid_port : server_port, + (isUDP(report->common) ? "UDP" : "TCP"), report->common->Port, report->pid); + } + if (report->common->Localhost != NULL) { + if (isEnhanced(report->common) && !SockAddr_isMulticast(&report->local)) { + if (report->common->Ifrname) { + printf(bind_address_iface, report->common->Localhost, report->common->Ifrname); + } else { + char *host_ip = (char *) malloc(REPORT_ADDRLEN); + if (host_ip != NULL) { + if (((struct sockaddr*)(&report->common->local))->sa_family == AF_INET) { + if (isHideIPs(report->common)) { + inet_ntop_hide(AF_INET, &((struct sockaddr_in*)(&report->common->local))->sin_addr, + host_ip, REPORT_ADDRLEN); + } else { + inet_ntop(AF_INET, &((struct sockaddr_in*)(&report->common->local))->sin_addr, + host_ip, REPORT_ADDRLEN); + } + } +#if HAVE_IPV6 + else { + inet_ntop(AF_INET6, &((struct sockaddr_in6*)(&report->common->local))->sin6_addr, + host_ip, REPORT_ADDRLEN); + } +#endif + printf(bind_address, host_ip); + free(host_ip); + } + } + } + if (SockAddr_isMulticast(&report->local)) { + if(!report->common->SSMMulticastStr) + if (!report->common->Ifrname) + printf(join_multicast, report->common->Localhost); + else + printf(join_multicast_starg_dev, report->common->Localhost,report->common->Ifrname); + else if(!report->common->Ifrname) + printf(join_multicast_sg, report->common->SSMMulticastStr, report->common->Localhost); + else + printf(join_multicast_sg_dev, report->common->SSMMulticastStr, report->common->Localhost, report->common->Ifrname); + } + } + if (isTunDev(report->common) || isTapDev(report->common)) { + printf(bind_address_iface_taptun, report->common->Ifrname); + } + if (isEnhanced(report->common)) { + byte_snprintf(outbuffer, sizeof(outbuffer), report->common->BufLen, toupper((int)report->common->Format)); + byte_snprintf(outbufferext, sizeof(outbufferext), report->common->BufLen / 8, 'A'); + outbuffer[(sizeof(outbuffer)-1)] = '\0'; + outbufferext[(sizeof(outbufferext)-1)] = '\0'; + printf("%s: %s (Dist bin width=%s)\n", server_read_size, outbuffer, outbufferext); + } + if (isCongestionControl(report->common) && report->common->Congestion) { + fprintf(stdout, "TCP congestion control set to %s\n", report->common->Congestion); + } + if (isOverrideTOS(report->common)) { + fprintf(stdout, "Reflected TOS will be set to 0x%x\n", report->common->RTOS); + } + if (isPrintMSS(report->common)) { + if (isTCPMSS(report->common)) { + printf(report_mss, report->sockmaxseg); + } else { + printf(report_default_mss, report->sockmaxseg); + } + } + if (report->common->TOS) { + fprintf(stdout, "TOS will be set to 0x%x\n", report->common->TOS); + } + if (isUDP(report->common)) { + if (isSingleClient(report->common)) { + fprintf(stdout, "WARN: Suggested to use lower case -u instead of -U (to avoid serialize & bypass of reporter thread)\n"); + } else if (isSingleClient(report->common)) { + fprintf(stdout, "Server set to single client traffic mode per -U (serialize traffic tests)\n"); + } + } else if (isSingleClient(report->common)) { + fprintf(stdout, "Server set to single client traffic mode (serialize traffic tests)\n"); + } + if (isMulticast(report->common)) { + fprintf(stdout, "Server set to single client traffic mode (per multicast receive)\n"); + } + if (isHistogram(report->common)) { + fprintf(stdout, "Enabled receive histograms bin-width=%0.3f ms, bins=%d (clients should use --trip-times)\n", \ + ((1e3 * report->common->HistBinsize) / pow(10,report->common->HistUnits)), report->common->HistBins); + } + if (isJitterHistogram(report->common)) { + fprintf(stdout, "Enabled jitter histograms (bin-width=%d us)\n", report->common->jitter_binwidth); + } + if (isFrameInterval(report->common)) { +#if HAVE_FASTSAMPLING + fprintf(stdout, "Frame or burst interval reporting (feature is experimental)\n"); +#else + fprintf(stdout, "Frame or burst interval reporting (feature is experimental, ./configure --enable-fastsampling suggested)\n"); +#endif + } + output_window_size(report); + printf("\n"); + if (isPermitKey(report->common) && report->common->PermitKey) { + if (report->common->ListenerTimeout > 0) { + fprintf(stdout, "Permit key is '%s' (timeout in %0.1f seconds)\n", report->common->PermitKey, report->common->ListenerTimeout); + } else { + fprintf(stdout, "Permit key is '%s' (WARN: no timeout)\n", report->common->PermitKey); + } + } + fflush(stdout); +} +static void reporter_output_client_settings (struct ReportSettings *report) { + char *hoststr = (isHideIPs(report->common) ? report->common->HideHost \ + : report->common->Host); + if (!report->common->Ifrnametx) { + printf(isEnhanced(report->common) ? client_pid_port : client_port, hoststr, + (isUDP(report->common) ? "UDP" : "TCP"), report->common->Port, report->pid, \ + (!report->common->threads ? 1 : report->common->threads)); + } else { + printf(client_pid_port_dev, hoststr, + (isUDP(report->common) ? "UDP" : "TCP"), report->common->Port, report->pid, \ + report->common->Ifrnametx, (!report->common->threads ? 1 : report->common->threads)); + } + if ((isEnhanced(report->common) || isNearCongest(report->common)) && !isUDP(report->common)) { + byte_snprintf(outbuffer, sizeof(outbuffer), report->common->BufLen, 'B'); + outbuffer[(sizeof(outbuffer)-1)] = '\0'; + if (isTcpWriteTimes(report->common)) { + printf("%s: %s (writetimer-enabled)\n", client_write_size, outbuffer); + } else { + printf("%s: %s\n", client_write_size, outbuffer); + } + } + if (isIsochronous(report->common)) { + char meanbuf[40]; + char variancebuf[40]; + byte_snprintf(meanbuf, sizeof(meanbuf), report->isochstats.mMean, 'a'); + byte_snprintf(variancebuf, sizeof(variancebuf), report->isochstats.mVariance, 'a'); + meanbuf[39]='\0'; variancebuf[39]='\0'; + printf(client_isochronous, report->isochstats.mFPS, meanbuf, variancebuf, (report->isochstats.mBurstInterval/1000.0), (report->isochstats.mBurstIPG/1000.0)); + } + if (isPeriodicBurst(report->common)) { + char tmpbuf[40]; + byte_snprintf(tmpbuf, sizeof(tmpbuf), report->common->BurstSize, 'A'); + tmpbuf[39]='\0'; + if (report->common->bbcount) { + printf(client_burstperiodcount, tmpbuf, report->common->bbcount, (1.0 / report->common->FPS)); + } else { + printf(client_burstperiod, tmpbuf, (1.0 / report->common->FPS)); + } + } + if (isBounceBack(report->common)) { + char tmpbuf[40]; + byte_snprintf(tmpbuf, sizeof(tmpbuf), report->common->bbsize, 'A'); + tmpbuf[39]='\0'; + if (isTcpQuickAck(report->common)) { + printf(client_bounceback, tmpbuf, report->common->bbhold); + } else { + printf(client_bounceback_noqack, tmpbuf, report->common->bbhold); + } + } + if (isFQPacing(report->common)) { + byte_snprintf(outbuffer, sizeof(outbuffer), report->common->FQPacingRate, 'a'); + outbuffer[(sizeof(outbuffer)-1)] = '\0'; + printf(client_fq_pacing,outbuffer); + } + if (isPrintMSS(report->common)) { + if (isTCPMSS(report->common)) { + printf(report_mss, report->sockmaxseg); + } else { + printf(report_default_mss, report->sockmaxseg); + } + } + + if (isCongestionControl(report->common) && report->common->Congestion) { + fprintf(stdout, "TCP congestion control set to %s\n", report->common->Congestion); + } + if (isEnhanced(report->common)) { + if (isNoDelay(report->common)) { + fprintf(stdout, "TOS set to 0x%x and nodelay (Nagle off)\n", report->common->TOS); + } else { + fprintf(stdout, "TOS set to 0x%x (Nagle on)\n", report->common->TOS); + } + } + if (isNearCongest(report->common)) { + if (report->common->rtt_weight == NEARCONGEST_DEFAULT) { + fprintf(stdout, "TCP near-congestion delay weight set to %2.4f (use --near-congestion=<value> to change)\n", report->common->rtt_weight); + } else { + fprintf(stdout, "TCP near-congestion delay weight set to %2.4f\n", report->common->rtt_weight); + } + } + if (isSingleClient(report->common)) { + fprintf(stdout, "WARN: Client set to bypass reporter thread per -U (suggest use lower case -u instead)\n"); + } + if ((isIPG(report->common) || isUDP(report->common)) && !isIsochronous(report->common)) { + byte_snprintf(outbuffer, sizeof(outbuffer), report->common->pktIPG, 'a'); + outbuffer[(sizeof(outbuffer)-1)] = '\0'; +#ifdef HAVE_KALMAN + printf(client_datagram_size_kalman, report->common->BufLen, report->common->pktIPG); +#else + printf(client_datagram_size, report->common->BufLen, report->common->pktIPG); +#endif + } + if (isConnectOnly(report->common)) { + fprintf(stdout, "TCP three-way-handshake (3WHS) only\n"); + } else { + output_window_size(report); + printf("\n"); +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (isWritePrefetch(report->common)) { + fprintf(stdout, "Event based writes (pending queue watermark at %d bytes)\n", report->common->WritePrefetch); + } +#endif + if (isHistogram(report->common)) { + if (!isBounceBack(report->common)) { + fprintf(stdout, "Enabled write histograms bin-width=%0.3f ms, bins=%d\n", \ + ((1e3 * report->common->HistBinsize) / pow(10,report->common->HistUnits)), report->common->HistBins); + } else { + fprintf(stdout, "Set bounceback histograms to bin-width=%0.3f ms, bins=%d\n", \ + ((1e3 * report->common->HistBinsize) / pow(10,report->common->HistUnits)), report->common->HistBins); + } + } + } + fflush(stdout); +} + +void reporter_connect_printf_tcp_final (struct ConnectionInfo * report) { + if (report->connect_times.cnt > 1) { + double variance = (report->connect_times.cnt < 2) ? 0 : 1e3* (sqrt(report->connect_times.m2 / (report->connect_times.cnt - 1))); + fprintf(stdout, "[ CT] final connect times (min/avg/max/stdev) = %0.3f/%0.3f/%0.3f/%0.3f ms (tot/err) = %" PRIdMAX "/%" PRIdMAX "\n", \ + report->connect_times.min, \ + (report->connect_times.sum / report->connect_times.cnt), \ + report->connect_times.max, variance, \ + (report->connect_times.cnt + report->connect_times.err), \ + report->connect_times.err); + } + fflush(stdout); +} + +void reporter_print_connection_report (struct ConnectionInfo *report) { + assert(report->common); + // copy the inet_ntop into temp buffers, to avoid overwriting + char local_addr[REPORT_ADDRLEN]; + char remote_addr[REPORT_ADDRLEN]; + struct sockaddr *local = ((struct sockaddr*)&report->common->local); + struct sockaddr *peer = ((struct sockaddr*)&report->common->peer); + outbuffer[0]='\0'; + outbufferext[0]='\0'; + char *b = &outbuffer[0]; + +#if HAVE_DECL_TCP_WINDOW_CLAMP + if (!isUDP(report->common) && isRxClamp(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (%s%d)", "clamp=", report->common->ClampSize); + b += strlen(b); + } +#endif +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (!isUDP(report->common) && (report->common->socket > 0) && isWritePrefetch(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (%s%d)", "prefetch=", report->common->WritePrefetch); + b += strlen(b); + } +#endif + if (isIsochronous(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (isoch)"); + b += strlen(b); + } + if (isPeriodicBurst(report->common) && (report->common->ThreadMode != kMode_Client) && !isServerReverse(report->common)) { +#if HAVE_FASTSAMPLING + snprintf(b, SNBUFFERSIZE-strlen(b), " (burst-period=%0.4fs)", (1.0 / report->common->FPS)); +#else + snprintf(b, SNBUFFERSIZE-strlen(b), " (burst-period=%0.2fs)", (1.0 / report->common->FPS)); +#endif + b += strlen(b); + } + if (isFullDuplex(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (full-duplex)"); + b += strlen(b); + } else if (isServerReverse(report->common) || isReverse(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (reverse)"); + b += strlen(b); + if (isFQPacing(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (fq)"); + b += strlen(b); + } + } + if (isTxStartTime(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (epoch-start)"); + b += strlen(b); + } + if (isBounceBack(report->common)) { + if (isTcpQuickAck(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (bb w/quickack len/hold=%d/%d)", report->common->bbsize, report->common->bbhold); + } else { + snprintf(b, SNBUFFERSIZE-strlen(b), " (bb len/hold=%d/%d)", report->common->bbsize, report->common->bbhold); + } + b += strlen(b); + } + if (isL2LengthCheck(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (l2mode)"); + b += strlen(b); + } + if (isUDP(report->common) && isNoUDPfin(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (no-udp-fin)"); + b += strlen(b); + } + if (isTripTime(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (trip-times)"); + b += strlen(b); + } + if (isEnhanced(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (sock=%d)", report->common->socket);; + b += strlen(b); + } + if (isOverrideTOS(report->common)) { + if (isFullDuplex(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (tos rx/tx=0x%x/0x%x)", report->common->TOS, report->common->RTOS); + } else if (isReverse(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (tos tx=0x%x)", report->common->TOS); + } + b += strlen(b); + } else if (report->common->TOS) { + if (isFullDuplex(report->common) || isBounceBack(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (tos rx/tx=0x%x/0x%x)", report->common->TOS, report->common->TOS); + } else if (isReverse(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (tos tx=0x%x)", report->common->TOS); + } else { + snprintf(b, SNBUFFERSIZE-strlen(b), " (tos rx=0x%x)", report->common->TOS); + } + b += strlen(b); + } + if (isEnhanced(report->common) || isPeerVerDetect(report->common)) { + if (report->peerversion[0] != '\0') { + snprintf(b, SNBUFFERSIZE-strlen(b), "%s", report->peerversion); + b += strlen(b); + } + } +#if HAVE_DECL_TCP_QUICKACK + if (isTcpQuickAck(report->common) && !isBounceBack(report->common)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (qack)"); + b += strlen(b); + } +#endif +#if HAVE_TCP_STATS + if (!isUDP(report->common) && (report->tcpinitstats.isValid)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (icwnd/mss/irtt=%u/%u/%u)", \ + report->tcpinitstats.cwnd, report->tcpinitstats.mss_negotiated, report->tcpinitstats.rtt); + b += strlen(b); + } +#endif + + if ((isFullDuplex(report->common) || !isServerReverse(report->common)) \ + && (isEnhanced(report->common) || isConnectOnly(report->common))) { + if (report->connect_timestamp.tv_sec > 0) { + char timestr[80]; + iperf_formattime(timestr, sizeof(timestr), report->connect_timestamp, \ + isEnhanced(report->common), isUTC(report->common), YearThruSecTZ); + if (!isUDP(report->common) && (report->common->ThreadMode == kMode_Client) && (report->tcpinitstats.connecttime > 0)) { + snprintf(b, SNBUFFERSIZE-strlen(b), " (ct=%4.2f ms) on %s", report->tcpinitstats.connecttime, timestr); + } else { + snprintf(b, SNBUFFERSIZE-strlen(b), " on %s", timestr); + } + b += strlen(b); + } + } + if (local->sa_family == AF_INET) { + if (isHideIPs(report->common)) { + inet_ntop_hide(AF_INET, &((struct sockaddr_in*)local)->sin_addr, local_addr, REPORT_ADDRLEN); + } else { + inet_ntop(AF_INET, &((struct sockaddr_in*)local)->sin_addr, local_addr, REPORT_ADDRLEN); + } + } +#if HAVE_IPV6 + else { + inet_ntop(AF_INET6, &((struct sockaddr_in6*)local)->sin6_addr, local_addr, REPORT_ADDRLEN); + } +#endif + if (peer->sa_family == AF_INET) { + if (isHideIPs(report->common)) { + inet_ntop_hide(AF_INET, &((struct sockaddr_in*)peer)->sin_addr, remote_addr, REPORT_ADDRLEN); + } else { + inet_ntop(AF_INET, &((struct sockaddr_in*)peer)->sin_addr, remote_addr, REPORT_ADDRLEN); + } + } +#if HAVE_IPV6 + else { + inet_ntop(AF_INET6, &((struct sockaddr_in6*)peer)->sin6_addr, remote_addr, REPORT_ADDRLEN); + } +#endif +#if HAVE_IPV6 + if (report->common->KeyCheck) { + if (isEnhanced(report->common) && report->common->Ifrname && (strlen(report->common->Ifrname) < SNBUFFERSIZE-strlen(b))) { + printf(report_peer_dev, report->common->transferIDStr, local_addr, report->common->Ifrname, \ + (local->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)local)->sin_port) : \ + ntohs(((struct sockaddr_in6*)local)->sin6_port)), \ + remote_addr, (peer->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)peer)->sin_port) : \ + ntohs(((struct sockaddr_in6*)peer)->sin6_port)), outbuffer); + } else { + printf(report_peer, report->common->transferIDStr, local_addr, \ + (local->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)local)->sin_port) : \ + ntohs(((struct sockaddr_in6*)local)->sin6_port)), \ + remote_addr, (peer->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)peer)->sin_port) : \ + ntohs(((struct sockaddr_in6*)peer)->sin6_port)), outbuffer); + } + } else { + printf(report_peer_fail, local_addr, \ + (local->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)local)->sin_port) : \ + ntohs(((struct sockaddr_in6*)local)->sin6_port)), \ + remote_addr, (peer->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)peer)->sin_port) : \ + ntohs(((struct sockaddr_in6*)peer)->sin6_port)), outbuffer); + } + +#else + if (report->common->KeyCheck) { + if (isEnhanced(report->common) && report->common->Ifrname && (strlen(report->common->Ifrname) < SNBUFFERSIZE-strlen(b))) { + printf(report_peer_dev, report->common->transferIDStr, local_addr, report->common->Ifrname, \ + local_addr, (local->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)local)->sin_port) : 0), \ + remote_addr, (peer->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)peer)->sin_port) : 0), \ + outbuffer); + } else { + printf(report_peer, report->common->transferIDStr, \ + local_addr, (local->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)local)->sin_port) : 0), \ + remote_addr, (peer->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)peer)->sin_port) : 0), \ + outbuffer); + } + } else { + printf(report_peer_fail, local_addr, (local->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)local)->sin_port) : 0), \ + remote_addr, (peer->sa_family == AF_INET ? ntohs(((struct sockaddr_in*)peer)->sin_port) : 0), \ + outbuffer); + } +#endif + if ((report->common->ThreadMode == kMode_Client) && !isServerReverse(report->common)) { + if (isTxHoldback(report->common) || isTxStartTime(report->common)) { + struct timeval now; +#ifdef HAVE_CLOCK_GETTIME + struct timespec t1; + clock_gettime(CLOCK_REALTIME, &t1); + now.tv_sec = t1.tv_sec; + now.tv_usec = t1.tv_nsec / 1000; +#else + gettimeofday(&now, NULL); +#endif + int seconds_from_now; + if (isTxHoldback(report->common)) { + seconds_from_now = report->txholdbacktime.tv_sec; + if (report->txholdbacktime.tv_usec > 0) + seconds_from_now++; + } else { + seconds_from_now = ceil(TimeDifference(report->epochStartTime, now)); + } + struct timeval start; + start = now; + char start_timebuf[80]; + start.tv_sec = now.tv_sec + seconds_from_now; + char now_timebuf[80]; + iperf_formattime(now_timebuf, sizeof(now_timebuf), now, \ + isEnhanced(report->common), isUTC(report->common), YearThruSecTZ); + iperf_formattime(start_timebuf, sizeof(start_timebuf), start, \ + isEnhanced(report->common), isUTC(report->common), YearThruSec); + if (seconds_from_now > 0) { + printf(client_report_epoch_start_current, report->common->transferID, seconds_from_now, \ + start_timebuf, now_timebuf); + } else if (!isBounceBack(report->common)) { + printf(warn_start_before_now, report->common->transferID, report->epochStartTime.tv_sec, \ + report->epochStartTime.tv_usec, start_timebuf, now_timebuf); + } + } + } + fflush(stdout); +} + +void reporter_print_settings_report (struct ReportSettings *report) { + assert(report != NULL); + report->pid = (int) getpid(); + printf("%s", separator_line); + if (report->common->ThreadMode == kMode_Listener) { + reporter_output_listener_settings(report); + } else { + reporter_output_client_settings(report); + } + printf("%s", separator_line); + fflush(stdout); +} + +void reporter_peerversion (struct ConnectionInfo *report, uint32_t upper, uint32_t lower) { + if (!upper || !lower) { + report->peerversion[0]='\0'; + } else { + int rel, major, minor, alpha; + rel = (upper & 0xFFFF0000) >> 16; + major = (upper & 0x0000FFFF); + minor = (lower & 0xFFFF0000) >> 16; + alpha = (lower & 0x0000000F); + snprintf(report->peerversion, (PEERVERBUFSIZE-10), " (peer %d.%d.%d)", rel, major, minor); + switch(alpha) { + case 0: + sprintf(report->peerversion + strlen(report->peerversion) - 1,"-dev)"); + break; + case 1: + sprintf(report->peerversion + strlen(report->peerversion) - 1,"-rc)"); + break; + case 2: + sprintf(report->peerversion + strlen(report->peerversion) - 1,"-rc2)"); + break; + case 3: + break; + case 4: + sprintf(report->peerversion + strlen(report->peerversion) - 1,"-private)"); + break; + case 5: + sprintf(report->peerversion + strlen(report->peerversion) - 1,"-master)"); + break; + default: + sprintf(report->peerversion + strlen(report->peerversion) - 1, "-unk)"); + } + report->peerversion[PEERVERBUFSIZE-1]='\0'; + } +} + +void reporter_print_server_relay_report (struct ServerRelay *report) { + printf(server_reporting, report->info.common->transferID); + if (isTripTime(report->info.common) || isEnhanced(report->info.common)) { + udp_output_read_triptime(&report->info); + } else { + udp_output_read(&report->info); + } + fflush(stdout); +} diff --git a/src/Reporter.c b/src/Reporter.c new file mode 100644 index 0000000..bbd6fd5 --- /dev/null +++ b/src/Reporter.c @@ -0,0 +1,1937 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Reporter.c + * by Kevin Gibbs <kgibbs@nlanr.net> + * + * Major rewrite by Robert McMahon (Sept 2020, ver 2.0.14) + * ________________________________________________________________ */ + +#include <math.h> +#include "headers.h" +#include "Settings.hpp" +#include "util.h" +#include "Reporter.h" +#include "Thread.h" +#include "Locale.h" +#include "PerfSocket.hpp" +#include "SocketAddr.h" +#include "histogram.h" +#include "delay.h" +#include "packet_ring.h" +#include "payloads.h" +#include "gettcpinfo.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef INITIAL_PACKETID +# define INITIAL_PACKETID 0 +#endif + +struct ReportHeader *ReportRoot = NULL; +struct ReportHeader *ReportPendingHead = NULL; +struct ReportHeader *ReportPendingTail = NULL; + +// Reporter's reset of stats after a print occurs +static void reporter_reset_transfer_stats_client_tcp(struct TransferInfo *stats); +static void reporter_reset_transfer_stats_client_udp(struct TransferInfo *stats); +static void reporter_reset_transfer_stats_server_udp(struct TransferInfo *stats); +static void reporter_reset_transfer_stats_server_tcp(struct TransferInfo *stats); + +// code for welfornd's algorithm to produce running mean/min/max/var +static void reporter_update_mmm (struct MeanMinMaxStats *stats, double value); +static void reporter_reset_mmm (struct MeanMinMaxStats *stats); + + +// one way delay (OWD) calculations +static void reporter_handle_packet_oneway_transit(struct TransferInfo *stats, struct ReportStruct *packet); +static void reporter_handle_isoch_oneway_transit_tcp(struct TransferInfo *stats, struct ReportStruct *packet); +static void reporter_handle_isoch_oneway_transit_udp(struct TransferInfo *stats, struct ReportStruct *packet); +static void reporter_handle_frame_isoch_oneway_transit(struct TransferInfo *stats, struct ReportStruct *packet); +static void reporter_handle_txmsg_oneway_transit(struct TransferInfo *stats, struct ReportStruct *packet); +static void reporter_handle_rxmsg_oneway_transit(struct TransferInfo *stats, struct ReportStruct *packet); + +static inline void reporter_compute_packet_pps (struct TransferInfo *stats, struct ReportStruct *packet); + +#if HAVE_TCP_STATS +static inline void reporter_handle_packet_tcpistats(struct ReporterData *data, struct ReportStruct *packet); +#endif +static struct ConnectionInfo *myConnectionReport; + +void PostReport (struct ReportHeader *reporthdr) { +#ifdef HAVE_THREAD_DEBUG + char rs[REPORTTXTMAX]; + reporttype_text(reporthdr, &rs[0]); + thread_debug("Jobq *POST* report %p (%s)", reporthdr, &rs[0]); +#endif + if (reporthdr) { +#ifdef HAVE_THREAD + /* + * Update the ReportRoot to include this report. + */ + Condition_Lock(ReportCond); + reporthdr->next = NULL; + if (!ReportPendingHead) { + ReportPendingHead = reporthdr; + ReportPendingTail = reporthdr; + } else { + ReportPendingTail->next = reporthdr; + ReportPendingTail = reporthdr; + } + Condition_Unlock(ReportCond); + // wake up the reporter thread + Condition_Signal(&ReportCond); +#else + /* + * Process the report in this thread + */ + reporthdr->next = NULL; + reporter_process_report(reporthdr); +#endif + } +} +/* + * ReportPacket is called by a transfer agent to record + * the arrival or departure of a "packet" (for TCP it + * will actually represent many packets). This needs to + * be as simple and fast as possible as it gets called for + * every "packet". + * + * Returns true when the tcpinfo was sampled, false ohterwise + */ +bool ReportPacket (struct ReporterData* data, struct ReportStruct *packet) { + assert(data != NULL); + + bool rc = false; + #ifdef HAVE_THREAD_DEBUG + if (packet->packetID < 0) { + thread_debug("Reporting last packet for %p qdepth=%d sock=%d", (void *) data, packetring_getcount(data->packetring), data->info.common->socket); + } + #endif +#if HAVE_TCP_STATS + struct TransferInfo *stats = &data->info; + packet->tcpstats.isValid = false; + if (stats->isEnableTcpInfo) { + if (!TimeZero(stats->ts.nextTCPSampleTime) && (TimeDifference(stats->ts.nextTCPSampleTime, packet->packetTime) < 0)) { + gettcpinfo(data->info.common->socket, &packet->tcpstats); + TimeAdd(stats->ts.nextTCPSampleTime, stats->ts.intervalTime); + } else { + gettcpinfo(data->info.common->socket, &packet->tcpstats); + } + } +#endif + + // Note for threaded operation all that needs + // to be done is to enqueue the packet data + // into the ring. + packetring_enqueue(data->packetring, packet); + // The traffic thread calls the reporting process + // directly forr non-threaded operation + // These defeats the puropse of separating + // traffic i/o from user i/o and really + // should be avoided. + #ifdef HAVE_THREAD + // bypass the reporter thread here for single UDP + if (isSingleUDP(data->info.common)) + reporter_process_transfer_report(data); + #else + /* + * Process the report in this thread + */ + reporter_process_transfer_report(data); + #endif + + return rc; +} + +/* + * EndJob is called by a traffic thread to inform the reporter + * thread to print a final report and to remove the data report from its jobq. + * It also handles the freeing reports and other closing actions + */ +int EndJob (struct ReportHeader *reporthdr, struct ReportStruct *finalpacket) { + assert(reporthdr!=NULL); + assert(finalpacket!=NULL); + struct ReporterData *report = (struct ReporterData *) reporthdr->this_report; + struct ReportStruct packet; + + memset(&packet, 0, sizeof(struct ReportStruct)); + int do_close = 1; + /* + * Using PacketID of -1 ends reporting + * It pushes a "special packet" through + * the packet ring which will be detected + * by the reporter thread as and end of traffic + * event + */ +#if HAVE_TCP_STATS + // tcpi stats are sampled on a final packet + struct TransferInfo *stats = &report->info; + if (stats->isEnableTcpInfo) { + gettcpinfo(report->info.common->socket, &finalpacket->tcpstats); + } +#endif + // clear the reporter done predicate + report->packetring->consumerdone = 0; + // the negative packetID is used to inform the report thread this traffic thread is done + packet.packetID = -1; + packet.packetLen = finalpacket->packetLen; + packet.packetTime = finalpacket->packetTime; + if (isSingleUDP(report->info.common)) { + packetring_enqueue(report->packetring, &packet); + reporter_process_transfer_report(report); + } else { + ReportPacket(report, &packet); +#ifdef HAVE_THREAD_DEBUG + thread_debug( "Traffic thread awaiting reporter to be done with %p and cond %p", (void *)report, (void *) report->packetring->awake_producer); +#endif + Condition_Lock((*(report->packetring->awake_producer))); + while (!report->packetring->consumerdone) { + // This wait time is the lag between the reporter thread + // and the traffic thread, a reporter thread with lots of + // reports (e.g. fastsampling) can lag per the i/o + Condition_TimedWait(report->packetring->awake_producer, 1); + // printf("Consumer done may be stuck\n"); + } + Condition_Unlock((*(report->packetring->awake_producer))); + } + if (report->FullDuplexReport && isFullDuplex(report->FullDuplexReport->info.common)) { + if (fullduplex_stop_barrier(&report->FullDuplexReport->fullduplex_barrier)) { + struct Condition *tmp = &report->FullDuplexReport->fullduplex_barrier.await; + Condition_Destroy(tmp); +#if HAVE_THREAD_DEBUG + thread_debug("Socket fullduplex close sock=%d", report->FullDuplexReport->info.common->socket); +#endif + FreeSumReport(report->FullDuplexReport); + } else { + do_close = 0; + } + } + return do_close; +} + +// This is used to determine the packet/cpu load into the reporter thread +// If the overall reporter load is too low, add some yield +// or delay so the traffic threads can fill the packet rings +#define MINPACKETDEPTH 10 +#define MINPERQUEUEDEPTH 20 +#define REPORTERDELAY_DURATION 16000 // units is microseconds +struct ConsumptionDetectorType { + int accounted_packets; + int accounted_packet_threads; + int reporter_thread_suspends ; +}; +struct ConsumptionDetectorType consumption_detector = \ + {.accounted_packets = 0, .accounted_packet_threads = 0, .reporter_thread_suspends = 0}; + +static inline void reset_consumption_detector (void) { + consumption_detector.accounted_packet_threads = thread_numtrafficthreads(); + if ((consumption_detector.accounted_packets = thread_numtrafficthreads() * MINPERQUEUEDEPTH) <= MINPACKETDEPTH) { + consumption_detector.accounted_packets = MINPACKETDEPTH; + } +} +static inline void apply_consumption_detector (void) { + if (--consumption_detector.accounted_packet_threads <= 0) { + // All active threads have been processed for the loop, + // reset the thread counter and check the consumption rate + // If the rate is too low add some delay to the reporter + consumption_detector.accounted_packet_threads = thread_numtrafficthreads(); + // Check to see if we need to suspend the reporter + if (consumption_detector.accounted_packets > 0) { + /* + * Suspend the reporter thread for some (e.g. 4) milliseconds + * + * This allows the thread to receive client or server threads' + * packet events in "aggregates." This can reduce context + * switching allowing for better CPU utilization, + * which is very noticble on CPU constrained systems. + */ + delay_loop(REPORTERDELAY_DURATION); + consumption_detector.reporter_thread_suspends++; + // printf("DEBUG: forced reporter suspend, accounted=%d, queueue depth after = %d\n", accounted_packets, getcount_packetring(reporthdr)); + } else { + // printf("DEBUG: no suspend, accounted=%d, queueue depth after = %d\n", accounted_packets, getcount_packetring(reporthdr)); + } + reset_consumption_detector(); + } +} + +#ifdef HAVE_THREAD_DEBUG +static void reporter_jobq_dump(void) { + thread_debug("reporter thread job queue request lock"); + Condition_Lock(ReportCond); + struct ReportHeader *itr = ReportRoot; + while (itr) { + thread_debug("Job in queue %p",(void *) itr); + itr = itr->next; + } + Condition_Unlock(ReportCond); + thread_debug("reporter thread job queue unlock"); +} +#endif + + +/* Concatenate pending reports and return the head */ +static inline struct ReportHeader *reporter_jobq_set_root (struct thread_Settings *inSettings) { + struct ReportHeader *root = NULL; + Condition_Lock(ReportCond); + // check the jobq for empty + if (ReportRoot == NULL) { + sInterupted = 0; // reset flags in reporter thread emtpy context + // The reporter is starting from an empty state + // so set the load detect to trigger an initial delay + if (!isSingleUDP(inSettings)) { + reset_consumption_detector(); + reporter_default_heading_flags((inSettings->mReportMode == kReport_CSV)); + } + // Only hang the timed wait if more than this thread is active + if (!ReportPendingHead && (thread_numuserthreads() > 1)) { + Condition_TimedWait(&ReportCond, 1); +#ifdef HAVE_THREAD_DEBUG + thread_debug( "Jobq *WAIT* exit %p/%p cond=%p threads u/t=%d/%d", \ + (void *) ReportRoot, (void *) ReportPendingHead, \ + (void *) &ReportCond, thread_numuserthreads(), thread_numtrafficthreads()); +#endif + } + } + // update the jobq per pending reports + if (ReportPendingHead) { + ReportPendingTail->next = ReportRoot; + ReportRoot = ReportPendingHead; +#ifdef HAVE_THREAD_DEBUG + thread_debug( "Jobq *ROOT* %p (last=%p)", \ + (void *) ReportRoot, (void * ) ReportPendingTail->next); +#endif + ReportPendingHead = NULL; + ReportPendingTail = NULL; + } + root = ReportRoot; + Condition_Unlock(ReportCond); + return root; +} +/* + * Welford's online algorithm + * + * # For a new value newValue, compute the new count, new mean, the new M2. + * # mean accumulates the mean of the entire dataset + * # M2 aggregates the squared distance from the mean + * # count aggregates the number of samples seen so far + * def update(existingAggregate, newValue): + * (count, mean, M2) = existingAggregate + * count += 1 + * delta = newValue - mean + * mean += delta / count + * delta2 = newValue - mean + * M2 += delta * delta2 + * return (count, mean, M2) + * + * # Retrieve the mean, variance and sample variance from an aggregate + * def finalize(existingAggregate): + * (count, mean, M2) = existingAggregate + * if count < 2: + * return float("nan") + * else: + * (mean, variance, sampleVariance) = (mean, M2 / count, M2 / (count - 1)) + * return (mean, variance, sampleVariance) + * + */ +static void reporter_update_mmm (struct MeanMinMaxStats *stats, double value) { + assert(stats != NULL); + stats->cnt++; + if (stats->cnt == 1) { + // Very first entry + stats->min = value; + stats->max = value; + stats->sum = value; + stats->vd = value; + stats->mean = value; + stats->m2 = 0; + stats->sum = value; + } else { + stats->sum += value; + stats->vd = value - stats->mean; + stats->mean += (stats->vd / stats->cnt); + stats->m2 += stats->vd * (value - stats->mean); + // mean min max tests + if (value < stats->min) + stats->min = value; + if (value > stats->max) + stats->max = value; + } + // fprintf(stderr,"**** mmm(%d) val/sum=%f/%f mmm=%f/%f/%f/%f\n", stats->cnt, value, stats->sum, stats->mean, stats->min, stats->max, stats->m2); +} +static void reporter_reset_mmm (struct MeanMinMaxStats *stats) { + stats->min = FLT_MAX; + stats->max = FLT_MIN; + stats->sum = 0; + stats->vd = 0; + stats->mean = 0; + stats->m2 = 0; + stats->cnt = 0; +}; + +/* + * This function is the loop that the reporter thread processes + */ +void reporter_spawn (struct thread_Settings *thread) { +#ifdef HAVE_THREAD_DEBUG + thread_debug( "Reporter thread started"); +#endif + if (isEnhanced(thread)) { + myConnectionReport = InitConnectOnlyReport(thread); + } + /* + * reporter main loop needs to wait on all threads being started + */ + Condition_Lock(threads_start.await); + while (!threads_start.ready) { + Condition_TimedWait(&threads_start.await, 1); + } + Condition_Unlock(threads_start.await); +#ifdef HAVE_THREAD_DEBUG + thread_debug( "Reporter await done"); +#endif + + // + // Signal to other (client) threads that the + // reporter is now running. + // + Condition_Lock(reporter_state.await); + reporter_state.ready = 1; + Condition_Unlock(reporter_state.await); + Condition_Broadcast(&reporter_state.await); +#if HAVE_SCHED_SETSCHEDULER + // set reporter thread to realtime if requested + thread_setscheduler(thread); +#endif + /* + * Keep the reporter thread alive under the following conditions + * + * o) There are more reports to output, ReportRoot has a report + * o) The number of threads is greater than one which indicates + * either traffic threads are still running or a Listener thread + * is running. If equal to 1 then only the reporter thread is alive + */ + while ((reporter_jobq_set_root(thread) != NULL) || (thread_numuserthreads() > 1)){ +#ifdef HAVE_THREAD_DEBUG + // thread_debug( "Jobq *HEAD* %p (%d)", (void *) ReportRoot, thread_numuserthreads()); +#endif + if (ReportRoot) { + // https://blog.kloetzl.info/beautiful-code/ + // Linked list removal/processing is derived from: + // + // remove_list_entry(entry) { + // indirect = &head; + // while ((*indirect) != entry) { + // indirect = &(*indirect)->next; + // } + // *indirect = entry->next + // } + struct ReportHeader **work_item = &ReportRoot; + while (*work_item) { +#ifdef HAVE_THREAD_DEBUG + // thread_debug( "Jobq *NEXT* %p", (void *) *work_item); +#endif + // Report process report returns true + // when a report needs to be removed + // from the jobq. Also, work item might + // be removed as part of processing + // Store a cached pointer for the linked list maitenance + struct ReportHeader *tmp = (*work_item)->next; + if (reporter_process_report(*work_item)) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Jobq *REMOVE* %p", (void *) (*work_item)); +#endif + // memory for *work_item is gone by now + *work_item = tmp; + if (!tmp) + break; + } + work_item = &(*work_item)->next; + } + } + } + if (myConnectionReport) { + if (myConnectionReport->connect_times.cnt > 1) { + reporter_connect_printf_tcp_final(myConnectionReport); + } + FreeConnectionReport(myConnectionReport); + } +#ifdef HAVE_THREAD_DEBUG + if (sInterupted) + reporter_jobq_dump(); + thread_debug("Reporter thread finished user/traffic %d/%d", thread_numuserthreads(), thread_numtrafficthreads()); +#endif +} + +// The Transfer or Data report is by far the most complicated report +int reporter_process_transfer_report (struct ReporterData *this_ireport) { + assert(this_ireport != NULL); + struct TransferInfo *sumstats = (this_ireport->GroupSumReport ? &this_ireport->GroupSumReport->info : NULL); + struct TransferInfo *fullduplexstats = (this_ireport->FullDuplexReport ? &this_ireport->FullDuplexReport->info : NULL); + int need_free = 0; + // The consumption detector applies delay to the reporter + // thread when its consumption rate is too low. This allows + // the traffic threads to send aggregates vs thrash + // the packet rings. The dissimilarity between the thread + // speeds is due to the performance differences between i/o + // bound threads vs cpu bound ones, and it's expected + // that reporter thread being CPU limited should be much + // faster than the traffic threads, even in aggregate. + // Note: If this detection is not going off it means + // the system is likely CPU bound and iperf is now likely + // becoming a CPU bound test vs a network i/o bound test + if (!isSingleUDP(this_ireport->info.common)) + apply_consumption_detector(); + // If there are more packets to process then handle them + struct ReportStruct *packet = NULL; + int advance_jobq = 0; + while (!advance_jobq && (packet = packetring_dequeue(this_ireport->packetring))) { + // Increment the total packet count processed by this thread + // this will be used to make decisions on if the reporter + // thread should add some delay to eliminate cpu thread + // thrashing, + consumption_detector.accounted_packets--; + // Check against a final packet event on this packet ring +#if HAVE_TCP_STATS + if (this_ireport->info.isEnableTcpInfo && packet->tcpstats.isValid) { + reporter_handle_packet_tcpistats(this_ireport, packet); + } +#endif + if (!(packet->packetID < 0)) { + // Check to output any interval reports, + // bursts need to report the packet first + if (this_ireport->packet_handler_pre_report) { + (*this_ireport->packet_handler_pre_report)(this_ireport, packet); + } + if (this_ireport->transfer_interval_handler) { + advance_jobq = (*this_ireport->transfer_interval_handler)(this_ireport, packet); + } + if (this_ireport->packet_handler_post_report) { + (*this_ireport->packet_handler_post_report)(this_ireport, packet); + } + // Sum reports update the report header's last + // packet time after the handler. This means + // the report header's packet time will be + // the previous time before the interval + if (sumstats) + sumstats->ts.packetTime = packet->packetTime; + if (fullduplexstats) + fullduplexstats->ts.packetTime = packet->packetTime; + } else { + need_free = 1; + advance_jobq = 1; + // A last packet event was detected + // printf("last packet event detected\n"); fflush(stdout); + this_ireport->reporter_thread_suspends = consumption_detector.reporter_thread_suspends; + if (this_ireport->packet_handler_pre_report) { + (*this_ireport->packet_handler_pre_report)(this_ireport, packet); + } + if (this_ireport->packet_handler_post_report) { + (*this_ireport->packet_handler_post_report)(this_ireport, packet); + } + this_ireport->info.ts.packetTime = packet->packetTime; + assert(this_ireport->transfer_protocol_handler != NULL); + (*this_ireport->transfer_protocol_handler)(this_ireport, 1); + // This is a final report so set the sum report header's packet time + // Note, the thread with the max value will set this + if (fullduplexstats && isEnhanced(this_ireport->info.common)) { + // The largest packet timestamp sets the sum report final time + if (TimeDifference(fullduplexstats->ts.packetTime, packet->packetTime) > 0) { + fullduplexstats->ts.packetTime = packet->packetTime; + } + if (DecrSumReportRefCounter(this_ireport->FullDuplexReport) == 0) { + if (this_ireport->FullDuplexReport->transfer_protocol_sum_handler) { + (*this_ireport->FullDuplexReport->transfer_protocol_sum_handler)(fullduplexstats, 1); + } + // FullDuplex report gets freed by a traffic thread (per its barrier) + } + } + if (sumstats) { + if (!this_ireport->GroupSumReport->threads_cntr_fsum) + this_ireport->GroupSumReport->threads_cntr_fsum = this_ireport->GroupSumReport->reference.maxcount; + if (TimeDifference(sumstats->ts.packetTime, packet->packetTime) > 0) { + sumstats->ts.packetTime = packet->packetTime; + } + if (this_ireport->GroupSumReport->transfer_protocol_sum_handler && \ + (--this_ireport->GroupSumReport->threads_cntr_fsum == 0) && (this_ireport->GroupSumReport->reference.maxcount > 1)) { + (*this_ireport->GroupSumReport->transfer_protocol_sum_handler)(&this_ireport->GroupSumReport->info, 1); + } + } + } + } + return need_free; +} +/* + * Process reports + * + * Make notice here, the reporter thread is freeing most reports, traffic threads + * can't use them anymore (except for the DATA REPORT); + * + */ +inline int reporter_process_report (struct ReportHeader *reporthdr) { + assert(reporthdr != NULL); + int done = 1; + switch (reporthdr->type) { + case DATA_REPORT: + done = reporter_process_transfer_report((struct ReporterData *)reporthdr->this_report); + fflush(stdout); + if (done) { + struct ReporterData *tmp = (struct ReporterData *)reporthdr->this_report; + struct PacketRing *pr = tmp->packetring; + pr->consumerdone = 1; + // Data Reports are special because the traffic thread needs to free them, just signal + Condition_Signal(pr->awake_producer); + } + break; + case CONNECTION_REPORT: + { + struct ConnectionInfo *creport = (struct ConnectionInfo *)reporthdr->this_report; + assert(creport!=NULL); + if (!isCompat(creport->common) && (creport->common->ThreadMode == kMode_Client) && myConnectionReport) { + // Clients' connect times will be inputs to the overall connect stats + if (creport->tcpinitstats.connecttime > 0.0) { + reporter_update_mmm(&myConnectionReport->connect_times, creport->tcpinitstats.connecttime); + } else { + myConnectionReport->connect_times.err++; + } + } + reporter_print_connection_report(creport); + fflush(stdout); + FreeReport(reporthdr); + } + break; + case SETTINGS_REPORT: + reporter_print_settings_report((struct ReportSettings *)reporthdr->this_report); + fflush(stdout); + FreeReport(reporthdr); + break; + case SERVER_RELAY_REPORT: + reporter_print_server_relay_report((struct ServerRelay *)reporthdr->this_report); + fflush(stdout); + FreeReport(reporthdr); + break; + default: + fprintf(stderr,"Invalid report type in process report %p\n", reporthdr->this_report); + assert(0); + break; + } +#ifdef HAVE_THREAD_DEBUG + // thread_debug("Processed report %p type=%d", (void *)reporthdr, reporthdr->report.type); +#endif + return done; +} + +/* + * Updates connection stats + */ +#define L2DROPFILTERCOUNTER 100 + +// Reporter private routines +void reporter_handle_packet_null (struct ReporterData *data, struct ReportStruct *packet) { +} +void reporter_transfer_protocol_null (struct ReporterData *data, int final){ +} + +static inline void reporter_compute_packet_pps (struct TransferInfo *stats, struct ReportStruct *packet) { + if (!packet->emptyreport) { + stats->total.Datagrams.current++; + stats->total.IPG.current++; + } + stats->ts.IPGstart = packet->packetTime; + stats->IPGsum += TimeDifference(packet->packetTime, packet->prevPacketTime); +#ifdef DEBUG_PPS + printf("*** IPGsum = %f cnt=%ld ipg=%ld.%ld pkt=%ld.%ld id=%ld empty=%d transit=%f prev=%ld.%ld\n", stats->IPGsum, stats->cntIPG, stats->ts.IPGstart.tv_sec, stats->ts.IPGstart.tv_usec, packet->packetTime.tv_sec, packet->packetTime.tv_usec, packet->packetID, packet->emptyreport, TimeDifference(packet->packetTime, packet->prevPacketTime), packet->prevPacketTime.tv_sec, packet->prevPacketTime.tv_usec); +#endif +} + +static void reporter_handle_packet_oneway_transit (struct TransferInfo *stats, struct ReportStruct *packet) { + // Transit or latency updates done inline below + double transit = TimeDifference(packet->packetTime, packet->sentTime); + if (stats->latency_histogram) { + histogram_insert(stats->latency_histogram, transit, NULL); + } + double deltaTransit; + deltaTransit = transit - stats->transit.current.last; + stats->transit.current.last = transit; // shift transit for next time + if (deltaTransit < 0.0) { + deltaTransit = -deltaTransit; + } + // Compute end/end delay stats + reporter_update_mmm(&stats->transit.total, transit); + reporter_update_mmm(&stats->transit.current, transit); + // + // Compute jitter though filter the case of isoch and between isoch frames + // or, in other words, only calculate jitter for packets within the same isoch frame + // + // Taken from RFC 1889, Real Time Protocol (RTP) + // J = J + ( | D(i-1,i) | - J ) / + // + // interarrival jitter: + // + // An estimate of the statistical variance of the RTP data packet + // interarrival time, measured in timestamp units and expressed as + // an unsigned integer. The interarrival jitter J is defined to be + // the mean deviation (smoothed absolute value) of the difference D + // in packet spacing at the receiver compared to the sender for a + // pair of packets. As shown in the equation below, this is + // equivalent to the difference in the "relative transit time" for + // the two packets; the relative transit time is the difference + // between a packet's RTP timestamp and the receiver's clock at the + // time of arrival, measured in the same units. + // + // If Si is the RTP timestamp from packet i, and Ri is the time of + // arrival in RTP timestamp units for packet i, then for two packets i + // and j, D may be expressed as + // + // D(i,j)=(Rj-Ri)-(Sj-Si)=(Rj-Sj)-(Ri-Si) + // + // The interarrival jitter is calculated continuously as each data + // packet i is received from source SSRC_n, using this difference D for + // that packet and the previous packet i-1 in order of arrival (not + // necessarily in sequence), according to the formula + // + // J=J+(|D(i-1,i)|-J)/16 + // + // Whenever a reception report is issued, the current value of J is + // sampled. This algorithm is the optimal first-order estimator and + // the gain parameter 1/16 gives a good noise reduction ratio while / + // maintaining a reasonable rate of convergence + // + if (isIsochronous(stats->common) && stats->isochstats.newburst) { + --stats->isochstats.newburst; // decr the burst counter, need for RTP estimator w/isoch + // printf("**** skip value %f per frame change packet %d expected %d max = %f %d\n", deltaTransit, packet->frameID, stats->isochstats.frameID, stats->inline_jitter.total.max, stats->isochstats.newburst); + } else if (stats->transit.total.cnt > 1) { + stats->jitter += (deltaTransit - stats->jitter) / (16.0); + reporter_update_mmm(&stats->inline_jitter.total, stats->jitter); + reporter_update_mmm(&stats->inline_jitter.current, stats->jitter); + if (stats->jitter_histogram) { + histogram_insert(stats->jitter_histogram, deltaTransit, NULL); + } + } +} + + +static void reporter_handle_isoch_oneway_transit_tcp (struct TransferInfo *stats, struct ReportStruct *packet) { + // printf("fid=%lu bs=%lu remain=%lu\n", packet->frameID, packet->burstsize, packet->remaining); + if (packet->frameID && packet->transit_ready) { + int framedelta = 0; + double frametransit = 0; + // very first isochronous frame + if (!stats->isochstats.frameID) { + stats->isochstats.framecnt.current=packet->frameID; + stats->isochstats.newburst = 0; // no packet/read filtering of early samples for TCP + } + // perform client and server frame based accounting + if ((framedelta = (packet->frameID - stats->isochstats.frameID))) { + stats->isochstats.framecnt.current++; + if (framedelta > 1) { + stats->isochstats.framelostcnt.current += (framedelta-1); + stats->isochstats.slipcnt.current++; + } else if (stats->common->ThreadMode == kMode_Server) { + // Triptimes use the frame start time in passed in the frame header while + // it's calculated from the very first start time and frame id w/o trip timees + if (isTripTime(stats->common)) { + frametransit = TimeDifference(packet->packetTime, packet->isochStartTime); + } else { + frametransit = TimeDifference(packet->packetTime, packet->isochStartTime) \ + - ((packet->burstperiod * (packet->frameID - 1)) / 1e6); + } + reporter_update_mmm(&stats->isochstats.transit.total, frametransit); + reporter_update_mmm(&stats->isochstats.transit.current, frametransit); + if (stats->framelatency_histogram) { + histogram_insert(stats->framelatency_histogram, frametransit, &packet->packetTime); + } + } + } + stats->isochstats.frameID = packet->frameID; + } +} + +static void reporter_handle_isoch_oneway_transit_udp (struct TransferInfo *stats, struct ReportStruct *packet) { + // printf("fid=%lu bs=%lu remain=%lu\n", packet->frameID, packet->burstsize, packet->remaining); + if (packet->frameID && packet->transit_ready) { + int framedelta = 0; + double frametransit = 0; + // very first isochronous frame + if (!stats->isochstats.frameID) { + stats->isochstats.framecnt.current=1; + } + // perform client and server frame based accounting + framedelta = (packet->frameID - stats->isochstats.frameID); + stats->isochstats.framecnt.current++; +// stats->matchframeID = packet->frameID + 1; + if (framedelta == 1) { + stats->isochstats.newburst = 2; // set to two per RTP's pair calculation + // Triptimes use the frame start time in passed in the frame header while + // it's calculated from the very first start time and frame id w/o trip timees + frametransit = TimeDifference(packet->packetTime, packet->isochStartTime) \ + - ((packet->burstperiod * (packet->frameID - 1)) / 1e6); + reporter_update_mmm(&stats->isochstats.transit.total, frametransit); + reporter_update_mmm(&stats->isochstats.transit.current, frametransit); + if (stats->framelatency_histogram) { + histogram_insert(stats->framelatency_histogram, frametransit, &packet->packetTime); + } + } else if (framedelta > 1) { + stats->isochstats.newburst = 2; // set to two per RTP's pair calculation + if (stats->common->ThreadMode == kMode_Server) { + stats->isochstats.framelostcnt.current += framedelta; + } else { + stats->isochstats.framelostcnt.current += framedelta; + stats->isochstats.slipcnt.current++; + } + } + stats->isochstats.frameID = packet->frameID; + } +} + + +static void reporter_handle_rxmsg_oneway_transit (struct TransferInfo *stats, struct ReportStruct *packet) { + // very first burst + if (!stats->isochstats.frameID) { + stats->isochstats.frameID = packet->frameID; + } + if (packet->frameID && packet->transit_ready) { + double transit = TimeDifference(packet->packetTime, packet->sentTime); +// printf("**** r pt %ld.%ld st %ld.%ld %f\n", packet->packetTime.tv_sec, packet->packetTime.tv_usec, packet->sentTime.tv_sec, packet->sentTime.tv_usec, transit); + reporter_update_mmm(&stats->transit.total, transit); + reporter_update_mmm(&stats->transit.current, transit); + if (stats->framelatency_histogram) { + histogram_insert(stats->framelatency_histogram, transit, &packet->sentTime); + } + if (!TimeZero(stats->ts.prevpacketTime)) { + double delta = TimeDifference(packet->sentTime, stats->ts.prevpacketTime); + stats->IPGsum += delta; + } + stats->ts.prevpacketTime = packet->sentTime; + stats->isochstats.frameID++; // RJM fix this overload + stats->burstid_transition = true; + } else if (stats->burstid_transition && packet->frameID && (packet->frameID != stats->isochstats.frameID)) { + stats->burstid_transition = false; + fprintf(stderr,"%sError: expected burst id %u but got %d\n", \ + stats->common->transferIDStr, stats->isochstats.frameID + 1, packet->frameID); + stats->isochstats.frameID = packet->frameID; + } +} + +static inline void reporter_handle_txmsg_oneway_transit (struct TransferInfo *stats, struct ReportStruct *packet) { + // very first burst + if (!stats->isochstats.frameID) { + stats->isochstats.frameID = packet->frameID; + } + if (!TimeZero(stats->ts.prevpacketTime)) { + double delta = TimeDifference(packet->sentTime, stats->ts.prevpacketTime); + stats->IPGsum += delta; + } + if (packet->transit_ready) { + reporter_handle_packet_oneway_transit(stats, packet); + // printf("***Burst id = %ld, transit = %f\n", packet->frameID, stats->transit.lastTransit); + if (isIsochronous(stats->common)) { + if (packet->frameID && (packet->frameID != (stats->isochstats.frameID + 1))) { + fprintf(stderr,"%sError: expected burst id %u but got %d\n", \ + stats->common->transferIDStr, stats->isochstats.frameID + 1, packet->frameID); + } + stats->isochstats.frameID = packet->frameID; + } + } +} + +static void reporter_handle_frame_isoch_oneway_transit (struct TransferInfo *stats, struct ReportStruct *packet) { + // printf("fid=%lu bs=%lu remain=%lu\n", packet->frameID, packet->burstsize, packet->remaining); + if (packet->scheduled) { + reporter_update_mmm(&stats->schedule_error, (double)(packet->sched_err)); + } + if (packet->frameID && packet->transit_ready) { + int framedelta=0; + // very first isochronous frame + if (!stats->isochstats.frameID) { + stats->isochstats.framecnt.current=packet->frameID; + } + // perform frame based accounting + if ((framedelta = (packet->frameID - stats->isochstats.frameID))) { + stats->isochstats.framecnt.current++; + if (framedelta > 1) { + stats->isochstats.framelostcnt.current += (framedelta-1); + stats->isochstats.slipcnt.current++; + } + } + stats->isochstats.frameID = packet->frameID; + } +} + +// This is done in reporter thread context +void reporter_handle_packet_client (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + stats->ts.packetTime = packet->packetTime; + if (!packet->emptyreport) { + stats->total.Bytes.current += packet->packetLen; + if (packet->errwrite && (packet->errwrite != WriteErrNoAccount)) { + stats->sock_callstats.write.WriteErr++; + stats->sock_callstats.write.totWriteErr++; + } + // These are valid packets that need standard iperf accounting + stats->sock_callstats.write.WriteCnt += packet->writecnt; + stats->sock_callstats.write.totWriteCnt += packet->writecnt; + if (isIsochronous(stats->common)) { + reporter_handle_frame_isoch_oneway_transit(stats, packet); + } else if (isPeriodicBurst(stats->common)) { + reporter_handle_txmsg_oneway_transit(stats, packet); + } + if (isTcpWriteTimes(stats->common) && !isUDP(stats->common) && (packet->write_time > 0)) { + reporter_update_mmm(&stats->write_mmm.current, ((double) packet->write_time)); + reporter_update_mmm(&stats->write_mmm.total, ((double) packet->write_time)); + if (stats->write_histogram ) { + histogram_insert(stats->write_histogram, (1e-6 * packet->write_time), NULL); + } + } + } + if (isUDP(stats->common)) { + stats->PacketID = packet->packetID; + reporter_compute_packet_pps(stats, packet); + } +} + +#define DEBUG_BB_TIMESTAMPS 0 +void reporter_handle_packet_bb_client (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + if (packet->scheduled) { + reporter_update_mmm(&stats->schedule_error, (double)(packet->sched_err)); + } + if (!packet->emptyreport && (packet->packetLen > 0)) { + stats->total.Bytes.current += packet->packetLen; + double bbrtt = TimeDifference(packet->packetTime, packet->sentTime); + double bbowdto = TimeDifference(packet->sentTimeRX, packet->sentTime); + double bbowdfro = TimeDifference(packet->packetTime, packet->sentTimeTX); + double asym = bbowdfro - bbowdto; + stats->ts.prevpacketTime = packet->packetTime; +#if DEBUG_BB_TIMESTAMPS + fprintf(stderr, "BB Debug: ctx=%lx.%lx srx=%lx.%lx stx=%lx.%lx crx=%lx.%lx (hex)\n", packet->sentTime.tv_sec, packet->sentTime.tv_usec, packet->sentTimeRX.tv_sec, packet->sentTimeRX.tv_usec, packet->sentTimeTX.tv_sec, packet->sentTimeTX.tv_usec, packet->packetTime.tv_sec, packet->packetTime.tv_usec); + fprintf(stderr, "BB Debug: ctx=%ld.%ld srx=%ld.%ld stx=%ld.%ld crx=%ld.%ld\n", packet->sentTime.tv_sec, packet->sentTime.tv_usec, packet->sentTimeRX.tv_sec, packet->sentTimeRX.tv_usec, packet->sentTimeTX.tv_sec, packet->sentTimeTX.tv_usec, packet->packetTime.tv_sec, packet->packetTime.tv_usec); + fprintf(stderr, "BB RTT=%f OWDTo=%f OWDFro=%f Asym=%f\n", bbrtt, bbowdto, bbowdfro, asym); +#endif + stats->iBBrunning += bbrtt; + stats->fBBrunning += bbrtt; + reporter_update_mmm(&stats->bbrtt.current, bbrtt); + reporter_update_mmm(&stats->bbrtt.total, bbrtt); + reporter_update_mmm(&stats->bbowdto.total, bbowdto); + reporter_update_mmm(&stats->bbowdfro.total, bbowdfro); + reporter_update_mmm(&stats->bbasym.total, fabs(asym)); + if (stats->bbrtt_histogram) { + histogram_insert(stats->bbrtt_histogram, bbrtt, NULL); + } + } +} + +void reporter_handle_packet_bb_server (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + stats->ts.packetTime = packet->packetTime; + if (!packet->emptyreport && (packet->packetLen > 0)) { + stats->total.Bytes.current += packet->packetLen; + } +} + +inline void reporter_handle_packet_server_tcp (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + if (packet->packetLen > 0) { + int bin; + stats->total.Bytes.current += packet->packetLen; + // mean min max tests + stats->sock_callstats.read.cntRead++; + stats->sock_callstats.read.totcntRead++; + bin = (int)floor((packet->packetLen -1)/stats->sock_callstats.read.binsize); + if (bin < TCPREADBINCOUNT) { + stats->sock_callstats.read.bins[bin]++; + stats->sock_callstats.read.totbins[bin]++; + } + if (packet->transit_ready) { + if (isIsochronous(stats->common) && packet->frameID) { + reporter_handle_isoch_oneway_transit_tcp(stats, packet); + } else if (isPeriodicBurst(stats->common) || isTripTime(stats->common)) { + reporter_handle_rxmsg_oneway_transit(stats, packet); + } + } + } +} + +inline void reporter_handle_packet_server_udp (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + stats->ts.packetTime = packet->packetTime; + if (packet->emptyreport && (stats->transit.current.cnt == 0)) { + // This is the case when empty reports + // cross the report interval boundary + // Hence, set the per interval min to infinity + // and the per interval max and sum to zero + reporter_reset_mmm(&stats->transit.current); + } else if (packet->packetID > 0) { + stats->total.Bytes.current += packet->packetLen; + // These are valid packets that need standard iperf accounting + // Do L2 accounting first (if needed) + if (packet->l2errors && (stats->total.Datagrams.current > L2DROPFILTERCOUNTER)) { + stats->l2counts.cnt++; + stats->l2counts.tot_cnt++; + if (packet->l2errors & L2UNKNOWN) { + stats->l2counts.unknown++; + stats->l2counts.tot_unknown++; + } + if (packet->l2errors & L2LENERR) { + stats->l2counts.lengtherr++; + stats->l2counts.tot_lengtherr++; + } + if (packet->l2errors & L2CSUMERR) { + stats->l2counts.udpcsumerr++; + stats->l2counts.tot_udpcsumerr++; + } + } + // packet loss occured if the datagram numbers aren't sequential + if (packet->packetID != stats->PacketID + 1) { + if (packet->packetID < stats->PacketID + 1) { + stats->total.OutofOrder.current++; + } else { + stats->total.Lost.current += packet->packetID - stats->PacketID - 1; + } + } + // never decrease datagramID (e.g. if we get an out-of-order packet) + if (packet->packetID > stats->PacketID) { + stats->PacketID = packet->packetID; + } + reporter_compute_packet_pps(stats, packet); + reporter_handle_packet_oneway_transit(stats, packet); + if (packet->transit_ready) { + if (isIsochronous(stats->common)) { + reporter_handle_isoch_oneway_transit_udp(stats, packet); + } else if (isPeriodicBurst(stats->common)) { + reporter_handle_txmsg_oneway_transit(stats, packet); + } + } + } +} + +// This is done in reporter thread context +#if HAVE_TCP_STATS +static inline void reporter_handle_packet_tcpistats (struct ReporterData *data, struct ReportStruct *packet) { + assert(data!=NULL); + struct TransferInfo *stats = &data->info; + stats->sock_callstats.write.tcpstats.retry += (packet->tcpstats.retry_tot - stats->sock_callstats.write.tcpstats.retry_prev); + stats->sock_callstats.write.tcpstats.retry_prev = packet->tcpstats.retry_tot; + stats->sock_callstats.write.tcpstats.retry_tot = packet->tcpstats.retry_tot; + stats->sock_callstats.write.tcpstats.cwnd = packet->tcpstats.cwnd; + stats->sock_callstats.write.tcpstats.rtt = packet->tcpstats.rtt; + stats->sock_callstats.write.tcpstats.rttvar = packet->tcpstats.rttvar; +} +#endif + + +/* + * Report printing routines below + */ +static inline void reporter_set_timestamps_time (struct TransferInfo *stats, enum TimeStampType tstype) { + // There is a corner case when the first packet is also the last where the start time (which comes + // from app level syscall) is greater than the packetTime (which come for kernel level SO_TIMESTAMP) + // For this case set the start and end time to both zero. + struct ReportTimeStamps *times = &stats->ts; + if (TimeDifference(times->packetTime, times->startTime) < 0) { + times->iEnd = 0; + times->iStart = 0; + } else { + switch (tstype) { + case INTERVAL: + times->iStart = times->iEnd; + times->iEnd = TimeDifference(times->nextTime, times->startTime); + TimeAdd(times->nextTime, times->intervalTime); + stats->final = false; + break; + case TOTAL: + times->iStart = 0; + times->iEnd = TimeDifference(times->packetTime, times->startTime); + stats->final = true; + break; + case FINALPARTIAL: + times->iStart = times->iEnd; + times->iEnd = TimeDifference(times->packetTime, times->startTime); + stats->final = false; + break; + case INTERVALPARTIAL: + if ((times->iStart = TimeDifference(times->prevpacketTime, times->startTime)) < 0) + times->iStart = 0.0; + times->iEnd = TimeDifference(times->packetTime, times->startTime); + stats->final = false; + break; + default: + times->iEnd = -1; + times->iStart = -1; + stats->final = false; + break; + } + } +} + +// If reports were missed, catch up now +static inline void reporter_transfer_protocol_missed_reports (struct TransferInfo *stats, struct ReportStruct *packet) { + while (TimeDifference(packet->packetTime, stats->ts.nextTime) > TimeDouble(stats->ts.intervalTime)) { +// printf("**** cmp=%f/%f next %ld.%ld packet %ld.%ld id=%ld\n", TimeDifference(packet->packetTime, stats->ts.nextTime), TimeDouble(stats->ts.intervalTime), stats->ts.nextTime.tv_sec, stats->ts.nextTime.tv_usec, packet->packetTime.tv_sec, packet->packetTime.tv_usec, packet->packetID); + reporter_set_timestamps_time(stats, INTERVAL); + struct TransferInfo emptystats; + memset(&emptystats, 0, sizeof(struct TransferInfo)); + emptystats.ts.iStart = stats->ts.iStart; + emptystats.ts.iEnd = stats->ts.iEnd; + emptystats.common = stats->common; + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(&emptystats); + } +} + +static inline void reporter_reset_transfer_stats_client_tcp (struct TransferInfo *stats) { + stats->total.Bytes.prev = stats->total.Bytes.current; + stats->sock_callstats.write.WriteCnt = 0; + stats->sock_callstats.write.WriteErr = 0; + stats->isochstats.framecnt.prev = stats->isochstats.framecnt.current; + stats->isochstats.framelostcnt.prev = stats->isochstats.framelostcnt.current; + stats->isochstats.slipcnt.prev = stats->isochstats.slipcnt.current; +#if HAVE_TCP_STATS + // set the interval retry counter to zero + stats->sock_callstats.write.tcpstats.retry = 0; +#endif + if (isBounceBack(stats->common)) { + stats->iBBrunning = 0; + reporter_reset_mmm(&stats->bbrtt.current); + reporter_reset_mmm(&stats->bbowdto.current); + reporter_reset_mmm(&stats->bbowdfro.current); + reporter_reset_mmm(&stats->bbasym.current); + } + if (isTcpWriteTimes(stats->common)) { + stats->write_mmm.current.cnt = 0; + stats->write_mmm.current.min = FLT_MAX; + stats->write_mmm.current.max = FLT_MIN; + stats->write_mmm.current.sum = 0; + stats->write_mmm.current.vd = 0; + stats->write_mmm.current.mean = 0; + stats->write_mmm.current.m2 = 0; + } +} + +static inline void reporter_reset_transfer_stats_client_udp (struct TransferInfo *stats) { + if (stats->cntError < 0) { + stats->cntError = 0; + } + stats->total.Lost.prev = stats->total.Lost.current; + stats->total.Datagrams.prev = stats->total.Datagrams.current; + stats->total.Bytes.prev = stats->total.Bytes.current; + stats->total.IPG.prev = stats->total.IPG.current; + stats->sock_callstats.write.WriteCnt = 0; + stats->sock_callstats.write.WriteErr = 0; + stats->isochstats.framecnt.prev = stats->isochstats.framecnt.current; + stats->isochstats.framelostcnt.prev = stats->isochstats.framelostcnt.current; + stats->isochstats.slipcnt.prev = stats->isochstats.slipcnt.current; + if (stats->cntDatagrams) + stats->IPGsum = 0; +} + +static inline void reporter_reset_transfer_stats_server_tcp (struct TransferInfo *stats) { + int ix; + stats->total.Bytes.prev = stats->total.Bytes.current; + stats->sock_callstats.read.cntRead = 0; + for (ix = 0; ix < 8; ix++) { + stats->sock_callstats.read.bins[ix] = 0; + } + reporter_reset_mmm(&stats->transit.current); + reporter_reset_mmm(&stats->isochstats.transit.current); + stats->IPGsum = 0; +} + +static inline void reporter_reset_transfer_stats_server_udp (struct TransferInfo *stats) { + // Reset the enhanced stats for the next report interval + stats->total.Bytes.prev = stats->total.Bytes.current; + stats->total.Datagrams.prev = stats->PacketID; + stats->total.OutofOrder.prev = stats->total.OutofOrder.current; + stats->total.Lost.prev = stats->total.Lost.current; + stats->total.IPG.prev = stats->total.IPG.current; + reporter_reset_mmm(&stats->transit.current); + stats->isochstats.framecnt.prev = stats->isochstats.framecnt.current; + stats->isochstats.framelostcnt.prev = stats->isochstats.framelostcnt.current; + stats->isochstats.slipcnt.prev = stats->isochstats.slipcnt.current; + stats->l2counts.cnt = 0; + stats->l2counts.unknown = 0; + stats->l2counts.udpcsumerr = 0; + stats->l2counts.lengtherr = 0; + stats->threadcnt = 0; + stats->iInP = 0; + if (stats->cntDatagrams) + stats->IPGsum = 0; +} + +// These do the following +// +// o) set the TransferInfo struct and then calls the individual report output handler +// o) updates the sum and fullduplex reports +// +void reporter_transfer_protocol_server_udp (struct ReporterData *data, int final) { + struct TransferInfo *stats = &data->info; + struct TransferInfo *sumstats = (data->GroupSumReport != NULL) ? &data->GroupSumReport->info : NULL; + struct TransferInfo *fullduplexstats = (data->FullDuplexReport != NULL) ? &data->FullDuplexReport->info : NULL; + // print a interval report and possibly a partial interval report if this a final + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + stats->cntOutofOrder = stats->total.OutofOrder.current - stats->total.OutofOrder.prev; + // assume most of the time out-of-order packets are + // duplicate packets, so conditionally subtract them from the lost packets. + stats->cntError = stats->total.Lost.current - stats->total.Lost.prev - stats->cntOutofOrder; + if (stats->cntError < 0) + stats->cntError = 0; + stats->cntDatagrams = stats->PacketID - stats->total.Datagrams.prev; + stats->cntIPG = stats->total.IPG.current - stats->total.IPG.prev; + + if (stats->latency_histogram) { + stats->latency_histogram->final = final; + } + if (stats->jitter_histogram) { + stats->jitter_histogram->final = final; + } + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + if (stats->framelatency_histogram) { + stats->framelatency_histogram->final = final; + } + } + if (stats->total.Datagrams.current == 1) + stats->jitter = 0; + if (isTripTime(stats->common) && !final) { + double lambda = ((stats->IPGsum > 0.0) ? (round (stats->cntIPG / stats->IPGsum)) : 0.0); + double meantransit = (double) ((stats->transit.current.cnt > 0) ? (stats->transit.current.sum / stats->transit.current.cnt) : 0.0); + double variance = (stats->transit.current.cnt < 2) ? 0 : \ + (sqrt(stats->transit.current.m2 / (stats->transit.current.cnt - 1))); + stats->iInP = (double) lambda * meantransit; + stats->iInPVar = (double) lambda * variance; + } + if (sumstats) { + sumstats->total.OutofOrder.current += stats->total.OutofOrder.current - stats->total.OutofOrder.prev; + // assume most of the time out-of-order packets are not + // duplicate packets, so conditionally subtract them from the lost packets. + sumstats->total.Lost.current += stats->total.Lost.current - stats->total.Lost.prev; + sumstats->total.Datagrams.current += stats->PacketID - stats->total.Datagrams.prev; + sumstats->total.Bytes.current += stats->cntBytes; + sumstats->total.IPG.current += stats->cntIPG; + if (sumstats->IPGsum < stats->IPGsum) + sumstats->IPGsum = stats->IPGsum; + sumstats->threadcnt++; + sumstats->iInP += stats->iInP; + } + if (fullduplexstats) { + fullduplexstats->total.Bytes.current += stats->cntBytes; + fullduplexstats->total.IPG.current += stats->cntIPG; + fullduplexstats->total.Datagrams.current += (stats->total.Datagrams.current - stats->total.Datagrams.prev); + if (fullduplexstats->IPGsum < stats->IPGsum) + fullduplexstats->IPGsum = stats->IPGsum; + } + if (final) { + if ((stats->cntBytes > 0) && !TimeZero(stats->ts.intervalTime)) { + stats->cntOutofOrder = stats->total.OutofOrder.current - stats->total.OutofOrder.prev; + // assume most of the time out-of-order packets are not + // duplicate packets, so conditionally subtract them from the lost packets. + stats->cntError = stats->total.Lost.current - stats->total.Lost.prev; + stats->cntError -= stats->cntOutofOrder; + if (stats->cntError < 0) + stats->cntError = 0; + stats->cntDatagrams = stats->PacketID - stats->total.Datagrams.prev; + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + } + } + reporter_set_timestamps_time(stats, TOTAL); + stats->IPGsum = TimeDifference(stats->ts.packetTime, stats->ts.startTime); + stats->cntOutofOrder = stats->total.OutofOrder.current; + // assume most of the time out-of-order packets are not + // duplicate packets, so conditionally subtract them from the lost packets. + stats->cntError = stats->total.Lost.current; + stats->cntError -= stats->cntOutofOrder; + if (stats->cntError < 0) + stats->cntError = 0; + stats->cntDatagrams = stats->PacketID; + stats->cntIPG = stats->total.IPG.current; + stats->IPGsum = TimeDifference(stats->ts.packetTime, stats->ts.startTime); + stats->cntBytes = stats->total.Bytes.current; + stats->l2counts.cnt = stats->l2counts.tot_cnt; + stats->l2counts.unknown = stats->l2counts.tot_unknown; + stats->l2counts.udpcsumerr = stats->l2counts.tot_udpcsumerr; + stats->l2counts.lengtherr = stats->l2counts.tot_lengtherr; + stats->transit.current = stats->transit.total; + if (isTripTime(stats->common)) { + double lambda = ((stats->IPGsum > 0.0) ? (round (stats->cntIPG / stats->IPGsum)) : 0.0); + double meantransit = (double) ((stats->transit.total.cnt > 0) ? (stats->transit.total.sum / stats->transit.total.cnt) : 0.0); + double variance = (stats->transit.total.cnt < 2) ? 0 : \ + (sqrt(stats->transit.total.m2 / (stats->transit.total.cnt - 1))); + stats->fInP = (double) lambda * meantransit; + stats->fInPVar = (double) lambda * variance; + if (sumstats) { + sumstats->fInP += stats->fInP; + } + } + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current; + } + if (stats->latency_histogram) { + if (sumstats && sumstats->latency_histogram) { + histogram_add(sumstats->latency_histogram, stats->latency_histogram); + sumstats->latency_histogram->final = 1; + } + stats->latency_histogram->final = 1; + } + if (stats->jitter_histogram) { + if (sumstats && sumstats->jitter_histogram) { + histogram_add(sumstats->jitter_histogram, stats->jitter_histogram); + sumstats->jitter_histogram->final = 1; + } + stats->jitter_histogram->final = 1; + } + if (stats->framelatency_histogram) { + stats->framelatency_histogram->final = 1; + } + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + if (!final) + reporter_reset_transfer_stats_server_udp(stats); +} + +void reporter_transfer_protocol_sum_server_udp (struct TransferInfo *stats, int final) { + if (final) { + reporter_set_timestamps_time(stats, TOTAL); + stats->cntOutofOrder = stats->total.OutofOrder.current; + // assume most of the time out-of-order packets are not + // duplicate packets, so conditionally subtract them from the lost packets. + stats->cntError = stats->total.Lost.current; + stats->cntError -= stats->cntOutofOrder; + if (stats->cntError < 0) + stats->cntError = 0; + stats->cntDatagrams = stats->total.Datagrams.current; + stats->cntBytes = stats->total.Bytes.current; + stats->IPGsum = TimeDifference(stats->ts.packetTime, stats->ts.startTime); + stats->cntIPG = stats->total.IPG.current; + } else { + stats->cntOutofOrder = stats->total.OutofOrder.current - stats->total.OutofOrder.prev; + // assume most of the time out-of-order packets are not + // duplicate packets, so conditionally subtract them from the lost packets. + stats->cntError = stats->total.Lost.current - stats->total.Lost.prev; + stats->cntError -= stats->cntOutofOrder; + if (stats->cntError < 0) + stats->cntError = 0; + stats->cntDatagrams = stats->total.Datagrams.current - stats->total.Datagrams.prev; + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + stats->cntIPG = stats->total.IPG.current - stats->total.IPG.prev; + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + if (!final) { + // there is no packet ID for sum server reports, set it to total cnt for calculation + stats->PacketID = stats->total.Datagrams.current; + reporter_reset_transfer_stats_server_udp(stats); + } +} +void reporter_transfer_protocol_sum_client_udp (struct TransferInfo *stats, int final) { + if (final) { + reporter_set_timestamps_time(stats, TOTAL); + stats->sock_callstats.write.WriteErr = stats->sock_callstats.write.totWriteErr; + stats->sock_callstats.write.WriteCnt = stats->sock_callstats.write.totWriteCnt; + stats->cntDatagrams = stats->total.Datagrams.current; + stats->cntBytes = stats->total.Bytes.current; + stats->IPGsum = TimeDifference(stats->ts.packetTime, stats->ts.startTime); + stats->cntIPG = stats->total.IPG.current; + } else { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + stats->cntIPG = stats->total.IPG.current - stats->total.IPG.prev; + stats->cntDatagrams = stats->total.Datagrams.current - stats->total.Datagrams.prev; + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + + if (!final) { + stats->threadcnt = 0; + reporter_reset_transfer_stats_client_udp(stats); + } else if ((stats->common->ReportMode != kReport_CSV) && !(stats->isMaskOutput)) { + printf(report_sumcnt_datagrams, stats->threadcnt, stats->total.Datagrams.current); + fflush(stdout); + } +} + +void reporter_transfer_protocol_client_udp (struct ReporterData *data, int final) { + struct TransferInfo *stats = &data->info; + struct TransferInfo *sumstats = (data->GroupSumReport != NULL) ? &data->GroupSumReport->info : NULL; + struct TransferInfo *fullduplexstats = (data->FullDuplexReport != NULL) ? &data->FullDuplexReport->info : NULL; + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + stats->cntDatagrams = stats->total.Datagrams.current - stats->total.Datagrams.prev; + stats->cntIPG = stats->total.IPG.current - stats->total.IPG.prev; + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + } + if (sumstats) { + sumstats->total.Bytes.current += stats->cntBytes; + sumstats->sock_callstats.write.WriteErr += stats->sock_callstats.write.WriteErr; + sumstats->sock_callstats.write.WriteCnt += stats->sock_callstats.write.WriteCnt; + sumstats->sock_callstats.write.totWriteErr += stats->sock_callstats.write.WriteErr; + sumstats->sock_callstats.write.totWriteCnt += stats->sock_callstats.write.WriteCnt; + sumstats->total.Datagrams.current += stats->cntDatagrams; + if (sumstats->IPGsum < stats->IPGsum) + sumstats->IPGsum = stats->IPGsum; + sumstats->total.IPG.current += stats->cntIPG; + sumstats->threadcnt++; + } + if (fullduplexstats) { + fullduplexstats->total.Bytes.current += stats->cntBytes; + fullduplexstats->total.IPG.current += stats->cntIPG; + fullduplexstats->total.Datagrams.current += stats->cntDatagrams; + if (fullduplexstats->IPGsum < stats->IPGsum) + fullduplexstats->IPGsum = stats->IPGsum; + } + if (final) { + reporter_set_timestamps_time(stats, TOTAL); + stats->cntBytes = stats->total.Bytes.current; + stats->sock_callstats.write.WriteErr = stats->sock_callstats.write.totWriteErr; + stats->sock_callstats.write.WriteCnt = stats->sock_callstats.write.totWriteCnt; + stats->cntIPG = stats->total.IPG.current; + stats->cntDatagrams = stats->PacketID; + stats->IPGsum = TimeDifference(stats->ts.packetTime, stats->ts.startTime); + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current; + } + } else { + if (stats->ts.iEnd > 0) { + stats->cntIPG = (stats->total.IPG.current - stats->total.IPG.prev); + } else { + stats->cntIPG = 0; + } + } + if ((stats->output_handler) && !(stats->isMaskOutput)) { + (*stats->output_handler)(stats); + if (final && (stats->common->ReportMode != kReport_CSV)) { + printf(report_datagrams, stats->common->transferID, stats->total.Datagrams.current); + fflush(stdout); + } + } + reporter_reset_transfer_stats_client_udp(stats); +} + +void reporter_transfer_protocol_server_tcp (struct ReporterData *data, int final) { + struct TransferInfo *stats = &data->info; + struct TransferInfo *sumstats = (data->GroupSumReport != NULL) ? &data->GroupSumReport->info : NULL; + struct TransferInfo *fullduplexstats = (data->FullDuplexReport != NULL) ? &data->FullDuplexReport->info : NULL; + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + int ix; + if (stats->framelatency_histogram) { + stats->framelatency_histogram->final = 0; + } + double thisInP; + if (!final) { + double bytecnt = (double) (stats->total.Bytes.current - stats->total.Bytes.prev); + double lambda = (stats->IPGsum > 0.0) ? (bytecnt / stats->IPGsum) : 0.0; + double meantransit = (double) ((stats->transit.current.cnt > 0) ? (stats->transit.current.sum / stats->transit.current.cnt) : 0.0); + thisInP = lambda * meantransit; + stats->iInP = thisInP; + } else { + double bytecnt = (double) stats->cntBytes; + double lambda = (stats->IPGsum > 0.0) ? (bytecnt / stats->IPGsum) : 0.0; + double meantransit = (double) ((stats->transit.total.cnt > 0) ? (stats->transit.total.sum / stats->transit.total.cnt) : 0.0); + thisInP = lambda * meantransit; + stats->fInP = thisInP; + } + if (sumstats) { + sumstats->threadcnt++; + sumstats->total.Bytes.current += stats->cntBytes; + sumstats->sock_callstats.read.cntRead += stats->sock_callstats.read.cntRead; + sumstats->sock_callstats.read.totcntRead += stats->sock_callstats.read.cntRead; + for (ix = 0; ix < TCPREADBINCOUNT; ix++) { + sumstats->sock_callstats.read.bins[ix] += stats->sock_callstats.read.bins[ix]; + sumstats->sock_callstats.read.totbins[ix] += stats->sock_callstats.read.bins[ix]; + } + if (!final) { + sumstats->iInP += thisInP; + } else { + sumstats->fInP += thisInP; + } + } + if (fullduplexstats) { + fullduplexstats->total.Bytes.current += stats->cntBytes; + } + if (final) { + if ((stats->cntBytes > 0) && stats->output_handler && !TimeZero(stats->ts.intervalTime)) { + // print a partial interval report if enable and this a final + if ((stats->output_handler) && !(stats->isMaskOutput)) { + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + } + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_server_tcp(stats); + } + } + if (stats->framelatency_histogram) { + stats->framelatency_histogram->final = 1; + } + reporter_set_timestamps_time(stats, TOTAL); + stats->cntBytes = stats->total.Bytes.current; + stats->IPGsum = stats->ts.iEnd; + stats->sock_callstats.read.cntRead = stats->sock_callstats.read.totcntRead; + for (ix = 0; ix < TCPREADBINCOUNT; ix++) { + stats->sock_callstats.read.bins[ix] = stats->sock_callstats.read.totbins[ix]; + } + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current; + } + stats->transit.current = stats->transit.total; + if (stats->framelatency_histogram) { + if (sumstats && sumstats->framelatency_histogram) { + histogram_add(sumstats->framelatency_histogram, stats->framelatency_histogram); + sumstats->framelatency_histogram->final = 1; + } + stats->framelatency_histogram->final = 1; + } + } else if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + } + if ((stats->output_handler) && !stats->isMaskOutput) { + (*stats->output_handler)(stats); + if (isFrameInterval(stats->common) && stats->framelatency_histogram) { + histogram_print(stats->framelatency_histogram, stats->ts.iStart, stats->ts.iEnd); + } + } + if (!final) + reporter_reset_transfer_stats_server_tcp(stats); +} + +void reporter_transfer_protocol_client_tcp (struct ReporterData *data, int final) { + struct TransferInfo *stats = &data->info; + struct TransferInfo *sumstats = (data->GroupSumReport != NULL) ? &data->GroupSumReport->info : NULL; + struct TransferInfo *fullduplexstats = (data->FullDuplexReport != NULL) ? &data->FullDuplexReport->info : NULL; + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + if (stats->latency_histogram) { + stats->latency_histogram->final = final; + } + if (stats->write_histogram) { + stats->write_histogram->final = final; + } + if (isIsochronous(stats->common)) { + if (final) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current; + } else { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + } + } + if (sumstats) { + sumstats->total.Bytes.current += stats->cntBytes; + sumstats->sock_callstats.write.WriteErr += stats->sock_callstats.write.WriteErr; + sumstats->sock_callstats.write.WriteCnt += stats->sock_callstats.write.WriteCnt; + sumstats->sock_callstats.write.totWriteErr += stats->sock_callstats.write.WriteErr; + sumstats->sock_callstats.write.totWriteCnt += stats->sock_callstats.write.WriteCnt; + sumstats->threadcnt++; +#if HAVE_TCP_STATS + sumstats->sock_callstats.write.tcpstats.retry += stats->sock_callstats.write.tcpstats.retry; + sumstats->sock_callstats.write.tcpstats.retry_tot += stats->sock_callstats.write.tcpstats.retry; +#endif + } + if (fullduplexstats) { + fullduplexstats->total.Bytes.current += stats->cntBytes; + } + if (final) { + if (stats->latency_histogram) { + stats->latency_histogram->final = 1; + } + if (stats->write_histogram) { + stats->write_histogram->final = 1; + } + if ((stats->cntBytes > 0) && stats->output_handler && !TimeZero(stats->ts.intervalTime)) { + // print a partial interval report if enable and this a final + if ((stats->output_handler) && !(stats->isMaskOutput)) { + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + } + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_client_tcp(stats); + } + } + if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current; + } + stats->sock_callstats.write.WriteErr = stats->sock_callstats.write.totWriteErr; + stats->sock_callstats.write.WriteCnt = stats->sock_callstats.write.totWriteCnt; +#if HAVE_TCP_STATS + stats->sock_callstats.write.tcpstats.retry = stats->sock_callstats.write.tcpstats.retry_tot; +#endif + if (stats->framelatency_histogram) { + stats->framelatency_histogram->final = 1; + } + stats->cntBytes = stats->total.Bytes.current; + stats->write_mmm.current = stats->write_mmm.total; + reporter_set_timestamps_time(stats, TOTAL); + } else if (isIsochronous(stats->common)) { + stats->isochstats.cntFrames = stats->isochstats.framecnt.current - stats->isochstats.framecnt.prev; + stats->isochstats.cntFramesMissed = stats->isochstats.framelostcnt.current - stats->isochstats.framelostcnt.prev; + stats->isochstats.cntSlips = stats->isochstats.slipcnt.current - stats->isochstats.slipcnt.prev; + } + if ((stats->output_handler) && !(stats->isMaskOutput)) { + (*stats->output_handler)(stats); + } + if (!final) + reporter_reset_transfer_stats_client_tcp(stats); +} + +/* + * Handles summing of threads + */ +void reporter_transfer_protocol_sum_client_tcp (struct TransferInfo *stats, int final) { + if (!final || (final && (stats->cntBytes > 0) && !TimeZero(stats->ts.intervalTime))) { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + if (final) { + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_client_tcp(stats); + } + } else if ((stats->output_handler) && !(stats->isMaskOutput)) { + (*stats->output_handler)(stats); + stats->threadcnt = 0; + } + reporter_reset_transfer_stats_client_tcp(stats); + } + if (final) { + stats->sock_callstats.write.WriteErr = stats->sock_callstats.write.totWriteErr; + stats->sock_callstats.write.WriteCnt = stats->sock_callstats.write.totWriteCnt; +#if HAVE_TCP_STATS + stats->sock_callstats.write.tcpstats.retry = stats->sock_callstats.write.tcpstats.retry_tot; +#endif + stats->cntBytes = stats->total.Bytes.current; + reporter_set_timestamps_time(stats, TOTAL); + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + } +} + +void reporter_transfer_protocol_client_bb_tcp (struct ReporterData *data, int final) { + struct TransferInfo *stats = &data->info; + + if (final) { + if ((stats->cntBytes > 0) && stats->output_handler && !TimeZero(stats->ts.intervalTime)) { + // print a partial interval report if enable and this a final + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_client_tcp(stats); + } + } +#if HAVE_TCP_STATS + stats->sock_callstats.write.tcpstats.retry = stats->sock_callstats.write.tcpstats.retry_tot; +#endif + stats->cntBytes = stats->total.Bytes.current; + reporter_set_timestamps_time(stats, TOTAL); + } else { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + if (!final) { + reporter_reset_transfer_stats_client_tcp(stats); + } +} + +void reporter_transfer_protocol_server_bb_tcp (struct ReporterData *data, int final) { + struct TransferInfo *stats = &data->info; + if (final) { + if ((stats->cntBytes > 0) && stats->output_handler && !TimeZero(stats->ts.intervalTime)) { + // print a partial interval report if enable and this a final + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_server_tcp(stats); + } + } +#if HAVE_TCP_STATS + + stats->sock_callstats.write.tcpstats.retry = stats->sock_callstats.write.tcpstats.retry_tot; +#endif + stats->cntBytes = stats->total.Bytes.current; + reporter_set_timestamps_time(stats, TOTAL); + } else { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + if (!final) + reporter_reset_transfer_stats_client_tcp(stats); +} + +void reporter_transfer_protocol_sum_server_tcp (struct TransferInfo *stats, int final) { + if (!final || (final && (stats->cntBytes > 0) && !TimeZero(stats->ts.intervalTime))) { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + if (final) { + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + } + } else if ((stats->output_handler) && !(stats->isMaskOutput)) { + (*stats->output_handler)(stats); + stats->threadcnt = 0; + stats->iInP = 0; + } + reporter_reset_transfer_stats_server_tcp(stats); + } + if (final) { + int ix; + stats->cntBytes = stats->total.Bytes.current; + stats->sock_callstats.read.cntRead = stats->sock_callstats.read.totcntRead; + for (ix = 0; ix < TCPREADBINCOUNT; ix++) { + stats->sock_callstats.read.bins[ix] = stats->sock_callstats.read.totbins[ix]; + } + stats->cntBytes = stats->total.Bytes.current; + reporter_set_timestamps_time(stats, TOTAL); + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + } +} +void reporter_transfer_protocol_fullduplex_tcp (struct TransferInfo *stats, int final) { + if (!final || (final && (stats->cntBytes > 0) && !TimeZero(stats->ts.intervalTime))) { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + if (final) { + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + } + } + stats->total.Bytes.prev = stats->total.Bytes.current; + } + if (final) { + stats->cntBytes = stats->total.Bytes.current; + reporter_set_timestamps_time(stats, TOTAL); + } else { + reporter_set_timestamps_time(stats, INTERVAL); + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); +} + +void reporter_transfer_protocol_fullduplex_udp (struct TransferInfo *stats, int final) { + if (!final || (final && (stats->cntBytes > 0) && !TimeZero(stats->ts.intervalTime))) { + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + stats->cntDatagrams = stats->total.Datagrams.current - stats->total.Datagrams.prev; + stats->cntIPG = stats->total.IPG.current - stats->total.IPG.prev; + if (final) { + if ((stats->output_handler) && !(stats->isMaskOutput)) { + reporter_set_timestamps_time(stats, FINALPARTIAL); + if ((stats->ts.iEnd - stats->ts.iStart) > stats->ts.significant_partial) + (*stats->output_handler)(stats); + } + } + stats->total.Bytes.prev = stats->total.Bytes.current; + stats->total.IPG.prev = stats->total.IPG.current; + stats->total.Datagrams.prev = stats->total.Datagrams.current; + } + if (final) { + stats->cntBytes = stats->total.Bytes.current; + stats->cntBytes = stats->total.Bytes.current; + stats->cntDatagrams = stats->total.Datagrams.current ; + stats->cntIPG = stats->total.IPG.current; + stats->IPGsum = TimeDifference(stats->ts.packetTime, stats->ts.startTime); + reporter_set_timestamps_time(stats, TOTAL); + } else { + reporter_set_timestamps_time(stats, INTERVAL); + } + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + if (stats->cntDatagrams) + stats->IPGsum = 0.0; +} + +// Conditional print based on time +int reporter_condprint_time_interval_report (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + assert(stats!=NULL); + // printf("***sum handler = %p\n", (void *) data->GroupSumReport->transfer_protocol_sum_handler); + int advance_jobq = 0; + // Print a report if packet time exceeds the next report interval time, + // Also signal to the caller to move to the next report (or packet ring) + // if there was output. This will allow for more precise interval sum accounting. + // printf("***** pt = %ld.%ld next = %ld.%ld\n", packet->packetTime.tv_sec, packet->packetTime.tv_usec, stats->ts.nextTime.tv_sec, stats->ts.nextTime.tv_usec); + // printf("***** nt %ld.%ld pt %ld.%ld pid=%lld empty=%d\n", stats->ts.nextTime.tv_sec, stats->ts.nextTime.tv_usec, packet->packetTime.tv_sec, packet->packetTime.tv_usec, packet->packetID, packet->emptyreport); + if (TimeDifference(stats->ts.nextTime, packet->packetTime) < 0) { + assert(data->transfer_protocol_handler!=NULL); + advance_jobq = 1; + struct TransferInfo *sumstats = (data->GroupSumReport ? &data->GroupSumReport->info : NULL); + struct TransferInfo *fullduplexstats = (data->FullDuplexReport ? &data->FullDuplexReport->info : NULL); + stats->ts.packetTime = packet->packetTime; +#ifdef DEBUG_PPS + printf("*** packetID TRIGGER = %ld pt=%ld.%ld empty=%d nt=%ld.%ld\n",packet->packetID, packet->packetTime.tv_sec, packet->packetTime.tv_usec, packet->emptyreport, stats->ts.nextTime.tv_sec, stats->ts.nextTime.tv_usec); +#endif + reporter_set_timestamps_time(stats, INTERVAL); + (*data->transfer_protocol_handler)(data, 0); + if (fullduplexstats && ((++data->FullDuplexReport->threads) == 2) && isEnhanced(stats->common)) { + data->FullDuplexReport->threads = 0; + assert(data->FullDuplexReport->transfer_protocol_sum_handler != NULL); + (*data->FullDuplexReport->transfer_protocol_sum_handler)(fullduplexstats, 0); + } + if (sumstats) { + if ((++data->GroupSumReport->threads) == data->GroupSumReport->reference.count) { + data->GroupSumReport->threads = 0; + if ((data->GroupSumReport->reference.count > (fullduplexstats ? 2 : 1)) || \ + isSumOnly(data->info.common)) { + sumstats->isMaskOutput = false; + } else { + sumstats->isMaskOutput = true; + } + reporter_set_timestamps_time(sumstats, INTERVAL); + assert(data->GroupSumReport->transfer_protocol_sum_handler != NULL); + (*data->GroupSumReport->transfer_protocol_sum_handler)(sumstats, 0); + } + } + // In the (hopefully unlikely event) the reporter fell behind + // output the missed reports to catch up + if ((stats->output_handler) && !(stats->isMaskOutput)) + reporter_transfer_protocol_missed_reports(stats, packet); + } + return advance_jobq; +} + +// Conditional print based on bursts or frames +int reporter_condprint_frame_interval_report_server_udp (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + int advance_jobq = 0; + // first packet of a burst and not a duplicate + if ((packet->burstsize == (packet->remaining + packet->packetLen)) && (stats->matchframeID != packet->frameID)) { + stats->matchframeID=packet->frameID; + } + if ((packet->packetLen == packet->remaining) && (packet->frameID == stats->matchframeID)) { + if ((stats->ts.iStart = TimeDifference(stats->ts.nextTime, stats->ts.startTime)) < 0) + stats->ts.iStart = 0.0; + stats->frameID = packet->frameID; + stats->ts.iEnd = TimeDifference(packet->packetTime, stats->ts.startTime); + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + stats->cntOutofOrder = stats->total.OutofOrder.current - stats->total.OutofOrder.prev; + // assume most of the time out-of-order packets are not + // duplicate packets, so conditionally subtract them from the lost packets. + stats->cntError = stats->total.Lost.current - stats->total.Lost.prev; + stats->cntError -= stats->cntOutofOrder; + if (stats->cntError < 0) + stats->cntError = 0; + stats->cntDatagrams = stats->PacketID - stats->total.Datagrams.prev; + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_server_udp(stats); + advance_jobq = 1; + } + return advance_jobq; +} + +int reporter_condprint_frame_interval_report_server_tcp (struct ReporterData *data, struct ReportStruct *packet) { + fprintf(stderr, "FIX ME\n"); + return 1; +} + +int reporter_condprint_burst_interval_report_server_tcp (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + int advance_jobq = 0; + if (packet->transit_ready) { + stats->ts.prevpacketTime = packet->sentTime; + stats->ts.packetTime = packet->packetTime; + reporter_set_timestamps_time(stats, INTERVALPARTIAL); + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_server_tcp(stats); + advance_jobq = 1; + } + return advance_jobq; +} + +int reporter_condprint_burst_interval_report_client_tcp (struct ReporterData *data, struct ReportStruct *packet) { + struct TransferInfo *stats = &data->info; + int advance_jobq = 0; + // first packet of a burst and not a duplicate + if (packet->transit_ready) { + reporter_handle_packet_oneway_transit(stats, packet); +// printf("****sndpkt=%ld.%ld rxpkt=%ld.%ld\n", packet->sentTime.tv_sec, packet->sentTime.tv_usec, packet->packetTime.tv_sec,packet->packetTime.tv_usec); + stats->ts.prevpacketTime = packet->prevSentTime; + stats->ts.packetTime = packet->packetTime; + reporter_set_timestamps_time(stats, INTERVALPARTIAL); + stats->cntBytes = stats->total.Bytes.current - stats->total.Bytes.prev; + if ((stats->output_handler) && !(stats->isMaskOutput)) + (*stats->output_handler)(stats); + reporter_reset_transfer_stats_client_tcp(stats); + advance_jobq = 1; + } + return advance_jobq; +} + +#ifdef __cplusplus +} /* end extern "C" */ +#endif diff --git a/src/Reports.c b/src/Reports.c new file mode 100644 index 0000000..008f7f4 --- /dev/null +++ b/src/Reports.c @@ -0,0 +1,1091 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Reporter.c + * rewritten by Robert McMahon + * ------------------------------------------------------------------- + * Handle instantiation and deletion of reports, including sum reports, + * in a thread safe way + * ------------------------------------------------------------------- */ + +#include "headers.h" +#include <math.h> +#include "Settings.hpp" +#include "PerfSocket.hpp" +#include "Reporter.h" +#include "Locale.h" +#include "active_hosts.h" +#include "payloads.h" +static int transferid_counter = 0; + +static inline int my_str_copy(char **dst, char *src) { + int cnt = 0; + if (src) { + *dst = (char *) calloc(strlen(src) + 1, sizeof(char)); + if (*dst == NULL) { + fprintf(stderr, "Out of Memory!!\n"); + exit(1); + } + cnt = strlen(src) + 1; + strcpy((*dst), src); + } else { + *dst = NULL; + } + return cnt; +} + +// These are the thread settings that are shared among report types +// Make a copy vs referencing the thread setting object. This will +// better encpasulate report handling. +static void common_copy (struct ReportCommon **common, struct thread_Settings *inSettings) { + // Do deep copies from settings + *common = (struct ReportCommon *) calloc(1, sizeof(struct ReportCommon)); + my_str_copy(&(*common)->Host, inSettings->mHost); + my_str_copy(&(*common)->HideHost, inSettings->mHideHost); + my_str_copy(&(*common)->Localhost, inSettings->mLocalhost); + my_str_copy(&(*common)->Ifrname, inSettings->mIfrname); + my_str_copy(&(*common)->Ifrnametx, inSettings->mIfrnametx); + my_str_copy(&(*common)->SSMMulticastStr, inSettings->mSSMMulticastStr); + my_str_copy(&(*common)->Congestion, inSettings->mCongestion); + my_str_copy(&(*common)->transferIDStr, inSettings->mTransferIDStr); + my_str_copy(&(*common)->PermitKey, inSettings->mPermitKey); + + // copy some relevant settings + (*common)->flags = inSettings->flags; + (*common)->flags_extend = inSettings->flags_extend; + (*common)->flags_extend2 = inSettings->flags_extend2; + (*common)->ThreadMode = inSettings->mThreadMode; + (*common)->ReportMode = inSettings->mReportMode; + (*common)->KeyCheck = inSettings->mKeyCheck; + (*common)->Format = inSettings->mFormat; + (*common)->TTL = inSettings->mTTL; + // copy some traffic related settings + (*common)->BufLen = inSettings->mBufLen; + (*common)->MSS = inSettings->mMSS; + (*common)->TCPWin = inSettings->mTCPWin; + (*common)->FQPacingRate = inSettings->mFQPacingRate; + (*common)->Port = inSettings->mPort; + (*common)->PortLast = inSettings->mPortLast; + (*common)->BindPort = inSettings->mBindPort; + (*common)->ListenPort = inSettings->mListenPort; + (*common)->AppRate = inSettings->mAppRate; + (*common)->BurstSize = inSettings->mBurstSize; + (*common)->AppRateUnits = inSettings->mAppRateUnits; + (*common)->socket = inSettings->mSock; + (*common)->transferID = inSettings->mTransferID; + (*common)->threads = inSettings->mThreads; + (*common)->winsize_requested = inSettings->mTCPWin; +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + (*common)->socketdrop = inSettings->mSockDrop; +#endif + (*common)->peer = inSettings->peer; + (*common)->size_peer = inSettings->size_peer; + (*common)->jitter_binwidth = inSettings->jitter_binwidth; + (*common)->local = inSettings->local; + (*common)->size_local = inSettings->size_local; + (*common)->HistBins =inSettings->mHistBins; + (*common)->HistBinsize =inSettings->mHistBinsize; + (*common)->HistUnits =inSettings->mHistUnits; + (*common)->pktIPG =inSettings->mBurstIPG; + (*common)->rtt_weight = inSettings->rtt_nearcongest_weight_factor; + (*common)->ListenerTimeout =inSettings->mListenerTimeout; + (*common)->FPS = inSettings->mFPS; + (*common)->TOS = inSettings->mTOS; + (*common)->RTOS = inSettings->mRTOS; + (*common)->bbsize = inSettings->mBounceBackBytes; + (*common)->bbhold = inSettings->mBounceBackHold; + (*common)->bbcount = inSettings->mBounceBackBurst; +#if HAVE_DECL_TCP_WINDOW_CLAMP + (*common)->ClampSize = inSettings->mClampSize; +#endif +#if HAVE_DECL_TCP_NOTSENT_LOWAT + (*common)->WritePrefetch = inSettings->mWritePrefetch; +#endif +#ifdef HAVE_THREAD_DEBUG + thread_debug("Alloc common rpt/com/size %p/%p/%d", (void *) common, (void *)(*common), sizeof(struct ReportCommon)); +#endif +} + +static void free_common_copy (struct ReportCommon *common) { + assert(common != NULL); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Free common=%p", (void *)common); +#endif + // Free deep copies + if (common->Host) + free(common->Host); + if (common->HideHost) + free(common->HideHost); + if (common->Localhost) + free(common->Localhost); + if (common->Ifrname) + free(common->Ifrname); + if (common->Ifrnametx) + free(common->Ifrnametx); + if (common->SSMMulticastStr) + free(common->SSMMulticastStr); + if (common->Congestion) + free(common->Congestion); + if (common->transferIDStr) + free(common->transferIDStr); + if (common->PermitKey) + free(common->PermitKey); + free(common); +} + +// This will set the transfer id and id string +// on the setting object. If the current id is zero +// this will get the next one. Otherwise it will use +// the value. +void setTransferID (struct thread_Settings *inSettings, int role_reversal) { + if (!inSettings->mTransferIDStr) { + if (!inSettings->mTransferID) { + Mutex_Lock(&transferid_mutex); + inSettings->mTransferID = ++transferid_counter; + Mutex_Unlock(&transferid_mutex); + } + int len = 0; + if (role_reversal) { +#ifdef HAVE_ROLE_REVERSAL_ID + if (isPermitKey(inSettings) && (inSettings->mPermitKey[0] != '\0')) { + len = snprintf(NULL, 0, "[%s(*%d)] ", \ + inSettings->mPermitKey, inSettings->mTransferID); + inSettings->mTransferIDStr = (char *) calloc(len + 1, sizeof(char)); + len = sprintf(inSettings->mTransferIDStr, "[%s(*%d)] ", \ + inSettings->mPermitKey, inSettings->mTransferID); + } else if (inSettings->mTransferID < 10) { + len = snprintf(NULL, 0, "[ *%d] ", inSettings->mTransferID); + inSettings->mTransferIDStr = (char *) calloc(len + 1, sizeof(char)); + len = sprintf(inSettings->mTransferIDStr, "[ *%d] ", inSettings->mTransferID); + } else { + len = snprintf(NULL, 0, "[*%d] ", inSettings->mTransferID); + inSettings->mTransferIDStr = (char *) calloc(len + 1, sizeof(char)); + len = sprintf(inSettings->mTransferIDStr, "[*%d] ", inSettings->mTransferID); + } +#endif + } else if (isPermitKey(inSettings) && (inSettings->mPermitKey[0] != '\0')) { + len = snprintf(NULL, 0, "[%s(%d)] ", \ + inSettings->mPermitKey, inSettings->mTransferID); + inSettings->mTransferIDStr = (char *) calloc(len + 1, sizeof(char)); + len = sprintf(inSettings->mTransferIDStr, "[%s(%d)] ", \ + inSettings->mPermitKey, inSettings->mTransferID); + } else { + len = snprintf(NULL, 0, "[%3d] ", inSettings->mTransferID); + inSettings->mTransferIDStr = (char *) calloc(len+1, sizeof(char)); + len = sprintf(inSettings->mTransferIDStr, "[%3d] ", inSettings->mTransferID); + } + } +} + +void SetFullDuplexHandlers (struct thread_Settings *inSettings, struct SumReport* sumreport) { + if (isUDP(inSettings)) { + sumreport->transfer_protocol_sum_handler = reporter_transfer_protocol_fullduplex_udp; + sumreport->info.output_handler = ((inSettings->mReportMode == kReport_CSV) ? NULL : \ + (isSumOnly(inSettings) ? NULL : \ + (isEnhanced(inSettings) ? udp_output_fullduplex_enhanced : udp_output_fullduplex))); + } else { + sumreport->transfer_protocol_sum_handler = reporter_transfer_protocol_fullduplex_tcp; + sumreport->info.output_handler = ((inSettings->mReportMode == kReport_CSV) ? NULL : \ + (isSumOnly(inSettings) ? NULL : \ + (isEnhanced(inSettings) ? tcp_output_fullduplex_enhanced : tcp_output_fullduplex))); + } +} + +void SetSumHandlers (struct thread_Settings *inSettings, struct SumReport* sumreport) { + switch (inSettings->mThreadMode) { + case kMode_Server : + if (isUDP(inSettings)) { + sumreport->transfer_protocol_sum_handler = reporter_transfer_protocol_sum_server_udp; + if (inSettings->mReportMode == kReport_CSV) { + if (isEnhanced(inSettings)) + sumreport->info.output_handler = udp_output_enhanced_csv; + else + sumreport->info.output_handler = udp_output_basic_csv; + } else { + if (isTripTime(inSettings)) { + sumreport->info.output_handler = udp_output_sumcnt_read_triptime; + } else if (isSumOnly(inSettings)) { + sumreport->info.output_handler = udp_output_sumcnt_enhanced; + } else if (isFullDuplex(inSettings)) { + sumreport->info.output_handler = udp_output_fullduplex_sum; + } else { + sumreport->info.output_handler = (isEnhanced(inSettings) ? udp_output_sum_read_enhanced : udp_output_sum_read); + } + } + } else { + sumreport->transfer_protocol_sum_handler = reporter_transfer_protocol_sum_server_tcp; + if (inSettings->mReportMode == kReport_CSV) { + if (isEnhanced(inSettings)) + sumreport->info.output_handler = tcp_output_read_enhanced_csv; + else + sumreport->info.output_handler = tcp_output_basic_csv; + } else { + if (isTripTime(inSettings)) { + sumreport->info.output_handler = tcp_output_sumcnt_read_triptime; + } else if (isSumOnly(inSettings)) { + sumreport->info.output_handler = (isEnhanced(inSettings) ? tcp_output_sumcnt_read_enhanced : tcp_output_sumcnt_read); + } else if (isFullDuplex(inSettings)) { + sumreport->info.output_handler = tcp_output_sum_read; + } else { + sumreport->info.output_handler = (isEnhanced(inSettings) ? tcp_output_sum_read_enhanced : tcp_output_sum_read); + } + } + } + break; + case kMode_Client : + if (isUDP(inSettings)) { + sumreport->transfer_protocol_sum_handler = reporter_transfer_protocol_sum_client_udp; + if (inSettings->mReportMode == kReport_CSV) { + if (isEnhanced(inSettings)) + sumreport->info.output_handler = udp_output_enhanced_csv; + else + sumreport->info.output_handler = udp_output_basic_csv; + } else { + if (isSumOnly(inSettings)) { + sumreport->info.output_handler = ((isEnhanced(inSettings) && !isFullDuplex(inSettings)) ? \ + udp_output_sumcnt_write_enhanced : udp_output_sumcnt); + } else if (isFullDuplex(inSettings)) { + sumreport->info.output_handler = udp_output_fullduplex_sum; + } else { + sumreport->info.output_handler = (isEnhanced(inSettings) ? udp_output_sum_write_enhanced : udp_output_sum_write); + } + } + } else { + sumreport->transfer_protocol_sum_handler = reporter_transfer_protocol_sum_client_tcp; + if (inSettings->mReportMode == kReport_CSV) { + if (isEnhanced(inSettings)) + sumreport->info.output_handler = tcp_output_write_enhanced_csv; + else + sumreport->info.output_handler = tcp_output_basic_csv; + } else { + if (isSumOnly(inSettings)) { + sumreport->info.output_handler = (isEnhanced(inSettings) ? tcp_output_sumcnt_write_enhanced : tcp_output_sumcnt_write); + } else if (isFullDuplex(inSettings)) { + sumreport->info.output_handler = tcp_output_fullduplex_sum; + } else { + sumreport->info.output_handler = (isEnhanced(inSettings) ? tcp_output_sum_write_enhanced : tcp_output_sum_write); + } + } + } + break; + default: + FAIL(1, "SetSumReport", inSettings); + } +} + +struct SumReport* InitSumReport(struct thread_Settings *inSettings, int inID, int fullduplex_report) { + struct SumReport *sumreport = (struct SumReport *) calloc(1, sizeof(struct SumReport)); + if (sumreport == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + sumreport->reference.count = 0; + sumreport->reference.maxcount = 0; + Mutex_Initialize(&sumreport->reference.lock); + sumreport->threads = 0; + common_copy(&sumreport->info.common, inSettings); + // sumreport->info.common->transferID = inID; // this is now set in the active code + sumreport->info.threadcnt = 0; + sumreport->info.isMaskOutput = false; + if (inSettings->mReportMode == kReport_CSV) { + format_ips_port_string(&sumreport->info, 1); + } + + // Only initialize the interval time here + // The startTime and nextTime for summing reports will be set by + // the reporter thread in realtime + if ((inSettings->mInterval) && (inSettings->mIntervalMode == kInterval_Time)) { + sumreport->info.ts.intervalTime.tv_sec = (long) (inSettings->mInterval / rMillion); + sumreport->info.ts.intervalTime.tv_usec = (long) (inSettings->mInterval % rMillion); + sumreport->info.ts.significant_partial = ((double) inSettings->mInterval * PARTIALPERCENT / rMillion) ; + } + // Note that for UDP the client flag settings have not been read (and set) so only use server side flags in tests + if (isEnhanced(inSettings) && (inSettings->mThreadMode == kMode_Server) && !fullduplex_report) { + if (isHistogram(inSettings)) { + if (isUDP(inSettings)) { + char name[] = "SUMT8"; + sumreport->info.latency_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0,\ + pow(10,inSettings->mHistUnits), \ + inSettings->mHistci_lower, inSettings->mHistci_upper, sumreport->info.common->transferID, name); + } else { + char name[] = "SUMF8"; + sumreport->info.framelatency_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0, \ + pow(10,inSettings->mHistUnits), inSettings->mHistci_lower, \ + inSettings->mHistci_upper, sumreport->info.common->transferID, name); + } + } + if (isJitterHistogram(inSettings) && isUDP(inSettings)) { + char name[] = "SUMJ8"; + sumreport->info.jitter_histogram = histogram_init(JITTER_BINCNT,inSettings->jitter_binwidth,0,JITTER_UNITS, \ + JITTER_LCI, JITTER_UCI, sumreport->info.common->transferID, name); + } + } + if (fullduplex_report) { + SetFullDuplexHandlers(inSettings, sumreport); + if (!isServerReverse(inSettings)) { + sumreport->fullduplex_barrier.count = 0; + Condition_Initialize(&sumreport->fullduplex_barrier.await); + sumreport->fullduplex_barrier.timeout = ((isModeTime(inSettings) && isUDP(inSettings)) ? \ + ((int)(inSettings->mAmount / 100) + 1) : MINBARRIERTIMEOUT); + if (sumreport->fullduplex_barrier.timeout < MINBARRIERTIMEOUT) + sumreport->fullduplex_barrier.timeout = MINBARRIERTIMEOUT; + } else { + sumreport->info.ts.startTime = inSettings->accept_time; + sumreport->info.ts.nextTime = sumreport->info.ts.startTime; + TimeAdd(sumreport->info.ts.nextTime, sumreport->info.ts.intervalTime); + } + } else { + SetSumHandlers(inSettings, sumreport); + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Init sum report %p id=%d", (void *)sumreport, inID); +#endif + return sumreport; +} + +struct ConnectionInfo * InitConnectOnlyReport (struct thread_Settings *thread) { + assert(thread != NULL); + // this connection report used only by report for accumulate stats + struct ConnectionInfo *creport = (struct ConnectionInfo *) calloc(1, sizeof(struct ConnectionInfo)); + if (!creport) { + FAIL(1, "Out of Memory!!\n", thread); + } + common_copy(&creport->common, thread); + creport->connect_times.min = FLT_MAX; + creport->connect_times.max = FLT_MIN; + creport->connect_times.vd = 0; + creport->connect_times.m2 = 0; + creport->connect_times.mean = 0; + creport->txholdbacktime = thread->txholdback_timer; + return creport; +} + +void FreeSumReport (struct SumReport *sumreport) { + assert(sumreport); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Free sum report hdr=%p", (void *)sumreport); +#endif + Condition_Destroy_Reference(&sumreport->reference); + if (sumreport->info.latency_histogram) { + histogram_delete(sumreport->info.latency_histogram); + } + if (sumreport->info.framelatency_histogram) { + histogram_delete(sumreport->info.framelatency_histogram); + } + if (sumreport->info.bbrtt_histogram) { + histogram_delete(sumreport->info.bbrtt_histogram); + } + if (sumreport->info.jitter_histogram) { + histogram_delete(sumreport->info.jitter_histogram); + } + free_common_copy(sumreport->info.common); + free(sumreport); +} + + +static void Free_iReport (struct ReporterData *ireport) { + assert(ireport != NULL); + +#ifdef HAVE_THREAD_DEBUG + thread_debug("Free report hdr=%p reporter thread suspend count=%d packetring=%p histo=%p frame histo=%p", \ + (void *)ireport, ireport->reporter_thread_suspends, (void *) ireport->packetring, \ + (void *)ireport->info.latency_histogram, (void *) ireport->info.framelatency_histogram); +#endif + if (ireport->packetring && ireport->info.total.Bytes.current && !(isSingleUDP(ireport->info.common)) && \ + !TimeZero(ireport->info.ts.intervalTime) && (ireport->reporter_thread_suspends < 3)) { + fprintf(stdout, "WARN: this test may have been CPU bound (%d) (or may not be detecting the underlying network devices)\n", \ + ireport->reporter_thread_suspends); + } + if (ireport->packetring) { + packetring_free(ireport->packetring); + } + if (ireport->info.latency_histogram) { + histogram_delete(ireport->info.latency_histogram); + } + if (ireport->info.jitter_histogram) { + histogram_delete(ireport->info.jitter_histogram); + } + if (ireport->info.framelatency_histogram) { + histogram_delete(ireport->info.framelatency_histogram); + } + if (ireport->info.bbrtt_histogram) { + histogram_delete(ireport->info.bbrtt_histogram); + } + free_common_copy(ireport->info.common); + free(ireport); +} + +void FreeConnectionReport (struct ConnectionInfo *report) { + free_common_copy(report->common); + free(report); +} + +static void Free_sReport (struct ReportSettings *report) { + free_common_copy(report->common); + free(report); +} + +static void Free_srReport (struct TransferInfo *report) { + free_common_copy(report->common); + free(report); +} + +void FreeReport (struct ReportHeader *reporthdr) { + assert(reporthdr != NULL); +#ifdef HAVE_THREAD_DEBUG + char rs[REPORTTXTMAX]; + reporttype_text(reporthdr, &rs[0]); + thread_debug("Jobq *FREE* report hdr/rpt %p/%p (%s)", (void *) reporthdr, (void *) reporthdr->this_report, &rs[0]); +#endif + switch (reporthdr->type) { + case DATA_REPORT: + Free_iReport((struct ReporterData *)reporthdr->this_report); + break; + case CONNECTION_REPORT: + FreeConnectionReport((struct ConnectionInfo *)reporthdr->this_report); + break; + case SETTINGS_REPORT: + Free_sReport((struct ReportSettings *)reporthdr->this_report); + break; + case SERVER_RELAY_REPORT: + Free_srReport((struct TransferInfo *)reporthdr->this_report); + break; + default: + fprintf(stderr, "Invalid report type in free (%x)\n", reporthdr->type); + assert(0); + break; + } + free(reporthdr); +} + +/* + * InitReport is called by a transfer agent (client or + * server) to setup the needed structures to communicate + * traffic and connection information. Also initialize + * the report start time and next interval report time + * Finally, in the case of parallel clients, have them all + * synchronize on compeleting their connect() + */ + +void IncrSumReportRefCounter (struct SumReport *sumreport) { + assert(sumreport); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Sum multiheader %p ref=%d->%d", (void *)sumreport, sumreport->reference.count, (sumreport->reference.count + 1)); +#endif + Mutex_Lock(&sumreport->reference.lock); + sumreport->reference.count++; + if (sumreport->reference.count > sumreport->reference.maxcount) + sumreport->reference.maxcount = sumreport->reference.count; + Mutex_Unlock(&sumreport->reference.lock); +} + +int DecrSumReportRefCounter (struct SumReport *sumreport) { + assert(sumreport); +// thread_debug("before lock hdr=%p", (void *)sumreport); + Mutex_Lock(&sumreport->reference.lock); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Sum multiheader %p ref=%d->%d", (void *)sumreport, sumreport->reference.count, (sumreport->reference.count - 1)); +#endif +// thread_debug("in lock hdr=%p", (void *)sumreport); + int refcnt = --sumreport->reference.count; + Mutex_Unlock(&sumreport->reference.lock); +// thread_debug("unlock hdr=%p", (void *)sumreport); + return refcnt; +} + + +// Note, this report structure needs to remain self contained and not coupled +// to any settings structure pointers. This allows the thread settings to +// be freed without impacting the reporter. It's not recommended that +// this be done, i.e. free the settings before the report, but be defensive +// here to allow it +struct ReportHeader* InitIndividualReport (struct thread_Settings *inSettings) { + /* + * Create the report header and an ireport (if needed) + */ + assert(inSettings!=NULL); + struct ReportHeader *reporthdr = (struct ReportHeader *) calloc(1, sizeof(struct ReportHeader)); + if (reporthdr == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->this_report = calloc(1, sizeof(struct ReporterData)); + if (reporthdr->this_report == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->type = DATA_REPORT; + reporthdr->ReportMode = inSettings->mReportMode; + + struct ReporterData *ireport = (struct ReporterData *)(reporthdr->this_report); + if (inSettings->mSumReport) { + ireport->GroupSumReport = inSettings->mSumReport; + } + if (isFullDuplex(inSettings)) { + assert(inSettings->mFullDuplexReport != NULL); + IncrSumReportRefCounter(inSettings->mFullDuplexReport); + ireport->FullDuplexReport = inSettings->mFullDuplexReport; + } + // Copy common settings into the transfer report section + common_copy(&ireport->info.common, inSettings); + ireport->info.final = false; + ireport->info.burstid_transition = false; + ireport->info.isEnableTcpInfo = false; + + // Create a new packet ring which is used to communicate + // packet stats from the traffic thread to the reporter + // thread. The reporter thread does all packet accounting + ireport->packetring = packetring_init((inSettings->numreportstructs ? inSettings->numreportstructs : (isSingleUDP(inSettings) ? 40 : NUM_REPORT_STRUCTS)), \ + &ReportCond, (isSingleUDP(inSettings) ? NULL : &inSettings->awake_me)); +#ifdef HAVE_THREAD_DEBUG + char rs[REPORTTXTMAX]; + reporttype_text(reporthdr, &rs[0]); + thread_debug("Init %s report hdr/rpt/com=%p/%p/%p multireport/fullduplex=%p/%p pring(bytes)/cond=%p(%d)/%p (socket=%d)", &rs[0], \ + (void *) reporthdr, (void *) ireport, (void *) ireport->info.common, \ + (void *) inSettings->mSumReport, (void *) inSettings->mFullDuplexReport, \ + (void *) ireport->packetring, ireport->packetring->bytes, (void *) ireport->packetring->awake_producer, inSettings->mSock); +#endif + if (inSettings->numreportstructs) + fprintf (stdout, "%sNUM_REPORT_STRUCTS override from %d to %d\n", inSettings->mTransferIDStr, NUM_REPORT_STRUCTS, inSettings->numreportstructs); + + // Set up the function vectors, there are three + // 1) packet_handler: does packet accounting per the test and protocol + // 2) transfer_protocol_handler: performs output, e.g. interval reports, per the test and protocol + + if (inSettings->mIntervalMode == kInterval_Time) { + ireport->info.ts.intervalTime.tv_sec = (long) (inSettings->mInterval / rMillion); + ireport->info.ts.intervalTime.tv_usec = (long) (inSettings->mInterval % rMillion); + ireport->transfer_interval_handler = reporter_condprint_time_interval_report; + ireport->info.ts.significant_partial = (double) inSettings->mInterval * PARTIALPERCENT / rMillion ; + } else { + ireport->transfer_interval_handler = NULL; + } + ireport->packet_handler_pre_report = NULL; + ireport->packet_handler_post_report = NULL; + switch (inSettings->mThreadMode) { + case kMode_Server : + if (isUDP(inSettings)) { + ireport->packet_handler_post_report = reporter_handle_packet_server_udp; + ireport->transfer_protocol_handler = reporter_transfer_protocol_server_udp; + if ((inSettings->mIntervalMode == kInterval_Frames) && isIsochronous(inSettings)) { + ireport->transfer_interval_handler = reporter_condprint_frame_interval_report_server_udp; + ireport->transfer_protocol_handler = reporter_transfer_protocol_server_udp; + } else { + ireport->transfer_protocol_handler = reporter_transfer_protocol_server_udp; + if (isSumOnly(inSettings)) { + ireport->info.output_handler = NULL; + } else if ((inSettings->mReportMode == kReport_CSV) && !isSumOnly(inSettings)) { + if (isEnhanced(inSettings)) + ireport->info.output_handler = udp_output_enhanced_csv; + else + ireport->info.output_handler = udp_output_basic_csv; + } else if (isTripTime(inSettings)) { + if (isIsochronous(inSettings)) + ireport->info.output_handler = udp_output_read_triptime_isoch; + else + ireport->info.output_handler = udp_output_read_triptime; + } else if (isEnhanced(inSettings)) { + ireport->info.output_handler = udp_output_read_enhanced; + } else if (isFullDuplex(inSettings)) { + ireport->info.output_handler = udp_output_read; + } else { + ireport->info.output_handler = udp_output_read; + } + } + } else { // TCP case + ireport->packet_handler_post_report = reporter_handle_packet_server_tcp; + ireport->transfer_protocol_handler = reporter_transfer_protocol_server_tcp; + if (isPeriodicBurst(inSettings)) { + ireport->transfer_interval_handler = reporter_condprint_burst_interval_report_server_tcp; + ireport->info.output_handler = tcp_output_burst_read; + ireport->packet_handler_pre_report = reporter_handle_packet_server_tcp; + ireport->packet_handler_post_report = NULL; + } else if ((inSettings->mIntervalMode == kInterval_Frames) && isIsochronous(inSettings)) { + ireport->transfer_interval_handler = reporter_condprint_frame_interval_report_server_tcp; + ireport->info.output_handler = tcp_output_frame_read_triptime; + ireport->packet_handler_pre_report = reporter_handle_packet_server_tcp; + ireport->packet_handler_post_report = NULL; + } else if (isSumOnly(inSettings)) { + ireport->info.output_handler = NULL; + } else if ((inSettings->mReportMode == kReport_CSV) && !isSumOnly(inSettings)) { + if (isEnhanced(inSettings)) + ireport->info.output_handler = tcp_output_read_enhanced_csv; + else + ireport->info.output_handler = tcp_output_basic_csv; + } else if (isBounceBack(inSettings)) { + ireport->packet_handler_post_report = reporter_handle_packet_bb_server; + ireport->transfer_protocol_handler = reporter_transfer_protocol_server_bb_tcp; + ireport->info.output_handler = tcp_output_write; + } else if (isTripTime(inSettings) && isIsochronous(inSettings)) { + ireport->info.output_handler = tcp_output_read_enhanced_isoch; + } else if (isTripTime(inSettings)) { + ireport->info.output_handler = tcp_output_read_triptime; + } else if (isEnhanced(inSettings)) { + ireport->info.output_handler = tcp_output_read_enhanced; + } else if (!isFullDuplex(inSettings)) { + ireport->info.output_handler = tcp_output_read; + } else { + ireport->info.output_handler = tcp_output_read; + } + } + break; + case kMode_Client : + ireport->packet_handler_post_report = reporter_handle_packet_client; + if (isUDP(inSettings)) { + ireport->transfer_protocol_handler = reporter_transfer_protocol_client_udp; + if (isSumOnly(inSettings)) { + ireport->info.output_handler = NULL; + } else if ((inSettings->mReportMode == kReport_CSV) && !isSumOnly(inSettings)) { + if (isEnhanced(inSettings)) + ireport->info.output_handler = udp_output_enhanced_csv; + else + ireport->info.output_handler = udp_output_basic_csv; + } else if (isIsochronous(inSettings)) { + ireport->info.output_handler = udp_output_write_enhanced_isoch; + } else if (isEnhanced(inSettings)) { + ireport->info.output_handler = udp_output_write_enhanced; + } else if (isFullDuplex(inSettings)) { + ireport->info.output_handler = udp_output_write; + } else { + ireport->info.output_handler = udp_output_write; + } + } else { + ireport->transfer_protocol_handler = reporter_transfer_protocol_client_tcp; + if (isSumOnly(inSettings)) { + ireport->info.output_handler = NULL; + } else if ((inSettings->mReportMode == kReport_CSV) && !isSumOnly(inSettings)) { + if (isEnhanced(inSettings)) + ireport->info.output_handler = tcp_output_write_enhanced_csv; + else + ireport->info.output_handler = tcp_output_basic_csv; + } else if (isBounceBack(inSettings)) { + ireport->packet_handler_post_report = reporter_handle_packet_bb_client; + ireport->transfer_protocol_handler = reporter_transfer_protocol_client_bb_tcp; + ireport->info.output_handler = tcp_output_write_bb; + } else if (isIsochronous(inSettings)) { + ireport->info.output_handler = tcp_output_write_enhanced_isoch; + } else if (isTcpWriteTimes(inSettings)) { + ireport->info.output_handler = tcp_output_write_enhanced_write; + } else if (isEnhanced(inSettings)) { + ireport->info.output_handler = tcp_output_write_enhanced; + } else if (isFullDuplex(inSettings)) { + ireport->info.output_handler = tcp_output_write; + } else { + ireport->info.output_handler = tcp_output_write; + } + } + break; + case kMode_Unknown : + case kMode_Reporter : + case kMode_ReporterClient : + case kMode_Listener: + default: + FAIL(1, "InitIndividualReport\n", inSettings); + } + + if (inSettings->mThreadMode == kMode_Server) { + ireport->info.sock_callstats.read.binsize = inSettings->mBufLen / 8; + if (isUDP(inSettings)) { + if (isJitterHistogram(inSettings)) { + char name[] = "J8"; + ireport->info.jitter_histogram = histogram_init(JITTER_BINCNT,inSettings->jitter_binwidth,0,JITTER_UNITS, \ + JITTER_LCI, JITTER_UCI, ireport->info.common->transferID, name); + } + if (isTripTime(inSettings) && isHistogram(inSettings)) { + char name[] = "T8"; + ireport->info.latency_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0,\ + pow(10,inSettings->mHistUnits), \ + inSettings->mHistci_lower, inSettings->mHistci_upper, ireport->info.common->transferID, name); + } + } + if (isHistogram(inSettings) && (isIsochronous(inSettings) || (!isUDP(inSettings) && isTripTime(inSettings)))) { + char name[] = "F8"; + // make sure frame bin size min is 100 microsecond + ireport->info.framelatency_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0, \ + pow(10,inSettings->mHistUnits), inSettings->mHistci_lower, \ + inSettings->mHistci_upper, ireport->info.common->transferID, name); + } + } + if ((inSettings->mThreadMode == kMode_Client) && !isUDP(inSettings) && isHistogram(inSettings)) { + if (isTcpWriteTimes(inSettings)) { + char name[] = "W8"; + ireport->info.write_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0,\ + pow(10,inSettings->mHistUnits), \ + inSettings->mHistci_lower, inSettings->mHistci_upper, ireport->info.common->transferID, name); + } else if (isWritePrefetch(inSettings)) { + char name[] = "S8"; + ireport->info.latency_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0,\ + pow(10,inSettings->mHistUnits), \ + inSettings->mHistci_lower, inSettings->mHistci_upper, ireport->info.common->transferID, name); + } + } + if ((inSettings->mThreadMode == kMode_Client) && isBounceBack(inSettings)) { + char name[] = "BB8"; + if (!isHistogram(inSettings)) { + inSettings->mHistBins = 100000; // 10 seconds wide + inSettings->mHistBinsize = 100; // 100 usec bins + inSettings->mHistUnits = 6; // usecs 10 pow(x) + inSettings->mHistci_lower = 5; + inSettings->mHistci_upper = 95; + } + ireport->info.bbrtt_histogram = histogram_init(inSettings->mHistBins,inSettings->mHistBinsize,0, \ + pow(10,inSettings->mHistUnits), \ + inSettings->mHistci_lower, inSettings->mHistci_upper, ireport->info.common->transferID, name); + } + return reporthdr; +} + + +/* + * This init/update and print/finish (in the ReportDefault.c) + * is poor. It has to be done this way to preserve the + * interface to older versions where the reporter settings + * were delayed until a Transfer report came through. + * This transfer report has all the reports bound to it. + * + * The better implmementation is to treat all reports + * as independent objects that can be updated, processed, + * and output independlty per the Reporter threads job queue + * without shared state or copied state variables between these + * reports. The shared state, is really reporter state, that + * should be maintained in and by the reporter object/thread. + * + * For now, just fix it good enough. Later, write a c++ + * reporter object and use standard c++ design techniques + * to achieve this. Such code will be easier to maintain + * and to extend. + */ +struct ReportHeader* InitConnectionReport (struct thread_Settings *inSettings) { + assert(inSettings != NULL); + struct ReportHeader *reporthdr = (struct ReportHeader *) calloc(1, sizeof(struct ReportHeader)); + if (reporthdr == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->this_report = calloc(1, sizeof(struct ConnectionInfo)); + if (reporthdr->this_report == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->type = CONNECTION_REPORT; + reporthdr->ReportMode = inSettings->mReportMode; + + struct ConnectionInfo * creport = (struct ConnectionInfo *)(reporthdr->this_report); + common_copy(&creport->common, inSettings); + tcpstats_copy(&creport->tcpinitstats, &inSettings->tcpinitstats); + // Fill out known fields for the connection report + reporter_peerversion(creport, inSettings->peer_version_u, inSettings->peer_version_l); + if (isEnhanced(inSettings) && isTxStartTime(inSettings)) { + creport->epochStartTime.tv_sec = inSettings->txstart_epoch.tv_sec; + creport->epochStartTime.tv_usec = inSettings->txstart_epoch.tv_usec; + } else if (isTripTime(inSettings)) { + creport->epochStartTime.tv_sec = inSettings->accept_time.tv_sec; + creport->epochStartTime.tv_usec = inSettings->accept_time.tv_usec; + } + // Copy state from the settings object into the connection report + creport->connect_times.min = FLT_MAX; + creport->connect_times.max = FLT_MIN; + creport->connect_times.vd = 0; + creport->connect_times.m2 = 0; + creport->connect_times.mean = 0; + if (inSettings->mSock > 0) { + creport->winsize = getsock_tcp_windowsize(inSettings->mSock, \ + (inSettings->mThreadMode != kMode_Client ? 0 : 1) ); +#if HAVE_DECL_TCP_WINDOW_CLAMP + if (isRxClamp(inSettings)) { + getsock_tcp_windowclamp(inSettings->mSock); + } +#endif + } + creport->common->winsize_requested = inSettings->mTCPWin; + creport->txholdbacktime = inSettings->txholdback_timer; + if (isPeriodicBurst(inSettings)) { + creport->common->FPS = inSettings->mFPS; + } +#ifdef HAVE_THREAD_DEBUG + char rs[REPORTTXTMAX]; + reporttype_text(reporthdr, &rs[0]); + thread_debug("Init %s report hdr/rpt/com %p/%p/%p", &rs[0], \ + (void *) reporthdr, (void *) reporthdr->this_report, (void *) creport->common); +#endif + return reporthdr; +} + +/* + * ReportSettings will generate a summary report for + * settings being used with Listeners or Clients + */ +struct ReportHeader *InitSettingsReport (struct thread_Settings *inSettings) { + assert(inSettings != NULL); + struct ReportHeader *reporthdr = (struct ReportHeader *) calloc(1, sizeof(struct ReportHeader)); + if (reporthdr == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->this_report = calloc(1, sizeof(struct ReportSettings)); + if (reporthdr->this_report == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->type = SETTINGS_REPORT; + reporthdr->ReportMode = inSettings->mReportMode; + + struct ReportSettings *sreport = (struct ReportSettings *)reporthdr->this_report; + common_copy(&sreport->common, inSettings); + sreport->peer = inSettings->peer; + sreport->size_peer = inSettings->size_peer; + sreport->local = inSettings->local; + sreport->size_local = inSettings->size_local; + sreport->isochstats.mFPS = inSettings->mFPS; + sreport->isochstats.mMean = inSettings->mMean/8; + sreport->isochstats.mVariance = inSettings->mVariance/8; + sreport->isochstats.mBurstIPG = (unsigned int) (inSettings->mBurstIPG*1000.0); + sreport->isochstats.mBurstInterval = (unsigned int) (1 / inSettings->mFPS * 1000000); + if (!isUDP(inSettings)) { + if (inSettings->mMSS > 0) { + sreport->sockmaxseg = inSettings->mMSS; + } else if (isPrintMSS(inSettings) && !(inSettings->mMSS > 0)) { + sreport->sockmaxseg = getsock_tcp_mss(inSettings->mSock); + } + } +#ifdef HAVE_THREAD_DEBUG + char rs[REPORTTXTMAX]; + reporttype_text(reporthdr, &rs[0]); + thread_debug("Init %s report hdr/rpt/com %p/%p/%p", &rs[0], \ + (void *) reporthdr, (void *) reporthdr->this_report, (void *) sreport->common); +#endif + return reporthdr; +} + +/* + * This will generate a report of the UDP + * statistics as reported by the server on the client + * side. + */ +struct ReportHeader* InitServerRelayUDPReport(struct thread_Settings *inSettings, struct server_hdr *server) { + /* + * Create the report header and an ireport (if needed) + */ + struct ReportHeader *reporthdr = (struct ReportHeader *) calloc(1, sizeof(struct ReportHeader)); + if (reporthdr == NULL) { + FAIL(1, "Out of Memory!!\n", inSettings); + } + reporthdr->this_report = calloc(1, sizeof(struct ServerRelay)); + if (!reporthdr->this_report) { + FAIL(1, "Out of Memory!!\n", inSettings); + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Init server relay report %p size %ld", (void *)reporthdr, sizeof(struct ReportHeader) + sizeof(struct ServerRelay)); +#endif + reporthdr->type = SERVER_RELAY_REPORT; + reporthdr->ReportMode = inSettings->mReportMode; + struct ServerRelay *sr_report = (struct ServerRelay *)reporthdr->this_report; + common_copy(&sr_report->info.common, inSettings); + struct TransferInfo *stats = &sr_report->info; + stats->common->transferID = inSettings->mTransferID; + + stats->jitter = ntohl(server->base.jitter1); + stats->jitter += ntohl(server->base.jitter2) / (double)rMillion; +#ifdef HAVE_INT64_T + stats->cntBytes = (((intmax_t) ntohl(server->base.total_len1)) << 32) + \ + ntohl(server->base.total_len2); +#else + stats->cntBytes = (intmax_t) ntohl(server->base.total_len2); +#endif + stats->ts.iStart = 0; + stats->ts.iEnd = ntohl(server->base.stop_sec); + stats->ts.iEnd += ntohl(server->base.stop_usec) / (double)rMillion; + uint32_t flags = ntohl(server->base.flags); + if ((flags & HEADER_SEQNO64B)) { + stats->cntError = (((intmax_t) ntohl(server->extend2.error_cnt2)) << 32) + \ + ntohl(server->base.error_cnt); + stats->cntOutofOrder = (((intmax_t) ntohl(server->extend2.outorder_cnt2)) << 32) + \ + ntohl(server->base.outorder_cnt); + stats->cntDatagrams = (((intmax_t) ntohl(server->extend2.datagrams2)) << 32) + \ + ntohl(server->base.datagrams); + } else { + stats->cntError = ntohl(server->base.error_cnt); + stats->cntOutofOrder = ntohl(server->base.outorder_cnt); + stats->cntDatagrams = ntohl(server->base.datagrams); + } + if ((flags & SERVER_HEADER_EXTEND) != 0) { + setEnhanced(stats->common); + stats->transit.current.min = ntohl(server->extend.minTransit1); + stats->transit.current.min += ntohl(server->extend.minTransit2) / (double)rMillion; + stats->transit.current.max = ntohl(server->extend.maxTransit1); + stats->transit.current.max += ntohl(server->extend.maxTransit2) / (double)rMillion; + stats->transit.current.sum = ntohl(server->extend.sumTransit1); + stats->transit.current.sum += ntohl(server->extend.sumTransit2) / (double)rMillion; + stats->transit.current.mean = ntohl(server->extend.meanTransit1); + stats->transit.current.mean += ntohl(server->extend.meanTransit2) / (double)rMillion; + stats->transit.current.m2 = ntohl(server->extend.m2Transit1); + stats->transit.current.m2 += ntohl(server->extend.m2Transit2) / (double)rMillion; + stats->transit.current.m2 *= 1e-12; + stats->transit.current.vd = ntohl(server->extend.vdTransit1); + stats->transit.current.vd += ntohl(server->extend.vdTransit2) / (double)rMillion; + stats->transit.current.cnt = ntohl(server->extend.cntTransit); + stats->cntIPG = ntohl(server->extend.cntIPG); + stats->IPGsum = ntohl(server->extend.IPGsum); + } else { + unsetEnhanced(stats->common); + } + sr_report->peer = inSettings->local; + sr_report->size_peer = inSettings->size_local; + sr_report->local = inSettings->peer; + sr_report->size_local = inSettings->size_peer; + return reporthdr; +} + +/* ------------------------------------------------------------------- + * Send an AckFIN (a datagram acknowledging a FIN) on the socket, + * then select on the socket for some time to check for silence. + * If additional datagrams come in (not silent), probably our AckFIN + * was lost so the client has re-transmitted + * termination datagrams, so re-transmit our AckFIN. + * Sent by server to client + * ------------------------------------------------------------------- */ +void write_UDP_AckFIN (struct TransferInfo *stats, int len) { + assert(stats!= NULL); + int ackpacket_length = (int) (sizeof(struct UDP_datagram) + sizeof(struct server_hdr)); + int readlen = ((ackpacket_length * 2) > len * 2) ? (ackpacket_length * 2) : (len * 2); + char *ackPacket = (char *) calloc(1, readlen); + int success = 0; + assert(ackPacket); + fd_set readSet; + int rc = 1; + struct timeval timeout; + + if (ackPacket) { + struct UDP_datagram *UDP_Hdr = (struct UDP_datagram *)ackPacket; + struct server_hdr *hdr = (struct server_hdr *)(UDP_Hdr+1); + + UDP_Hdr = (struct UDP_datagram*) ackPacket; + int flags = HEADER_VERSION1; + if (isEnhanced(stats->common) || isTripTime(stats->common)) + flags |= SERVER_HEADER_EXTEND; +#ifdef HAVE_INT64_T + flags |= HEADER_SEQNO64B; +#endif + hdr->base.flags = htonl((long) flags); +#ifdef HAVE_INT64_T + hdr->base.total_len1 = htonl((long) (stats->cntBytes >> 32)); +#else + hdr->base.total_len1 = htonl(0x0); +#endif + hdr->base.total_len2 = htonl((long) (stats->cntBytes & 0xFFFFFFFF)); + hdr->base.stop_sec = htonl( (long) stats->ts.iEnd); + hdr->base.stop_usec = htonl( (long)((stats->ts.iEnd - (long)stats->ts.iEnd) * rMillion)); + hdr->base.error_cnt = htonl((long) (stats->cntError & 0xFFFFFFFF)); + hdr->base.outorder_cnt = htonl((long) (stats->cntOutofOrder & 0xFFFFFFFF)); + hdr->base.datagrams = htonl((long) (stats->cntDatagrams & 0xFFFFFFFF)); + if (flags & HEADER_SEQNO64B) { + hdr->extend2.error_cnt2 = htonl((long) (stats->cntError >> 32)); + hdr->extend2.outorder_cnt2 = htonl((long) (stats->cntOutofOrder >> 32) ); + hdr->extend2.datagrams2 = htonl((long) (stats->cntDatagrams >> 32)); + } + // printf("****** Server final estimator %f calculated average %f\n", stats->jitter, (stats->inline_jitter.total.sum / stats->inline_jitter.total.cnt)); + if (stats->inline_jitter.total.cnt > 0) + stats->jitter = (stats->inline_jitter.total.sum / stats->inline_jitter.total.cnt); // overide the final estimator with an average + hdr->base.jitter1 = htonl((long) stats->jitter); + hdr->base.jitter2 = htonl((long) ((stats->jitter - (long)stats->jitter) * rMillion)); + + hdr->extend.minTransit1 = htonl((long) stats->transit.total.min); + hdr->extend.minTransit2 = htonl((long) ((stats->transit.total.min - (long)stats->transit.total.min) * rMillion)); + hdr->extend.maxTransit1 = htonl((long) stats->transit.total.max); + hdr->extend.maxTransit2 = htonl((long) ((stats->transit.total.max - (long)stats->transit.total.max) * rMillion)); + hdr->extend.sumTransit1 = htonl((long) stats->transit.total.sum); + hdr->extend.sumTransit2 = htonl((long) ((stats->transit.total.sum - (long)stats->transit.total.sum) * rMillion)); + hdr->extend.meanTransit1 = htonl((long) stats->transit.total.mean); + hdr->extend.meanTransit2 = htonl((long) ((stats->transit.total.mean - (long)stats->transit.total.mean) * rMillion)); + stats->transit.total.m2 *= 1e12; + hdr->extend.m2Transit1 = htonl((long) stats->transit.total.m2); + hdr->extend.m2Transit2 = htonl((long) ((stats->transit.total.m2 - (long)stats->transit.total.m2) * rMillion)); + hdr->extend.vdTransit1 = htonl((long) stats->transit.total.vd); + hdr->extend.vdTransit2 = htonl((long) ((stats->transit.total.vd - (long)stats->transit.total.vd) * rMillion)); + hdr->extend.cntTransit = htonl(stats->transit.total.cnt); + hdr->extend.cntIPG = htonl((long) (stats->cntDatagrams / (stats->ts.iEnd - stats->ts.iStart))); + hdr->extend.IPGsum = htonl(1); + +#define TRYCOUNT 10 + int count = TRYCOUNT; + while (--count) { + // write data +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + // If in l2mode, use the AF_INET socket to write this packet + // +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDP server send done-ack w/server-stats to client (sock=%d)", stats->common->socket); +#endif + rc = write(((stats->common->socketdrop > 0) ? stats->common->socketdrop : stats->common->socket), ackPacket, ackpacket_length); +#else + rc = write(stats->common->socket, ackPacket, ackpacket_length); +#endif + WARN_errno(rc < 0, "write-ackfin"); + // wait here is for silence, no more packets from the client + + FD_ZERO(&readSet); + FD_SET(stats->common->socket, &readSet); + timeout.tv_sec = 0; + timeout.tv_usec = 250000; + rc = select(stats->common->socket+1, &readSet, NULL, NULL, &timeout); + if (rc == 0) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDP server detected silence - server stats assumed received by client"); +#endif + success = 1; + break; + } + rc = read(stats->common->socket, ackPacket, readlen); + // WARN_errno(rc < 0, "ack await silence"); + if ((rc < 0) && FATALUDPREADERR(errno)) { + break; + } +#ifdef HAVE_THREAD_DEBUG + if (rc > 0) { + thread_debug("UDP server thinks server stats packet maybe lost, will retransmit and try again", rc); + } +#endif + } + free(ackPacket); + } + if (!success && (stats->common->ReportMode != kReport_CSV)) { + fprintf(stderr, warn_ack_failed, stats->common->socket); + } +} +// end write_UDP_AckFIN diff --git a/src/Server.cpp b/src/Server.cpp new file mode 100644 index 0000000..c271cd7 --- /dev/null +++ b/src/Server.cpp @@ -0,0 +1,946 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Server.cpp + * by Mark Gates <mgates@nlanr.net> + * Ajay Tirumala (tirumala@ncsa.uiuc.edu>. + * ------------------------------------------------------------------- + * A server thread is initiated for each connection accept() returns. + * Handles sending and receiving data, and then closes socket. + * Changes to this version : The server can be run as a daemon + * ------------------------------------------------------------------- */ + +#define HEADERS() + +#include "headers.h" +#include "Server.hpp" +#include "active_hosts.h" +#include "Extractor.h" +#include "Reporter.h" +#include "Locale.h" +#include "delay.h" +#include "PerfSocket.hpp" +#include "SocketAddr.h" +#include "payloads.h" +#include <cmath> +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) +#include "checksums.h" +#endif + + +/* ------------------------------------------------------------------- + * Stores connected socket and socket info. + * ------------------------------------------------------------------- */ + +Server::Server (thread_Settings *inSettings) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("Server constructor with thread=%p sum=%p (sock=%d)", (void *) inSettings, (void *)inSettings->mSumReport, inSettings->mSock); +#endif + mSettings = inSettings; + myJob = NULL; + reportstruct = &scratchpad; + memset(&scratchpad, 0, sizeof(struct ReportStruct)); + mySocket = inSettings->mSock; + peerclose = false; +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + myDropSocket = inSettings->mSockDrop; + if (isL2LengthCheck(mSettings)) { + // For L2 UDP make sure we can receive a full ethernet packet plus a bit more + if (mSettings->mBufLen < (2 * ETHER_MAX_LEN)) { + mSettings->mBufLen = (2 * ETHER_MAX_LEN); + } + } +#endif + // Enable kernel level timestamping if available + InitKernelTimeStamping(); + int sorcvtimer = 0; + // sorcvtimer units microseconds convert to that + // minterval double, units seconds + // mAmount integer, units 10 milliseconds + // divide by two so timeout is 1/2 the interval + if (mSettings->mInterval && (mSettings->mIntervalMode == kInterval_Time)) { + sorcvtimer = static_cast<int>(round(mSettings->mInterval / 2.0)); + } else if (isServerModeTime(mSettings)) { + sorcvtimer = static_cast<int>(round(mSettings->mAmount * 10000) / 2); + } + isburst = (isIsochronous(mSettings) || isPeriodicBurst(mSettings) || (isTripTime(mSettings) && !isUDP(mSettings))); + if (isburst && (mSettings->mFPS > 0.0)) { + sorcvtimer = static_cast<int>(round(2000000.0 / mSettings->mFPS)); + } + if (sorcvtimer > 0) { + SetSocketOptionsReceiveTimeout(mSettings, sorcvtimer); + } +} + +/* ------------------------------------------------------------------- + * Destructor close socket. + * ------------------------------------------------------------------- */ +Server::~Server () { +#if HAVE_THREAD_DEBUG + thread_debug("Server destructor sock=%d fullduplex=%s", mySocket, (isFullDuplex(mSettings) ? "true" : "false")); +#endif +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + if (myDropSocket != INVALID_SOCKET) { + int rc = close(myDropSocket); + WARN_errno(rc == SOCKET_ERROR, "server close drop"); + myDropSocket = INVALID_SOCKET; + } +#endif +} + +inline bool Server::InProgress () { + return !(sInterupted || peerclose || + ((isServerModeTime(mSettings) || (isModeTime(mSettings) && isReverse(mSettings))) && mEndTime.before(reportstruct->packetTime))); +} + +/* ------------------------------------------------------------------- + * Receive TCP data from the (connected) socket. + * Sends termination flag several times at the end. + * Does not close the socket. + * ------------------------------------------------------------------- */ +void Server::RunTCP () { + long currLen; + intmax_t totLen = 0; + struct TCP_burst_payload burst_info; // used to store burst header and report in last packet of burst + Timestamp time1, time2; + double tokens=0.000004; + + if (!InitTrafficLoop()) + return; + myReport->info.ts.prevsendTime = myReport->info.ts.startTime; + + int burst_nleft = 0; + burst_info.burst_id = 0; + burst_info.burst_period_us = 0; + burst_info.send_tt.write_tv_sec = 0; + burst_info.send_tt.write_tv_usec = 0; + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + while (InProgress()) { +// printf("***** bid expect = %u\n", burstid_expect); + reportstruct->emptyreport=1; + currLen = 0; + // perform read + if (isBWSet(mSettings)) { + time2.setnow(); + tokens += time2.subSec(time1) * (mSettings->mAppRate / 8.0); + time1 = time2; + } + reportstruct->transit_ready = 0; + if (tokens >= 0.0) { + int n = 0; + int readLen = mSettings->mBufLen; + if (burst_nleft > 0) + readLen = (mSettings->mBufLen < burst_nleft) ? mSettings->mBufLen : burst_nleft; + reportstruct->emptyreport=1; +#if HAVE_DECL_TCP_QUICKACK + if (isTcpQuickAck(mSettings)) { + int opt = 1; + Socklen_t len = sizeof(opt); + int rc = setsockopt(mySocket, IPPROTO_TCP, TCP_QUICKACK, + reinterpret_cast<char*>(&opt), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_QUICKACK"); + } +#endif + if (isburst && (burst_nleft == 0)) { + if ((n = recvn(mSettings->mSock, reinterpret_cast<char *>(&burst_info), sizeof(struct TCP_burst_payload), 0)) == sizeof(struct TCP_burst_payload)) { + // burst_info.typelen.type = ntohl(burst_info.typelen.type); + // burst_info.typelen.length = ntohl(burst_info.typelen.length); + // This is the first stamp of the burst + burst_info.flags = ntohl(burst_info.flags); + burst_info.burst_size = ntohl(burst_info.burst_size); + assert(burst_info.burst_size > 0); + reportstruct->burstsize = burst_info.burst_size; + burst_info.burst_id = ntohl(burst_info.burst_id); + reportstruct->frameID = burst_info.burst_id; + if (isTripTime(mSettings)) { + burst_info.send_tt.write_tv_sec = ntohl(burst_info.send_tt.write_tv_sec); + burst_info.send_tt.write_tv_usec = ntohl(burst_info.send_tt.write_tv_usec); + } else if (isIsochronous(mSettings)) { + burst_info.send_tt.write_tv_sec = (uint32_t)myReport->info.ts.startTime.tv_sec; + burst_info.send_tt.write_tv_usec = (uint32_t)myReport->info.ts.startTime.tv_usec; + burst_info.burst_period_us = ntohl(burst_info.burst_period_us); + } else { + now.setnow(); + burst_info.send_tt.write_tv_sec = (uint32_t)now.getSecs(); + burst_info.send_tt.write_tv_usec = (uint32_t)now.getUsecs(); + } + reportstruct->sentTime.tv_sec = burst_info.send_tt.write_tv_sec; + reportstruct->sentTime.tv_usec = burst_info.send_tt.write_tv_usec; + myReport->info.ts.prevsendTime = reportstruct->sentTime; + burst_nleft = burst_info.burst_size - n; + if (burst_nleft == 0) { + reportstruct->prevSentTime = myReport->info.ts.prevsendTime; + reportstruct->transit_ready = 1; + reportstruct->burstperiod = burst_info.burst_period_us; + } + currLen += n; + readLen = (mSettings->mBufLen < burst_nleft) ? mSettings->mBufLen : burst_nleft; + WARN(burst_nleft <= 0, "invalid burst read req size"); + // thread_debug("***read burst header size %d id=%d", burst_info.burst_size, burst_info.burst_id); + } else { + if (n > 0) { + WARN(1, "partial readn"); +#ifdef HAVE_THREAD_DEBUG + thread_debug("TCP burst partial read of %d wanted %d", n, sizeof(struct TCP_burst_payload)); + } else { + thread_debug("Detected peer close"); +#endif + } + goto Done; + } + } + if (!reportstruct->transit_ready) { + n = recv(mSettings->mSock, mSettings->mBuf, readLen, 0); + if (n > 0) { + reportstruct->emptyreport = 0; + if (isburst) { + burst_nleft -= n; + if (burst_nleft == 0) { + reportstruct->sentTime = myReport->info.ts.prevsendTime; + if (isTripTime(mSettings) || isIsochronous(mSettings)) { + reportstruct->isochStartTime.tv_sec = burst_info.send_tt.write_tv_sec; + reportstruct->isochStartTime.tv_usec = burst_info.send_tt.write_tv_usec; + reportstruct->burstperiod = burst_info.burst_period_us; + } + reportstruct->transit_ready = 1; + } + } + } else if (n == 0) { + peerclose = true; +#ifdef HAVE_THREAD_DEBUG + thread_debug("Server thread detected EOF on socket %d", mSettings->mSock); +#endif + } else if ((n < 0) && (FATALTCPREADERR(errno))) { + WARN_errno(1, "recv"); + peerclose = true; + n = 0; + } + currLen += n; + } + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + totLen += currLen; + if (isBWSet(mSettings)) + tokens -= currLen; + + reportstruct->packetLen = currLen; + ReportPacket(myReport, reportstruct); + // Check for reverse and amount where + // the server stops after receiving + // the expected byte count + if (isReverse(mSettings) && !isModeTime(mSettings) && (totLen >= static_cast<intmax_t>(mSettings->mAmount))) { + break; + } + } else { + // Use a 4 usec delay to fill tokens + delay_loop(4); + } + } + Done: + disarm_itimer(); + // stop timing + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->packetLen = 0; + if (EndJob(myJob, reportstruct)) { +#if HAVE_THREAD_DEBUG + thread_debug("tcp close sock=%d", mySocket); +#endif + int rc = close(mySocket); + WARN_errno(rc == SOCKET_ERROR, "server close"); + } + Iperf_remove_host(mSettings); + FreeReport(myJob); +} + +void Server::PostNullEvent () { + assert(myReport!=NULL); + // push a nonevent into the packet ring + // this will cause the reporter to process + // up to this event + memset(reportstruct, 0, sizeof(struct ReportStruct)); + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->emptyreport=1; + ReportPacket(myReport, reportstruct); +} + +inline bool Server::ReadBBWithRXTimestamp () { + bool rc = false; + int n; + while (1) { + if ((n = recvn(mySocket, mSettings->mBuf, mSettings->mBounceBackBytes, 0)) == mSettings->mBounceBackBytes) { + struct bounceback_hdr *bbhdr = reinterpret_cast<struct bounceback_hdr *>(mSettings->mBuf); + uint16_t bbflags = ntohs(bbhdr->bbflags); + if (!(bbflags & HEADER_BBSTOP)) { + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->emptyreport=0; + reportstruct->packetLen = mSettings->mBounceBackBytes; + // write the rx timestamp back into the payload + bbhdr->bbserverRx_ts.sec = htonl(reportstruct->packetTime.tv_sec); + bbhdr->bbserverRx_ts.usec = htonl(reportstruct->packetTime.tv_usec); + ReportPacket(myReport, reportstruct); + rc = true; + } else { + peerclose = true; + } + break; + } else if (n==0) { + peerclose = true; + break; + } else if (n == -2){ + PostNullEvent(); + } else { + break; + } + } + return rc; +} + +void Server::RunBounceBackTCP () { + if (!InitTrafficLoop()) + return; +#if HAVE_DECL_TCP_NODELAY + { + int nodelay = 1; + // set TCP nodelay option + int rc = setsockopt(mySocket, IPPROTO_TCP, TCP_NODELAY, + reinterpret_cast<char*>(&nodelay), sizeof(nodelay)); + WARN_errno(rc == SOCKET_ERROR, "setsockopt BB TCP_NODELAY"); + setNoDelay(mSettings); + } +#endif + if (mSettings->mInterval && (mSettings->mIntervalMode == kInterval_Time)) { + int sotimer = static_cast<int>(round(mSettings->mInterval / 2.0)); + SetSocketOptionsSendTimeout(mSettings, sotimer); + SetSocketOptionsReceiveTimeout(mSettings, sotimer); + } else if (isModeTime(mSettings)) { + int sotimer = static_cast<int>(round(mSettings->mAmount * 10000) / 2); + SetSocketOptionsSendTimeout(mSettings, sotimer); + SetSocketOptionsReceiveTimeout(mSettings, sotimer); + } + myReport->info.ts.prevsendTime = myReport->info.ts.startTime; + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->packetLen = mSettings->mBounceBackBytes; + reportstruct->emptyreport=0; + ReportPacket(myReport, reportstruct); + + while (InProgress()) { + int n; + reportstruct->emptyreport=1; + do { + struct bounceback_hdr *bbhdr = reinterpret_cast<struct bounceback_hdr *>(mSettings->mBuf); + if (mSettings->mBounceBackHold) { +#if HAVE_DECL_TCP_QUICKACK + if (isTcpQuickAck(mSettings)) { + int opt = 1; + Socklen_t len = sizeof(opt); + int rc = setsockopt(mySocket, IPPROTO_TCP, TCP_QUICKACK, + reinterpret_cast<char*>(&opt), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_QUICKACK"); + } +#endif + delay_loop(mSettings->mBounceBackHold); + } + now.setnow(); + bbhdr->bbserverTx_ts.sec = htonl(now.getSecs()); + bbhdr->bbserverTx_ts.usec = htonl(now.getUsecs()); + if (mSettings->mTOS) { + bbhdr->tos = htons((uint16_t)(mSettings->mTOS & 0xFF)); + } + if ((n = writen(mySocket, mSettings->mBuf, mSettings->mBounceBackBytes, &reportstruct->writecnt)) == mSettings->mBounceBackBytes) { + reportstruct->emptyreport=0; + reportstruct->packetLen = n; + ReportPacket(myReport, reportstruct); + } else { + break; + } + } while (ReadBBWithRXTimestamp()); + } + disarm_itimer(); + // stop timing + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + reportstruct->packetLen = 0; + if (EndJob(myJob, reportstruct)) { +#if HAVE_THREAD_DEBUG + thread_debug("tcp close sock=%d", mySocket); +#endif + int rc = close(mySocket); + WARN_errno(rc == SOCKET_ERROR, "server close"); + } + Iperf_remove_host(mSettings); + FreeReport(myJob); +} + +void Server::InitKernelTimeStamping () { +#if HAVE_DECL_SO_TIMESTAMP + iov[0].iov_base=mSettings->mBuf; + iov[0].iov_len=mSettings->mBufLen; + + message.msg_iov=iov; + message.msg_iovlen=1; + message.msg_name=&srcaddr; + message.msg_namelen=sizeof(srcaddr); + + message.msg_control = (char *) ctrl; + message.msg_controllen = sizeof(ctrl); + + int timestampOn = 1; + if (setsockopt(mSettings->mSock, SOL_SOCKET, SO_TIMESTAMP, ×tampOn, sizeof(timestampOn)) < 0) { + WARN_errno(mSettings->mSock == SO_TIMESTAMP, "socket"); + } +#endif +} + +// +// Set the report start times and next report times, options +// are now, the accept time or the first write time +// +inline void Server::SetFullDuplexReportStartTime () { + assert(myReport->FullDuplexReport != NULL); + struct TransferInfo *fullduplexstats = &myReport->FullDuplexReport->info; + assert(fullduplexstats != NULL); + if (TimeZero(fullduplexstats->ts.startTime)) { + fullduplexstats->ts.startTime = myReport->info.ts.startTime; + if (isModeTime(mSettings)) { + fullduplexstats->ts.nextTime = myReport->info.ts.nextTime; + } + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Server fullduplex report start=%ld.%ld next=%ld.%ld", fullduplexstats->ts.startTime.tv_sec, fullduplexstats->ts.startTime.tv_usec, fullduplexstats->ts.nextTime.tv_sec, fullduplexstats->ts.nextTime.tv_usec); +#endif +} + +inline void Server::SetReportStartTime () { + if (TimeZero(myReport->info.ts.startTime)) { + if (!TimeZero(mSettings->sent_time) && !isTxStartTime(mSettings)) { + // Servers that aren't full duplex use the accept timestamp for start + myReport->info.ts.startTime.tv_sec = mSettings->sent_time.tv_sec; + myReport->info.ts.startTime.tv_usec = mSettings->sent_time.tv_usec; + } else if (!TimeZero(mSettings->accept_time) && !isTxStartTime(mSettings)) { + // Servers that aren't full duplex use the accept timestamp for start + myReport->info.ts.startTime.tv_sec = mSettings->accept_time.tv_sec; + myReport->info.ts.startTime.tv_usec = mSettings->accept_time.tv_usec; + } else { + now.setnow(); + myReport->info.ts.startTime.tv_sec = now.getSecs(); + myReport->info.ts.startTime.tv_usec = now.getUsecs(); + } + } + myReport->info.ts.IPGstart = myReport->info.ts.startTime; + + if (!TimeZero(myReport->info.ts.intervalTime)) { + myReport->info.ts.nextTime = myReport->info.ts.startTime; + TimeAdd(myReport->info.ts.nextTime, myReport->info.ts.intervalTime); + } + if (myReport->GroupSumReport) { + struct TransferInfo *sumstats = &myReport->GroupSumReport->info; + assert(sumstats != NULL); + Mutex_Lock(&myReport->GroupSumReport->reference.lock); + if (TimeZero(sumstats->ts.startTime)) { + sumstats->ts.startTime = myReport->info.ts.startTime; + if (isModeTime(mSettings) || isModeInfinite(mSettings)) { + sumstats->ts.nextTime = myReport->info.ts.nextTime; + } + } + Mutex_Unlock(&myReport->GroupSumReport->reference.lock); + } +#ifdef HAVE_THREAD_DEBUG + thread_debug("Server(%d) report start=%ld.%ld next=%ld.%ld", mSettings->mSock, myReport->info.ts.startTime.tv_sec, myReport->info.ts.startTime.tv_usec, myReport->info.ts.nextTime.tv_sec, myReport->info.ts.nextTime.tv_usec); +#endif +} + +void Server::ClientReverseFirstRead (void) { + // Handle the case when the client spawns a server (no listener) and need the initial header + // Case of --trip-times and --reverse or --fullduplex, listener handles normal case + // Handle the case when the client spawns a server (no listener) and need the initial header + // Case of --trip-times and --reverse or --fullduplex, listener handles normal case + if (isReverse(mSettings) && (isTripTime(mSettings) || isPeriodicBurst(mSettings) || isIsochronous(mSettings))) { + int nread = 0; + uint32_t flags = 0; + int readlen = 0; + if (isUDP(mSettings)) { + nread = recvn(mSettings->mSock, mSettings->mBuf, mSettings->mBufLen, 0); + switch (nread) { + case 0: + //peer closed the socket, with no writes e.g. a connect-only test + peerclose = true; + break; + case -1 : + FAIL_errno(1, "recvn-reverse", mSettings); + break; + default : + struct client_udp_testhdr *udp_pkt = reinterpret_cast<struct client_udp_testhdr *>(mSettings->mBuf); + flags = ntohl(udp_pkt->base.flags); + mSettings->sent_time.tv_sec = 0; + if (isTripTime(mSettings)) { + mSettings->sent_time.tv_sec = ntohl(udp_pkt->start_fq.start_tv_sec); + mSettings->sent_time.tv_usec = ntohl(udp_pkt->start_fq.start_tv_usec); + } + if (!mSettings->sent_time.tv_sec) { + now.setnow(); + mSettings->sent_time.tv_sec = now.getSecs(); + mSettings->sent_time.tv_usec = now.getUsecs(); + } + reportstruct->packetLen = nread; + reportstruct->packetID = 1; + break; + } + } else { + nread = recvn(mSettings->mSock, mSettings->mBuf, sizeof(uint32_t), 0); + if (nread == 0) { + fprintf(stderr, "WARN: zero read on header flags\n"); + //peer closed the socket, with no writes e.g. a connect-only test + peerclose = true; + } + FAIL_errno((nread < (int) sizeof(uint32_t)), "client read tcp flags", mSettings); + reportstruct->packetID = 1; + struct client_tcp_testhdr *tcp_pkt = reinterpret_cast<struct client_tcp_testhdr *>(mSettings->mBuf); + flags = ntohl(tcp_pkt->base.flags); + // figure out the length of the test header + if ((readlen = Settings_ClientTestHdrLen(flags, mSettings)) > 0) { + // read the test settings passed to the mSettings by the client + int adj = (readlen - sizeof(uint32_t)); + nread = recvn(mSettings->mSock, (mSettings->mBuf + sizeof(uint32_t)), adj, 0); + if (nread == 0) { + peerclose = true; + } + FAIL_errno((nread < adj), "client read tcp test info", mSettings); + if (nread > 0) { + if (isTripTime(mSettings)) { + struct client_tcp_testhdr *tcp_pkt = reinterpret_cast<struct client_tcp_testhdr *>(mSettings->mBuf); + mSettings->sent_time.tv_sec = ntohl(tcp_pkt->start_fq.start_tv_sec); + mSettings->sent_time.tv_usec = ntohl(tcp_pkt->start_fq.start_tv_usec); + } else { + now.setnow(); + mSettings->sent_time.tv_sec = now.getSecs(); + mSettings->sent_time.tv_sec = now.getUsecs(); + } + } + mSettings->firstreadbytes = readlen; + } + } + } +} + +bool Server::InitTrafficLoop (void) { + bool UDPReady = true; + myJob = InitIndividualReport(mSettings); + myReport = static_cast<struct ReporterData *>(myJob->this_report); + assert(myJob != NULL); + if (mSettings->mReportMode == kReport_CSV) { + format_ips_port_string(&myReport->info, 0); + } + // copy the thread drop socket to this object such + // that the destructor can close it if needed +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + if (mSettings->mSockDrop > 0) + myDropSocket = mSettings->mSockDrop; +#endif + // Initialze the reportstruct scratchpad + reportstruct = &scratchpad; + reportstruct->packetID = 0; + reportstruct->l2len = 0; + reportstruct->l2errors = 0x0; + + int setfullduplexflag = 0; + if (isFullDuplex(mSettings) && !isServerReverse(mSettings)) { + assert(mSettings->mFullDuplexReport != NULL); + if ((setfullduplexflag = fullduplex_start_barrier(&mSettings->mFullDuplexReport->fullduplex_barrier)) < 0) + exit(-1); + } + Timestamp now; + if (isReverse(mSettings)) { + mSettings->accept_time.tv_sec = now.getSecs(); + mSettings->accept_time.tv_usec = now.getUsecs(); + ClientReverseFirstRead(); + } + if (isTripTime(mSettings)) { + if ((abs(now.getSecs() - mSettings->sent_time.tv_sec)) > MAXDIFFTIMESTAMPSECS) { + unsetTripTime(mSettings); + fprintf(stdout,"WARN: ignore --trip-times because client didn't provide valid start timestamp within %d seconds of now\n", MAXDIFFTIMESTAMPSECS); + mSettings->accept_time.tv_sec = now.getSecs(); + mSettings->accept_time.tv_usec = now.getUsecs(); + } + } + SetReportStartTime(); + reportstruct->prevPacketTime = myReport->info.ts.startTime; + + if (setfullduplexflag) + SetFullDuplexReportStartTime(); + + if (isServerModeTime(mSettings) || (isModeTime(mSettings) && (isBounceBack(mSettings) || isServerReverse(mSettings) || isFullDuplex(mSettings) || isReverse(mSettings)))) { + + if (isServerReverse(mSettings) || isFullDuplex(mSettings) || isReverse(mSettings)) + mSettings->mAmount += (SLOPSECS * 100); // add 2 sec for slop on reverse, units are 10 ms + + uintmax_t end_usecs (mSettings->mAmount * 10000); //amount units is 10 ms + if (int err = set_itimer(end_usecs)) + FAIL_errno(err != 0, "setitimer", mSettings); + mEndTime.setnow(); + mEndTime.add(mSettings->mAmount / 100.0); + } + if (!isSingleUDP(mSettings)) + PostReport(myJob); + // The first payload is different for TCP so read it and report it + // before entering the main loop + if (mSettings->firstreadbytes > 0) { + reportstruct->frameID = 0; + reportstruct->packetLen = mSettings->firstreadbytes; + if (isUDP(mSettings)) { + int offset = 0; + UDPReady = !ReadPacketID(offset); + reportstruct->packetTime = mSettings->accept_time; + } else { + reportstruct->sentTime.tv_sec = myReport->info.ts.startTime.tv_sec; + reportstruct->sentTime.tv_usec = myReport->info.ts.startTime.tv_usec; + reportstruct->packetTime = reportstruct->sentTime; + } + ReportPacket(myReport, reportstruct); + } + return UDPReady; +} + +inline int Server::ReadWithRxTimestamp () { + long currLen; + int tsdone = 0; + +#if HAVE_DECL_SO_TIMESTAMP + cmsg = reinterpret_cast<struct cmsghdr *>(&ctrl); + currLen = recvmsg(mSettings->mSock, &message, mSettings->recvflags); + if (currLen > 0) { + for (cmsg = CMSG_FIRSTHDR(&message); cmsg != NULL; + cmsg = CMSG_NXTHDR(&message, cmsg)) { + if (cmsg->cmsg_level == SOL_SOCKET && + cmsg->cmsg_type == SCM_TIMESTAMP && + cmsg->cmsg_len == CMSG_LEN(sizeof(struct timeval))) { + memcpy(&(reportstruct->packetTime), CMSG_DATA(cmsg), sizeof(struct timeval)); + tsdone = 1; + } + } + } +#else + currLen = recv(mSettings->mSock, mSettings->mBuf, mSettings->mBufLen, mSettings->recvflags); +#endif + if (currLen <=0) { + // Socket read timeout or read error + reportstruct->emptyreport=1; + if (currLen == 0) { + peerclose = true; + } else if (FATALUDPREADERR(errno)) { + WARN_errno(1, "recvmsg"); + currLen = 0; + peerclose = true; + } + } else if (TimeZero(myReport->info.ts.prevpacketTime)) { + myReport->info.ts.prevpacketTime = reportstruct->packetTime; + } + if (!tsdone) { + now.setnow(); + reportstruct->packetTime.tv_sec = now.getSecs(); + reportstruct->packetTime.tv_usec = now.getUsecs(); + } + return currLen; +} + +// Returns true if the client has indicated this is the final packet +inline bool Server::ReadPacketID (int offset_adjust) { + bool terminate = false; + struct UDP_datagram* mBuf_UDP = reinterpret_cast<struct UDP_datagram*>(mSettings->mBuf + offset_adjust); + // terminate when datagram begins with negative index + // the datagram ID should be correct, just negated + + if (isSeqNo64b(mSettings)) { + // New client - Signed PacketID packed into unsigned id2,id + reportstruct->packetID = (static_cast<uint32_t>(ntohl(mBuf_UDP->id))) | (static_cast<uintmax_t>(ntohl(mBuf_UDP->id2)) << 32); + +#ifdef HAVE_PACKET_DEBUG + printf("id 0x%x, 0x%x -> %" PRIdMAX " (0x%" PRIxMAX ")\n", + ntohl(mBuf_UDP->id), ntohl(mBuf_UDP->id2), reportstruct->packetID, reportstruct->packetID); +#endif + } else { + // Old client - Signed PacketID in Signed id + reportstruct->packetID = static_cast<int32_t>(ntohl(mBuf_UDP->id)); +#ifdef HAVE_PACKET_DEBUG + printf("id 0x%x -> %" PRIdMAX " (0x%" PRIxMAX ")\n", + ntohl(mBuf_UDP->id), reportstruct->packetID, reportstruct->packetID); +#endif + } + if (reportstruct->packetID < 0) { + reportstruct->packetID = - reportstruct->packetID; + terminate = true; + } + // read the sent timestamp from the rx packet + reportstruct->sentTime.tv_sec = ntohl(mBuf_UDP->tv_sec); + reportstruct->sentTime.tv_usec = ntohl(mBuf_UDP->tv_usec); + return terminate; +} + +void Server::L2_processing () { +#if (HAVE_LINUX_FILTER_H) && (HAVE_AF_PACKET) + eth_hdr = reinterpret_cast<struct ether_header *>(mSettings->mBuf); + ip_hdr = reinterpret_cast<struct iphdr *>(mSettings->mBuf + sizeof(struct ether_header)); + // L4 offest is set by the listener and depends upon IPv4 or IPv6 + udp_hdr = reinterpret_cast<struct udphdr *>(mSettings->mBuf + mSettings->l4offset); + // Read the packet to get the UDP length + int udplen = ntohs(udp_hdr->len); + // + // in the event of an L2 error, double check the packet before passing it to the reporter, + // i.e. no reason to run iperf accounting on a packet that has no reasonable L3 or L4 headers + // + reportstruct->packetLen = udplen - sizeof(struct udphdr); + reportstruct->expected_l2len = reportstruct->packetLen + mSettings->l4offset + sizeof(struct udphdr); + if (reportstruct->l2len != reportstruct->expected_l2len) { + reportstruct->l2errors |= L2LENERR; + if (L2_quintuple_filter() != 0) { + reportstruct->l2errors |= L2UNKNOWN; + reportstruct->l2errors |= L2CSUMERR; + reportstruct->emptyreport = 1; + } + } + if (!(reportstruct->l2errors & L2UNKNOWN)) { + // perform UDP checksum test, returns zero on success + int rc; + rc = udpchecksum((void *)ip_hdr, (void *)udp_hdr, udplen, (isIPV6(mSettings) ? 1 : 0)); + if (rc) { + reportstruct->l2errors |= L2CSUMERR; + if ((!(reportstruct->l2errors & L2LENERR)) && (L2_quintuple_filter() != 0)) { + reportstruct->emptyreport = 1; + reportstruct->l2errors |= L2UNKNOWN; + } + } + } +#endif // HAVE_AF_PACKET +} + +// Run the L2 packet through a quintuple check, i.e. proto/ip src/ip dst/src port/src dst +// and return zero is there is a match, otherwize return nonzero +int Server::L2_quintuple_filter () { +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + +#define IPV4SRCOFFSET 12 // the ipv4 source address offset from the l3 pdu +#define IPV6SRCOFFSET 8 // the ipv6 source address offset + + // Get the expected values from the sockaddr structures + // Note: it's expected the initiating socket has aready "connected" + // and the sockaddr structs have been populated + // 2nd Note: sockaddr structs are in network byte order + struct sockaddr *p = reinterpret_cast<sockaddr *>(&mSettings->peer); + struct sockaddr *l = reinterpret_cast<sockaddr *>(&mSettings->local); + // make sure sa_family is coherent for both src and dst + if (!(((l->sa_family == AF_INET) && (p->sa_family == AF_INET)) || ((l->sa_family == AF_INET6) && (p->sa_family == AF_INET6)))) { + return -1; + } + + // check the L2 ethertype + struct ether_header *l2hdr = reinterpret_cast<struct ether_header *>(mSettings->mBuf); + + if (!isIPV6(mSettings)) { + if (ntohs(l2hdr->ether_type) != ETHERTYPE_IP) + return -1; + } else { + if (ntohs(l2hdr->ether_type) != ETHERTYPE_IPV6) + return -1; + } + // check the ip src/dst + const uint32_t *data; + udp_hdr = reinterpret_cast<struct udphdr *>(mSettings->mBuf + mSettings->l4offset); + + // Check plain old v4 using v4 addr structs + if (l->sa_family == AF_INET) { + data = reinterpret_cast<const uint32_t *>(mSettings->mBuf + sizeof(struct ether_header) + IPV4SRCOFFSET); + if ((reinterpret_cast<struct sockaddr_in *>(p))->sin_addr.s_addr != *data++) + return -1; + if ((reinterpret_cast<struct sockaddr_in *>(l))->sin_addr.s_addr != *data) + return -1; + if (udp_hdr->source != (reinterpret_cast<struct sockaddr_in *>(p))->sin_port) + return -1; + if (udp_hdr->dest != (reinterpret_cast<struct sockaddr_in *>(l))->sin_port) + return -1; + } else { + // Using the v6 addr structures +# if HAVE_IPV6 + struct in6_addr *v6peer = SockAddr_get_in6_addr(&mSettings->peer); + struct in6_addr *v6local = SockAddr_get_in6_addr(&mSettings->local); + if (isIPV6(mSettings)) { + int i; + data = reinterpret_cast<const uint32_t *>(mSettings->mBuf + sizeof(struct ether_header) + IPV6SRCOFFSET); + // check for v6 src/dst address match + for (i = 0; i < 4; i++) { + if (v6peer->s6_addr32[i] != *data++) + return -1; + } + for (i = 0; i < 4; i++) { + if (v6local->s6_addr32[i] != *data++) + return -1; + } + } else { // v4 addr in v6 family struct + data = reinterpret_cast<const uint32_t *>(mSettings->mBuf + sizeof(struct ether_header) + IPV4SRCOFFSET); + if (v6peer->s6_addr32[3] != *data++) + return -1; + if (v6peer->s6_addr32[3] != *data) + return -1; + } + // check udp ports + if (udp_hdr->source != (reinterpret_cast<struct sockaddr_in6 *>(p))->sin6_port) + return -1; + if (udp_hdr->dest != (reinterpret_cast<struct sockaddr_in6 *>(l))->sin6_port) + return -1; +# endif // HAVE_IPV6 + } +#endif // HAVE_AF_PACKET + // made it through all the checks + return 0; +} + +inline void Server::udp_isoch_processing (int rxlen) { + reportstruct->transit_ready = 0; + // Ignore runt sized isoch packets + if (rxlen < static_cast<int>(sizeof(struct UDP_datagram) + sizeof(struct client_hdr_v1) + sizeof(struct client_hdrext) + sizeof(struct isoch_payload))) { + reportstruct->burstsize = 0; + reportstruct->remaining = 0; + reportstruct->frameID = 0; + } else { + struct client_udp_testhdr *udp_pkt = reinterpret_cast<struct client_udp_testhdr *>(mSettings->mBuf); + reportstruct->isochStartTime.tv_sec = ntohl(udp_pkt->isoch.start_tv_sec); + reportstruct->isochStartTime.tv_usec = ntohl(udp_pkt->isoch.start_tv_usec); + reportstruct->frameID = ntohl(udp_pkt->isoch.frameid); + reportstruct->prevframeID = ntohl(udp_pkt->isoch.prevframeid); + reportstruct->burstsize = ntohl(udp_pkt->isoch.burstsize); + assert(reportstruct->burstsize > 0); + reportstruct->burstperiod = ntohl(udp_pkt->isoch.burstperiod); + reportstruct->remaining = ntohl(udp_pkt->isoch.remaining); + if ((reportstruct->remaining == (uint32_t) rxlen) && ((reportstruct->frameID - reportstruct->prevframeID) == 1)) { + reportstruct->transit_ready = 1; + } + } +} + +/* ------------------------------------------------------------------- + * Receive UDP data from the (connected) socket. + * Sends termination flag several times at the end. + * Does not close the socket. + * ------------------------------------------------------------------- */ +void Server::RunUDP () { + int rxlen; + bool isLastPacket = false; + + if (InitTrafficLoop()) { + // Exit loop on three conditions + // 1) Fatal read error + // 2) Last packet of traffic flow sent by client + // 3) -t timer expires + while (InProgress() && !isLastPacket) { + // The emptyreport flag can be set + // by any of the packet processing routines + // If it's set the iperf reporter won't do + // bandwidth accounting, basically it's indicating + // that the reportstruct itself couldn't be + // completely filled out. + reportstruct->emptyreport=1; + reportstruct->packetLen=0; + // read the next packet with timestamp + // will also set empty report or not + rxlen=ReadWithRxTimestamp(); + if (!peerclose && (rxlen > 0)) { + reportstruct->emptyreport = 0; + reportstruct->packetLen = rxlen; + if (isL2LengthCheck(mSettings)) { + reportstruct->l2len = rxlen; + // L2 processing will set the reportstruct packet length with the length found in the udp header + // and also set the expected length in the report struct. The reporter thread + // will do the compare and account and print l2 errors + reportstruct->l2errors = 0x0; + L2_processing(); + } + if (!(reportstruct->l2errors & L2UNKNOWN)) { + // ReadPacketID returns true if this is the last UDP packet sent by the client + // also sets the packet rx time in the reportstruct + reportstruct->prevSentTime = myReport->info.ts.prevsendTime; + reportstruct->prevPacketTime = myReport->info.ts.prevpacketTime; + isLastPacket = ReadPacketID(mSettings->l4payloadoffset); + myReport->info.ts.prevsendTime = reportstruct->sentTime; + myReport->info.ts.prevpacketTime = reportstruct->packetTime; + if (isIsochronous(mSettings)) { + udp_isoch_processing(rxlen); + } + } + } + ReportPacket(myReport, reportstruct); + } + } + disarm_itimer(); + int do_close = EndJob(myJob, reportstruct); + if (!isMulticast(mSettings) && !isNoUDPfin(mSettings)) { + // send a UDP acknowledgement back except when: + // 1) we're NOT receiving multicast + // 2) the user requested no final exchange + // 3) this is a full duplex test + write_UDP_AckFIN(&myReport->info, mSettings->mBufLen); + } + if (do_close) { +#if HAVE_THREAD_DEBUG + thread_debug("udp close sock=%d", mySocket); +#endif + int rc = close(mySocket); + WARN_errno(rc == SOCKET_ERROR, "server close"); + } + Iperf_remove_host(mSettings); + FreeReport(myJob); +} + +// end Recv diff --git a/src/Settings.cpp b/src/Settings.cpp new file mode 100644 index 0000000..39229f5 --- /dev/null +++ b/src/Settings.cpp @@ -0,0 +1,2577 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Settings.cpp + * by Mark Gates <mgates@nlanr.net> + * & Ajay Tirumala <tirumala@ncsa.uiuc.edu> + * ------------------------------------------------------------------- + * Stores and parses the initial values for all the global variables. + * ------------------------------------------------------------------- + * headers + * uses + * <stdlib.h> + * <stdio.h> + * <string.h> + * + * <unistd.h> + * ------------------------------------------------------------------- */ + +#define HEADERS() + +#include "headers.h" +#include "Settings.hpp" +#include "Locale.h" +#include "SocketAddr.h" +#include "util.h" +#include "version.h" +#include "gnu_getopt.h" +#include "isochronous.hpp" +#include "pdfs.h" +#include "payloads.h" +#include "PerfSocket.hpp" +#include "dscp.h" +#include "iperf_formattime.h" +#include <math.h> + +static int reversetest = 0; +static int fullduplextest = 0; +static int histogram = 0; +static int jitter_histogram = 0; +static int l2checks = 0; +static int incrdstip = 0; +static int incrsrcip = 0; +static int incrdstport = 0; +static int incrsrcport = 0; +static int sumdstip = 0; +static int txstarttime = 0; +static int noconnectsync = 0; +static int txholdback = 0; +static int fqrate = 0; +static int triptime = 0; +static int infinitetime = 0; +static int connectonly = 0; +static int connectretry = 0; +static int burstipg = 0; +static int burstsize = 0; +static int burstperiodic = 0; +static int isochronous = 0; +static int noudpfin = 0; +static int numreportstructs = 0; +static int sumonly = 0; +static int so_dontroute = 0; +static int nearcongest = 0; +static int permitkey = 0; +static int permitkeytimeout = 0; +static int rxwinclamp = 0; +static int txnotsentlowwater = 0; +static int tapif = 0; +static int tunif = 0; +static int hideips = 0; +static int bounceback = 0; +static int bouncebackhold = 0; +static int bouncebackperiod = 0; +static int overridetos = 0; +static int notcpbbquickack = 0; +static int tcpquickack = 0; +static int notcpbbquickack_cliset = 0; +static int workingload = 0; +static int utctimes = 0; +static int bouncebackdelaystart = 0; +static int tcpwritetimes = 0; + +void Settings_Interpret(char option, const char *optarg, struct thread_Settings *mExtSettings); +// apply compound settings after the command line has been fully parsed +void Settings_ModalOptions(struct thread_Settings *mExtSettings); + +static void generate_permit_key(struct thread_Settings *mExtSettings); + +/* ------------------------------------------------------------------- + * command line options + * + * The option struct essentially maps a long option name (--foobar) + * or environment variable ($FOOBAR) to its short option char (f). + * ------------------------------------------------------------------- */ +#define LONG_OPTIONS() + +const struct option long_options[] = +{ +{"singleclient", no_argument, NULL, '1'}, +#if 0 +{"v4", no_argument, NULL, '4'}, +{"v6", no_argument, NULL, '6'}, +#endif +{"bandwidth", required_argument, NULL, 'b'}, +{"client", required_argument, NULL, 'c'}, +{"dualtest", no_argument, NULL, 'd'}, +{"enhanced", no_argument, NULL, 'e'}, +{"format", required_argument, NULL, 'f'}, +{"help", no_argument, NULL, 'h'}, +{"interval", required_argument, NULL, 'i'}, +{"len", required_argument, NULL, 'l'}, +{"print_mss", no_argument, NULL, 'm'}, +{"num", required_argument, NULL, 'n'}, +{"output", required_argument, NULL, 'o'}, +{"port", required_argument, NULL, 'p'}, +{"tradeoff", no_argument, NULL, 'r'}, +{"server", no_argument, NULL, 's'}, +{"time", required_argument, NULL, 't'}, +{"udp", no_argument, NULL, 'u'}, +{"version", no_argument, NULL, 'v'}, +{"window", required_argument, NULL, 'w'}, +{"reportexclude", required_argument, NULL, 'x'}, +{"reportstyle",required_argument, NULL, 'y'}, +{"realtime", no_argument, NULL, 'z'}, + +// more esoteric options +{"awdl", no_argument, NULL, 'A'}, +{"bind", required_argument, NULL, 'B'}, +{"bounceback", optional_argument, &bounceback, 1}, +{"bounceback-txdelay", required_argument, &bouncebackdelaystart, 1}, +{"bounceback-hold", required_argument, &bouncebackhold, 1}, +{"bounceback-no-quickack", no_argument, ¬cpbbquickack, 1}, +{"bounceback-period", required_argument, &bouncebackperiod, 1}, +{"compatibility", no_argument, NULL, 'C'}, +{"daemon", no_argument, NULL, 'D'}, +{"file_input", required_argument, NULL, 'F'}, +{"ssm-host", required_argument, NULL, 'H'}, +{"stdin_input", no_argument, NULL, 'I'}, +{"mss", required_argument, NULL, 'M'}, +{"nodelay", no_argument, NULL, 'N'}, +{"listenport", required_argument, NULL, 'L'}, +{"parallel", required_argument, NULL, 'P'}, +#ifdef WIN32 +{"remove", no_argument, NULL, 'R'}, +#else +{"reverse", no_argument, NULL, 'R'}, +#endif +{"tos", required_argument, NULL, 'S'}, +{"ttl", required_argument, NULL, 'T'}, +{"single_udp", no_argument, NULL, 'U'}, +{"ipv6_domain", no_argument, NULL, 'V'}, +{"suggest_win_size", no_argument, NULL, 'W'}, +{"peer-detect", no_argument, NULL, 'X'}, +{"tcp-congestion", required_argument, NULL, 'Z'}, +{"histograms", optional_argument, &histogram, 1}, +{"hide-ips", no_argument, &hideips, 1}, +{"jitter-histograms", optional_argument, &jitter_histogram, 1}, +{"udp-histograms", optional_argument, &histogram, 1}, // keep support per 2.0.13 usage +{"l2checks", no_argument, &l2checks, 1}, +{"incr-dstip", no_argument, &incrdstip, 1}, +{"incr-srcip", no_argument, &incrsrcip, 1}, +{"incr-dstport", no_argument, &incrdstport, 1}, +{"incr-srcport", no_argument, &incrsrcport, 1}, +{"sum-dstip", no_argument, &sumdstip, 1}, +{"txstart-time", required_argument, &txstarttime, 1}, +{"txdelay-time", required_argument, &txholdback, 1}, +{"fq-rate", required_argument, &fqrate, 1}, +{"trip-times", no_argument, &triptime, 1}, +{"no-udp-fin", no_argument, &noudpfin, 1}, +{"connect-only", optional_argument, &connectonly, 1}, +{"connect-retries", required_argument, &connectretry, 1}, +{"no-connect-sync", no_argument, &noconnectsync, 1}, +{"full-duplex", no_argument, &fullduplextest, 1}, +{"ipg", required_argument, &burstipg, 1}, +{"isochronous", optional_argument, &isochronous, 1}, +{"sum-only", no_argument, &sumonly, 1}, +{"local-only", optional_argument, &so_dontroute, 1}, +{"near-congestion", optional_argument, &nearcongest, 1}, +{"permit-key", optional_argument, &permitkey, 1}, +{"permit-key-timeout", required_argument, &permitkeytimeout, 1}, +{"burst-size", required_argument, &burstsize, 1}, +{"burst-period", required_argument, &burstperiodic, 1}, +{"tos-override", required_argument, &overridetos, 1}, +{"tcp-rx-window-clamp", required_argument, &rxwinclamp, 1}, +{"tcp-quickack", no_argument, &tcpquickack, 1}, +{"tcp-write-prefetch", required_argument, &txnotsentlowwater, 1}, // see doc/DESIGN_NOTES +{"tcp-write-times", no_argument, &tcpwritetimes, 1}, +{"tap-dev", optional_argument, &tapif, 1}, +{"tun-dev", optional_argument, &tunif, 1}, +{"working-load", optional_argument, &workingload, 1}, +{"utc", no_argument, &utctimes, 1}, +{"NUM_REPORT_STRUCTS", required_argument, &numreportstructs, 1}, +#ifdef WIN32 +{"reverse", no_argument, &reversetest, 1}, +#endif +{0, 0, 0, 0} +}; + +#define ENV_OPTIONS() + +const struct option env_options[] = +{ +{"IPERF_IPV6_DOMAIN", no_argument, NULL, 'V'}, +{"IPERF_SINGLECLIENT", no_argument, NULL, '1'}, +{"IPERF_BANDWIDTH", required_argument, NULL, 'b'}, +{"IPERF_CLIENT", required_argument, NULL, 'c'}, +{"IPERF_DUALTEST", no_argument, NULL, 'd'}, +{"IPERF_ENHANCEDREPORTS", no_argument, NULL, 'e'}, +{"IPERF_FORMAT", required_argument, NULL, 'f'}, +// skip help +{"IPERF_INTERVAL", required_argument, NULL, 'i'}, +{"IPERF_LEN", required_argument, NULL, 'l'}, +{"IPERF_PRINT_MSS", no_argument, NULL, 'm'}, +{"IPERF_NUM", required_argument, NULL, 'n'}, +{"IPERF_PORT", required_argument, NULL, 'p'}, +{"IPERF_TRADEOFF", no_argument, NULL, 'r'}, +{"IPERF_SERVER", no_argument, NULL, 's'}, +{"IPERF_TIME", required_argument, NULL, 't'}, +{"IPERF_UDP", no_argument, NULL, 'u'}, +// skip version +{"TCP_WINDOW_SIZE", required_argument, NULL, 'w'}, +{"IPERF_REPORTEXCLUDE", required_argument, NULL, 'x'}, +{"IPERF_REPORTSTYLE",required_argument, NULL, 'y'}, + +// more esoteric options +{"IPERF_BIND", required_argument, NULL, 'B'}, +{"IPERF_COMPAT", no_argument, NULL, 'C'}, +{"IPERF_DAEMON", no_argument, NULL, 'D'}, +{"IPERF_FILE_INPUT", required_argument, NULL, 'F'}, +{"IPERF_STDIN_INPUT", no_argument, NULL, 'I'}, +{"IPERF_MSS", required_argument, NULL, 'M'}, +{"IPERF_NODELAY", no_argument, NULL, 'N'}, +{"IPERF_LISTENPORT", required_argument, NULL, 'L'}, +{"IPERF_PARALLEL", required_argument, NULL, 'P'}, +{"IPERF_TOS", required_argument, NULL, 'S'}, +{"IPERF_TTL", required_argument, NULL, 'T'}, +{"IPERF_SINGLE_UDP", no_argument, NULL, 'U'}, +{"IPERF_SUGGEST_WIN_SIZE", required_argument, NULL, 'W'}, +{"IPERF_PEER_DETECT", no_argument, NULL, 'X'}, +{"IPERF_CONGESTION_CONTROL", required_argument, NULL, 'Z'}, +{0, 0, 0, 0} +}; + +#define SHORT_OPTIONS() + +const char short_options[] = "146b:c:def:hi:l:mn:o:p:rst:uvw:x:y:zAB:CDF:H:IL:M:NP:RS:T:UVWXZ:"; + +/* ------------------------------------------------------------------- + * defaults + * ------------------------------------------------------------------- */ +#define DEFAULTS() + +const long kDefault_UDPRate = 1024 * 1024; // -u if set, 1 Mbit/sec +const int kDefault_TCPBufLen = 128 * 1024; // TCP default read/write size +const int kDefault_BBTCPBufLen = 100; // default bounce-back size in bytes + + +/* ------------------------------------------------------------------- + * Initialize all settings to defaults. + * ------------------------------------------------------------------- */ +void Settings_Initialize (struct thread_Settings *main) { + // Everything defaults to zero or NULL with + // this memset. Only need to set non-zero values + // below. + memset(main, 0, sizeof(struct thread_Settings)); + main->mSock = INVALID_SOCKET; + main->mReportMode = kReport_Default; + // option, defaults + main->flags = FLAG_MODETIME | FLAG_STDOUT; // Default time and stdout + main->flags_extend = 0x0; // Default all extend flags to off + main->flags_extend2 = 0x0; // Default all extend flags to off + //main->mAppRate = 0; // -b, offered (or rate limited) load (both UDP and TCP) + main->mAppRateUnits = kRate_BW; + //main->mHost = NULL; // -c, none, required for client + main->mMode = kTest_Normal; // -d, mMode == kTest_DualTest + main->mFormat = 'a'; // -f, adaptive bits + // skip help // -h, + //main->mBufLenSet = false; // -l, + main->mBufLen = kDefault_TCPBufLen; // -l, Default to TCP read/write size + //main->mInterval = 0; // -i, ie. no periodic bw reports + //main->mPrintMSS = false; // -m, don't print MSS + // mAmount is time also // -n, N/A + //main->mOutputFileName = NULL; // -o, filename + main->mPort = 5001; // -p, ttcp port + main->mBindPort = 0; // -B, default port for bind + // mMode = kTest_Normal; // -r, mMode == kTest_TradeOff + main->mThreadMode = kMode_Unknown; // -s, or -c, none + main->mAmount = 1000; // -t, 10 seconds, units is 10 ms + main->mIntervalMode = kInterval_None;// -i none, time, packets, or bursts + // skip version // -v, + //main->mTCPWin = 0; // -w, ie. don't set window + + // more esoteric options + //main->mLocalhost = NULL; // -B, none + //main->mCompat = false; // -C, run in Compatibility mode + //main->mDaemon = false; // -D, run as a daemon + //main->mFileInput = false; // -F, + //main->mFileName = NULL; // -F, filename + //main->mStdin = false; // -I, default not stdin + //main->mListenPort = 0; // -L, listen port + //main->mMSS = 0; // -M, ie. don't set MSS + //main->mNodelay = false; // -N, don't set nodelay + //main->mThreads = 0; // -P, + //main->mRemoveService = false; // -R, + //main->mTOS = 0; // -S, ie. don't set type of service + main->mTTL = -1; // -T, link-local TTL + //main->mDomain = kMode_IPv4; // -V, + //main->mSuggestWin = false; // -W, Suggest the window size. + main->mListenerTimeout = -1; // + main->mKeyCheck = true; +#if defined(HAVE_DECL_SO_DONTROUTE) && defined(HAVE_DEFAULT_DONTROUTE_ON) + setDontRoute(main); +#endif + main->mFPS = 1; +} // end Settings + +void Settings_Copy (struct thread_Settings *from, struct thread_Settings **into, int copyall) { + *into = new struct thread_Settings; + memset(*into, 0, sizeof(struct thread_Settings)); + memcpy(*into, from, sizeof(struct thread_Settings)); + (*into)->mSumReport = NULL; + (*into)->mTransferIDStr = NULL; + +#ifdef HAVE_THREAD_DEBUG + thread_debug("Copy thread settings (malloc) from/to=%p/%p report/sum/fullduplex %p/%p/%p", \ + (void *)from, (void *)*into, (void *)(*into)->reporthdr, (void *)(*into)->mSumReport, (void *)(*into)->mFullDuplexReport); +#endif + // Some settings don't need to be copied and will confuse things. Don't copy them unless copyall is set + if (copyall) { + // Don't allocate memory for these if this is a reverse client + if (from->mHost != NULL) { + (*into)->mHost = new char[strlen(from->mHost) + 1]; + strcpy((*into)->mHost, from->mHost); + } + if (from->mOutputFileName != NULL) { + (*into)->mOutputFileName = new char[strlen(from->mOutputFileName) + 1]; + strcpy((*into)->mOutputFileName, from->mOutputFileName); + } + if (from->mLocalhost != NULL) { + (*into)->mLocalhost = new char[strlen(from->mLocalhost) + 1]; + strcpy((*into)->mLocalhost, from->mLocalhost); + } + if (from->mFileName != NULL) { + (*into)->mFileName = new char[strlen(from->mFileName) + 1]; + strcpy((*into)->mFileName, from->mFileName); + } + if (from->mHistogramStr != NULL) { + (*into)->mHistogramStr = new char[strlen(from->mHistogramStr) + 1]; + strcpy((*into)->mHistogramStr, from->mHistogramStr); + } + if (from->mSSMMulticastStr != NULL) { + (*into)->mSSMMulticastStr = new char[strlen(from->mSSMMulticastStr) + 1]; + strcpy((*into)->mSSMMulticastStr, from->mSSMMulticastStr); + } + if (from->mIfrname != NULL) { + (*into)->mIfrname = static_cast<char *>(calloc(strlen(from->mIfrname) + 1, sizeof(char))); + strcpy((*into)->mIfrname, from->mIfrname); + } + if (from->mIfrnametx != NULL) { + (*into)->mIfrnametx = static_cast<char *>(calloc(strlen(from->mIfrnametx) + 1, sizeof(char))); + strcpy((*into)->mIfrnametx, from->mIfrnametx); + } + if (from->mIsochronousStr != NULL) { + (*into)->mIsochronousStr = new char[strlen(from->mIsochronousStr) + 1]; + strcpy((*into)->mIsochronousStr, from->mIsochronousStr); + } + if (from->mHideHost != NULL) { + (*into)->mHideHost = new char[strlen(from->mHideHost) + 1]; + strcpy((*into)->mHideHost, from->mHideHost); + } + if (from->mCongestion != NULL) { + (*into)->mCongestion = new char[strlen(from->mCongestion) + 1]; + strcpy((*into)->mCongestion, from->mCongestion); + } + } else { + (*into)->mHost = NULL; + (*into)->mOutputFileName = NULL; + (*into)->mLocalhost = NULL; + (*into)->mFileName = NULL; + (*into)->mHistogramStr = NULL; + (*into)->mSSMMulticastStr = NULL; + (*into)->mIfrname = NULL; + (*into)->mIfrnametx = NULL; + (*into)->mIsochronousStr = NULL; + (*into)->mCongestion = NULL; + // apply the server side congestion setting to reverse clients + if (from->mIsochronousStr != NULL) { + (*into)->mIsochronousStr = new char[strlen(from->mIsochronousStr) + 1]; + strcpy((*into)->mIsochronousStr, from->mIsochronousStr); + } + } + + (*into)->txstart_epoch = from->txstart_epoch; + (*into)->mSumReport = from->mSumReport; + (*into)->mFullDuplexReport = from->mFullDuplexReport; + + // Zero out certain entries + (*into)->mTID = thread_zeroid(); + (*into)->runNext = NULL; + (*into)->runNow = NULL; +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + (*into)->mSockDrop = INVALID_SOCKET; +#endif + int mbuflen = (from->mBufLen > MINMBUFALLOCSIZE) ? from->mBufLen : MINMBUFALLOCSIZE; // defined in payloads.h +#if (((HAVE_TUNTAP_TUN) || (HAVE_TUNTAP_TAP)) && (AF_PACKET)) + mbuflen += TAPBYTESSLOP; +#endif + (*into)->mBuf = new char[mbuflen]; + memset((*into)->mBuf, 0, mbuflen); + +#ifdef HAVE_THREAD_DEBUG + thread_debug("Copy Settings: MBUF malloc %d bytes (%p)", mbuflen, (void *) (*into)->mBuf); +#endif + Condition_Initialize(&(*into)->awake_me); + // default copied settings to no reporter reporting + unsetReport((*into)); +} + +/* ------------------------------------------------------------------- + * Delete memory: Does not clean up open file pointers or ptr_parents + * ------------------------------------------------------------------- */ + +void Settings_Destroy (struct thread_Settings *mSettings) { +#if HAVE_THREAD_DEBUG + thread_debug("Free thread settings=%p", mSettings); +#endif + if (mSettings->tuntapdev) + close(mSettings->tuntapdev); + Condition_Destroy(&mSettings->awake_me); + DELETE_ARRAY(mSettings->mHost); + DELETE_ARRAY(mSettings->mHideHost); + DELETE_ARRAY(mSettings->mLocalhost); + DELETE_ARRAY(mSettings->mFileName); + DELETE_ARRAY(mSettings->mOutputFileName); + DELETE_ARRAY(mSettings->mHistogramStr); + DELETE_ARRAY(mSettings->mSSMMulticastStr); + DELETE_ARRAY(mSettings->mCongestion); + FREE_ARRAY(mSettings->mIfrname); + FREE_ARRAY(mSettings->mIfrnametx); + FREE_ARRAY(mSettings->mTransferIDStr); + DELETE_ARRAY(mSettings->mIsochronousStr); + DELETE_ARRAY(mSettings->mBuf); + DELETE_PTR(mSettings); +} // end ~Settings + +/* ------------------------------------------------------------------- + * Parses settings from user's environment variables. + * ------------------------------------------------------------------- */ +void Settings_ParseEnvironment (struct thread_Settings *mSettings) { + char *theVariable; + + int i = 0; + while (env_options[i].name != NULL) { + theVariable = getenv(env_options[i].name); + if (theVariable != NULL) { + Settings_Interpret(env_options[i].val, theVariable, mSettings); + } + i++; + } +} // end ParseEnvironment + +/* ------------------------------------------------------------------- + * Parse settings from app's command line. + * ------------------------------------------------------------------- */ + +void Settings_ParseCommandLine (int argc, char **argv, struct thread_Settings *mSettings) { + int option; + gnu_opterr = 1; // Fail on an unrecognized command line option + while ((option = + gnu_getopt_long(argc, argv, short_options, + long_options, NULL)) != EOF) { + Settings_Interpret(option, gnu_optarg, mSettings); + } + + for (int i = gnu_optind; i < argc; i++) { + fprintf(stderr, "%s: ignoring extra argument -- %s\n", argv[0], argv[i]); + } + // Determine the modal or compound settings now that the full command line has been parsed + Settings_ModalOptions(mSettings); + +} // end ParseCommandLine + +/* ------------------------------------------------------------------- + * Interpret individual options, either from the command line + * or from environment variables. + * ------------------------------------------------------------------- */ + +void Settings_Interpret (char option, const char *optarg, struct thread_Settings *mExtSettings) { + char *results; + switch (option) { + case '1': // Single Client + setSingleClient(mExtSettings); + break; + + case '4': // v4 only + setIPV4(mExtSettings); + break; + + case '6': // v6 only + setIPV6(mExtSettings); + break; + + case 'b': // UDP bandwidth + { + char *tmp= new char [strlen(optarg) + 1]; + strcpy(tmp, optarg); + // scan for PPS units, just look for 'p' as that's good enough + if ((((results = strtok(tmp, "p")) != NULL) && strcmp(results,optarg) != 0) \ + || (((results = strtok(tmp, "P")) != NULL) && strcmp(results,optarg) != 0)) { + mExtSettings->mAppRateUnits = kRate_PPS; + mExtSettings->mAppRate = byte_atoi(results); + } else { + mExtSettings->mAppRateUnits = kRate_BW; + mExtSettings->mAppRate = byte_atoi(optarg); + if (((results = strtok(tmp, ",")) != NULL) && strcmp(results,optarg) != 0) { + setVaryLoad(mExtSettings); + mExtSettings->mVariance = byte_atoi(optarg); + } + } + delete [] tmp; + } + setBWSet(mExtSettings); + break; + case 'c': // client mode w/ server host to connect to + mExtSettings->mHost = new char[strlen(optarg) + 1 ]; + strcpy(mExtSettings->mHost, optarg); + + if (mExtSettings->mThreadMode == kMode_Unknown) { + mExtSettings->mThreadMode = kMode_Client; + mExtSettings->mThreads = 1; + } + break; + + case 'd': // Dual-test Mode + if (mExtSettings->mThreadMode != kMode_Client) { + fprintf(stderr, warn_invalid_server_option, option); + break; + } + if (isCompat(mExtSettings)) { + fprintf(stderr, warn_invalid_compatibility_option, option); + } +#ifdef HAVE_THREAD + mExtSettings->mMode = kTest_DualTest; +#else + fprintf(stderr, warn_invalid_single_threaded, option); + mExtSettings->mMode = kTest_TradeOff; +#endif + break; + case 'e': // Use enhanced reports + setEnhanced(mExtSettings); + break; + case 'f': // format to print in + mExtSettings->mFormat = (*optarg); + break; + + case 'h': // print help and exit + fprintf(stdout, "%s", usage_long1); + fprintf(stdout, "%s", usage_long2); + exit(0); + break; + + case 'i': // specify interval between periodic bw reports + { + char framechar; + char *tmp= new char [strlen(optarg) + 1]; + strcpy(tmp, optarg); + // scan for frames as units + if ((sscanf(optarg,"%c", &framechar)) && ((framechar == 'f') || (framechar == 'F'))) { + mExtSettings->mIntervalMode = kInterval_Frames; + setEnhanced(mExtSettings); + setFrameInterval(mExtSettings); + } else { + char *end; + strcpy(tmp, optarg); + double itime = strtof(optarg, &end); + if (*end != '\0') { + fprintf (stderr, "Invalid value of '%s' for -i interval\n", optarg); + exit(1); + } + if (itime > (UINT_MAX / 1e6)) { + fprintf (stderr, "Too large value of '%s' for -i interval, max is %f\n", optarg, (UINT_MAX / 1e6)); + exit(1); + } + mExtSettings->mInterval = static_cast<unsigned int>(ceil(itime * 1e6)); + mExtSettings->mIntervalMode = kInterval_Time; + if (mExtSettings->mInterval <= 0) { + mExtSettings->mInterval = -1; + } else if (mExtSettings->mInterval < SMALLEST_INTERVAL) { + mExtSettings->mInterval = SMALLEST_INTERVAL; + fprintf (stderr, report_interval_small, (double) mExtSettings->mInterval / 1e3); + } + } + delete [] tmp; + } + break; + + case 'l': // length of each buffer + mExtSettings->mBufLen = byte_atoi(optarg); + setBuflenSet(mExtSettings); + break; + + case 'm': // print TCP MSS +#if HAVE_DECL_TCP_MAXSEG + setPrintMSS(mExtSettings); +#endif + break; + + case 'n': // bytes of data + // amount mode (instead of time mode) + unsetModeTime(mExtSettings); + mExtSettings->mAmount = byte_atoi(optarg); + if (!(mExtSettings->mAmount > 0)) { + fprintf (stderr, "Invalid value for -n amount of '%s'\n", optarg); + exit(1); + } + break; + + case 'o' : // output the report and other messages into the file + unsetSTDOUT(mExtSettings); + mExtSettings->mOutputFileName = new char[strlen(optarg)+1]; + strcpy(mExtSettings->mOutputFileName, optarg); + break; + + case 'p': // server port + { + char *tmp= new char [strlen(optarg) + 1]; + strcpy(tmp, optarg); + if ((results = strtok(tmp, "-")) != NULL) { + mExtSettings->mPort = atoi(results); + if (strcmp(results,optarg)) { + mExtSettings->mPortLast = atoi(strtok(NULL, "-")); + setIncrDstPort(mExtSettings); + } + } + delete [] tmp; + break; + } + case 'r': // test mode tradeoff + if (mExtSettings->mThreadMode != kMode_Client) { + fprintf(stderr, warn_invalid_server_option, option); + break; + } + if (isCompat(mExtSettings)) { + fprintf(stderr, warn_invalid_compatibility_option, option); + } + mExtSettings->mMode = kTest_TradeOff; + break; + + case 's': // server mode + if (mExtSettings->mThreadMode != kMode_Unknown) { + fprintf(stderr, warn_invalid_client_option, option); + break; + } + + mExtSettings->mThreadMode = kMode_Listener; + break; + + case 't': // seconds to run the client, server, listener + if (!optarg) { + fprintf(stderr, "ERROR: option -t requires value\n"); + exit(1); + } + { + double val; +#if HAVE_STRTOD + char *end; + errno = 0; + val = strtod(optarg, &end); + if (errno || (*end != '\0')) { + fprintf(stderr, "ERROR: -t value of '%s' not recognized\n", optarg); + exit(1); + } +#else + val = atof(optarg); +#endif + if (val > 0.0) + mExtSettings->mAmount = static_cast<size_t>(val * 100.0); + else + infinitetime = 1; + // time mode (instead of amount mode), units is 10 ms + setModeTime(mExtSettings); + setServerModeTime(mExtSettings); + } + break; + case 'u': // UDP instead of TCP + setUDP(mExtSettings); + break; + + case 'v': // print version and exit + fprintf(stdout, "%s", version); + exit(0); + break; + + case 'w': // TCP window size (socket buffer size) + mExtSettings->mTCPWin = byte_atoi(optarg); + if (mExtSettings->mTCPWin < 2048) { + fprintf(stderr, warn_window_small, mExtSettings->mTCPWin); + } + break; + + case 'x': // Limit Reports + while (*optarg != '\0') { + switch (*optarg) { + case 's': + case 'S': + setNoSettReport(mExtSettings); + break; + case 'c': + case 'C': + setNoConnReport(mExtSettings); + break; + case 'd': + case 'D': + setNoDataReport(mExtSettings); + break; + case 'v': + case 'V': + setNoServReport(mExtSettings); + break; + case 'm': + case 'M': + setNoMultReport(mExtSettings); + break; + default: + fprintf(stderr, warn_invalid_report, *optarg); + } + optarg++; + } + break; +#if HAVE_SCHED_SETSCHEDULER + case 'z': // Use realtime scheduling + setRealtime(mExtSettings); + break; +#endif + + case 'y': // Reporting Style + switch (*optarg) { + case 'c': + case 'C': + mExtSettings->mReportMode = kReport_CSV; + setNoSettReport(mExtSettings); + setNoConnReport(mExtSettings); + break; + default: + fprintf(stderr, warn_invalid_report_style, optarg); + } + break; + + // more esoteric options + + case 'B': // specify bind address + if (mExtSettings->mLocalhost == NULL) { + mExtSettings->mLocalhost = new char[strlen(optarg) + 1 ]; + strcpy(mExtSettings->mLocalhost, optarg); + } + break; + + case 'C': // Run in Compatibility Mode, i.e. no intial nor final header messaging + setCompat(mExtSettings); + if (mExtSettings->mMode != kTest_Normal) { + fprintf(stderr, warn_invalid_compatibility_option, + (mExtSettings->mMode == kTest_DualTest ? + 'd' : 'r')); + mExtSettings->mMode = kTest_Normal; + } + break; + + case 'D': // Run as a daemon + setDaemon(mExtSettings); + break; + + case 'F' : // Get the input for the data stream from a file + if (mExtSettings->mThreadMode != kMode_Client) { + fprintf(stderr, warn_invalid_server_option, option); + break; + } + + setFileInput(mExtSettings); + mExtSettings->mFileName = new char[strlen(optarg)+1]; + strcpy(mExtSettings->mFileName, optarg); + break; + + case 'H' : // Get the SSM host (or Source per the S,G) + if (mExtSettings->mThreadMode == kMode_Client) { + fprintf(stderr, warn_invalid_client_option, option); + break; + } + mExtSettings->mSSMMulticastStr = new char[strlen(optarg)+1]; + strcpy(mExtSettings->mSSMMulticastStr, optarg); + setSSMMulticast(mExtSettings); + break; + + case 'I' : // Set the stdin as the input source + if (mExtSettings->mThreadMode != kMode_Client) { + fprintf(stderr, warn_invalid_server_option, option); + break; + } + + setFileInput(mExtSettings); + setSTDIN(mExtSettings); + mExtSettings->mFileName = new char[strlen("<stdin>")+1]; + strcpy(mExtSettings->mFileName,"<stdin>"); + break; + + case 'L': // Listen Port (bidirectional testing client-side) + if (mExtSettings->mThreadMode != kMode_Client) { + fprintf(stderr, warn_invalid_server_option, option); + break; + } + mExtSettings->mListenPort = atoi(optarg); + break; + + case 'M': // specify TCP MSS (maximum segment size) +#if HAVE_DECL_TCP_MAXSEG + mExtSettings->mMSS = byte_atoi(optarg); + setTCPMSS(mExtSettings); + setPrintMSS(mExtSettings); +#endif + break; + + case 'N': // specify TCP nodelay option (disable Jacobson's Algorithm) + setNoDelay(mExtSettings); + break; + + case 'P': // number of client threads +#ifdef HAVE_THREAD + mExtSettings->mThreads = atoi(optarg); +#else + if (mExtSettings->mThreadMode != kMode_Server) { + fprintf(stderr, warn_invalid_single_threaded, option); + } else { + mExtSettings->mThreads = atoi(optarg); + } +#endif + break; +#ifdef WIN32 + case 'R': + setRemoveService(mExtSettings); + break; +#else + case 'R': + setReverse(mExtSettings); + break; +#endif + case 'S': // IP type-of-service + // TODO use a function that understands base-2 + // the zero base here allows the user to specify + // "0x#" hex, "0#" octal, and "#" decimal numbers + if ((mExtSettings->mTOS = parse_ipqos(optarg)) == -1) { + fprintf(stderr, "Invalid --tos value of %s\n", optarg); + mExtSettings->mTOS = 0; + } + break; + + case 'T': // time-to-live for both unicast and multicast + mExtSettings->mTTL = atoi(optarg); + break; + + case 'U': // single threaded UDP server + setUDP(mExtSettings); + setSingleUDP(mExtSettings); + setSingleClient(mExtSettings); + break; + + case 'V': // IPv6 Domain +#if HAVE_IPV6 + setIPV6(mExtSettings); +#else + fprintf(stderr, "The --ipv6_domain (-V) option is not enabled in this build.\n"); + exit(1); +#endif + break; + + case 'W' : + setSuggestWin(mExtSettings); + fprintf(stderr, "The -W option is not available in this release\n"); + break; + + case 'X' : + setPeerVerDetect(mExtSettings); + break; + + case 'Z': +#ifdef TCP_CONGESTION + setCongestionControl(mExtSettings); + mExtSettings->mCongestion = new char[strlen(optarg)+1]; + strcpy(mExtSettings->mCongestion, optarg); +#else + fprintf(stderr, "The -Z option is not available on this operating system\n"); +#endif + break; + + case 0: + if (incrdstip) { + incrdstip = 0; + setIncrDstIP(mExtSettings); + } + if (incrdstport) { + incrdstport = 0; + setIncrDstPort(mExtSettings); + } + if (incrsrcip) { + incrsrcip = 0; + setIncrSrcIP(mExtSettings); + } + if (incrsrcport) { + incrsrcport = 0; + setIncrSrcPort(mExtSettings); + } + if (sumdstip) { + sumdstip = 0; + setSumServerDstIP(mExtSettings); + } + if (txstarttime) { + long seconds; + long usecs; + int match = 0; + txstarttime = 0; + setTxStartTime(mExtSettings); + setEnhanced(mExtSettings); + match = sscanf(optarg,"%ld.%6ld", &seconds, &usecs); + mExtSettings->txstart_epoch.tv_usec = 0; + switch (match) { + case 2: + mExtSettings->txstart_epoch.tv_usec = usecs; + case 1: + mExtSettings->txstart_epoch.tv_sec = seconds; + break; + default: + unsetTxStartTime(mExtSettings); + fprintf(stderr, "WARNING: invalid --txstart-time format\n"); + } + } + if (noconnectsync) { +#ifdef HAVE_THREAD + noconnectsync = 0; + setNoConnectSync(mExtSettings); +#else + fprintf(stderr, "WARNING: --no-connect-sync requires thread support and not supported\n"); +#endif + } + if (txholdback) { + txholdback = 0; + char *end; + Timestamp holdbackdelay; + double delay = strtof(optarg, &end); + if (*end != '\0') { + fprintf (stderr, "Invalid value of '%s' for --txdelay-time time\n", optarg); + } else { + holdbackdelay.set(delay); + mExtSettings->txholdback_timer.tv_sec = holdbackdelay.getSecs(); + mExtSettings->txholdback_timer.tv_usec = (holdbackdelay.getUsecs()); + setTxHoldback(mExtSettings); + } + } + if (triptime) { + triptime = 0; + setTripTime(mExtSettings); + } + if (noudpfin) { + noudpfin = 0; + setNoUDPfin(mExtSettings); + } + if (connectonly) { + connectonly = 0; + setConnectOnly(mExtSettings); + unsetNoConnReport(mExtSettings); + if (optarg) { + mExtSettings->connectonly_count = atoi(optarg); + } else { + mExtSettings->connectonly_count = -1; + } + } + if (connectretry) { + connectretry = 0; + mExtSettings->mConnectRetries = atoi(optarg); + } + if (sumonly) { + sumonly = 0; + setSumOnly(mExtSettings); + } + if (so_dontroute) { + so_dontroute = 0; +#if HAVE_DECL_SO_DONTROUTE + setDontRoute(mExtSettings); + if (optarg) { + if (atoi(optarg)) + setDontRoute(mExtSettings); + else + unsetDontRoute(mExtSettings); + } +#else + fprintf(stderr, "WARNING: The --local-only option is not supported on this platform\n"); +#endif + } + if (nearcongest) { + nearcongest = 0; + setNearCongest(mExtSettings); + if (optarg && (atof(optarg) >= 0.0)) { + mExtSettings->rtt_nearcongest_weight_factor = atof(optarg); + } else { + mExtSettings->rtt_nearcongest_weight_factor = NEARCONGEST_DEFAULT; + } + } + if (permitkey) { + permitkey = 0; + if (optarg) { + strncpy(mExtSettings->mPermitKey, optarg, MAX_PERMITKEY_LEN); + mExtSettings->mPermitKey[MAX_PERMITKEY_LEN] = '\0'; + } else { + mExtSettings->mPermitKey[0] = '\0'; + } + setPermitKey(mExtSettings); + } + if (permitkeytimeout) { + permitkeytimeout = 0; + if (atof(optarg) >= 0.0) + mExtSettings->mListenerTimeout = static_cast<size_t>(atof(optarg)); + } + if (histogram) { + histogram = 0; + setHistogram(mExtSettings); + setEnhanced(mExtSettings); + if (optarg) { + mExtSettings->mHistogramStr = new char[strlen(optarg) + 1 ]; + strcpy(mExtSettings->mHistogramStr, optarg); + } else { + mExtSettings->mHistogramStr = NULL; + } + } + if (jitter_histogram) { + jitter_histogram = 0; + setJitterHistogram(mExtSettings); + setEnhanced(mExtSettings); + if (optarg) { + mExtSettings->jitter_binwidth = atoi(optarg); + } else { + mExtSettings->jitter_binwidth = JITTER_BINWIDTH; // units are usecs + } + } + if (reversetest) { + reversetest = 0; + setReverse(mExtSettings); + } + if (fullduplextest) { + fullduplextest = 0; + setFullDuplex(mExtSettings); + } + if (overridetos) { + overridetos = 0; + if ((mExtSettings->mRTOS = parse_ipqos(optarg)) == -1) { + fprintf(stderr, "Invalid --tos-overide value of %s\n", optarg); + } else { + setOverrideTOS(mExtSettings); + } + } + if (fqrate) { +#if defined(HAVE_DECL_SO_MAX_PACING_RATE) + fqrate=0; + setFQPacing(mExtSettings); + mExtSettings->mFQPacingRate = static_cast<uintmax_t>(bitorbyte_atoi(optarg) / 8); +#else + fprintf(stderr, "WARNING: The --fq-rate option is not supported\n"); +#endif + } + if (isochronous) { + isochronous = 0; + setEnhanced(mExtSettings); + setIsochronous(mExtSettings); + // The following are default values which + // may be overwritten during modal parsing + mExtSettings->mFPS = 60.0; + mExtSettings->mMean = 20000000.0; + mExtSettings->mVariance = 0.0; + mExtSettings->mBurstIPG = 5e-6; + if (optarg) { + mExtSettings->mIsochronousStr = new char[strlen(optarg) + 1 ]; + strcpy(mExtSettings->mIsochronousStr, optarg); + } + } + if (burstipg) { + burstipg = 0; + setIPG(mExtSettings); + char *end; + mExtSettings->mBurstIPG = strtof(optarg,&end); + if (*end != '\0') { + fprintf (stderr, "ERRPORE: Invalid value of '%s' for --ipg\n", optarg); + exit(1); + } + } + if (rxwinclamp) { + rxwinclamp = 0; +#if HAVE_DECL_TCP_WINDOW_CLAMP + mExtSettings->mClampSize = byte_atoi(optarg); + setRxClamp(mExtSettings); +#else + fprintf(stderr, "--tcp-rx-window-clamp not supported on this platform\n"); +#endif + } + if (tcpwritetimes) { + tcpwritetimes = 0; + setTcpWriteTimes(mExtSettings); + } + if (notcpbbquickack) { + notcpbbquickack = 0; + notcpbbquickack_cliset = 1; + } + if (tcpquickack) { + tcpquickack = 0; +#if HAVE_DECL_TCP_QUICKACK + setTcpQuickAck(mExtSettings); +#endif + } + if (utctimes) { + setUTC(mExtSettings); + } + if (workingload) { + workingload = 0; +#ifdef HAVE_THREAD + setWorkingLoadUp(mExtSettings); + setWorkingLoadDown(mExtSettings); + if (optarg) { + char *tmp= new char [strlen(optarg) + 1]; + if (tmp) { + strcpy(tmp, optarg); + if ((results = strtok(tmp, ",")) != NULL) { + if (strcasecmp(results, "up") == 0) { + unsetWorkingLoadDown(mExtSettings); + } else if (strcasecmp(results, "down") == 0) { + unsetWorkingLoadUp(mExtSettings); + } else if (strcasecmp(results, "bidir") == 0) { + setWorkingLoadUp(mExtSettings); + setWorkingLoadDown(mExtSettings); + } else { + fprintf(stderr, "Unrecoginized value of %s for --working-load, use 'up', 'down' or 'bidir'\n", results); + } + if ((results = strtok(NULL, ",")) != NULL) { + mExtSettings->mWorkingLoadThreads = atoi(results); + } + delete [] tmp; + } + } + } +#else + fprintf(stderr, "bounceback-congest option requires a platform that supports threads\n"); +#endif + } + if (bouncebackdelaystart) { + bouncebackdelaystart = 0; + char *end; + Timestamp holdbackdelay; + double delay = strtof(optarg, &end); + if (*end != '\0') { + fprintf (stderr, "Invalid value of '%s' for --bounceback-txdelay time\n", optarg); + } else { + holdbackdelay.set(delay); + mExtSettings->txholdback_timer.tv_sec = holdbackdelay.getSecs(); + mExtSettings->txholdback_timer.tv_usec = (holdbackdelay.getUsecs()); + setTxHoldback(mExtSettings); + } + } + if (txnotsentlowwater) { + txnotsentlowwater = 0; +#if HAVE_DECL_TCP_NOTSENT_LOWAT + mExtSettings->mWritePrefetch = byte_atoi(optarg); + setWritePrefetch(mExtSettings); + setEnhanced(mExtSettings); +#else + fprintf(stderr, "--tcp-write-prefetch not supported on this platform\n"); +#endif + } + if (burstperiodic) { + burstperiodic = 0; + setPeriodicBurst(mExtSettings); + if (optarg && (atof(optarg) > 1e-5)) { // limit to 10 usecs + mExtSettings->mFPS = 1.0/atof(optarg); + } else { + if (atof(optarg) != 0) + fprintf(stderr, "WARN: burst-period too small, must be greater than 10 usecs\n"); + unsetPeriodicBurst(mExtSettings); + } + } + if (burstsize) { + burstsize = 0; + setPeriodicBurst(mExtSettings); + if (optarg) { + mExtSettings->mBurstSize = byte_atoi(optarg); + } + } + if (numreportstructs) { + numreportstructs = 0; + mExtSettings->numreportstructs = byte_atoi(optarg); + } + if (tapif) { + tapif = 0; +#if HAVE_TUNTAP_TAP + if (optarg) { + mExtSettings->mIfrname = static_cast<char *>(calloc(strlen(optarg) + 1, sizeof(char))); + strcpy(mExtSettings->mIfrname, optarg); + } + setTapDev(mExtSettings); + setEnhanced(mExtSettings); + setL2LengthCheck(mExtSettings); +#else + fprintf(stderr, "ERROR: tap devices not supported\n"); + exit(1); +#endif + } + if (tunif) { + tunif = 0; + fprintf(stderr, "ERROR: tun devices not yet supported\n"); + exit(1); +#if HAVE_TUNTAP_TUN + if (optarg) { + mExtSettings->mIfrname = static_cast<char *>(calloc(strlen(optarg) + 1, sizeof(char))); + strcpy(mExtSettings->mIfrname, optarg); + } + setTunDev(mExtSettings); + setEnhanced(mExtSettings); +#endif + } + if (hideips) { + hideips = 0; + setHideIPs(mExtSettings); + } + if (bounceback) { + bounceback = 0; + setBounceBack(mExtSettings); + setNoDelay(mExtSettings); + setEnhanced(mExtSettings); + if (optarg) { + mExtSettings->mBounceBackBurst = atoi(optarg); + if (mExtSettings->mBounceBackBurst <= 0) { + fprintf(stderr, "WARN: invalid bounceback value, setting it to 10\n"); + mExtSettings->mBounceBackBurst = 10; + } + } else { + mExtSettings->mBounceBackBurst = -1; + } + } + if (bouncebackhold) { + bouncebackhold = 0; + if (optarg) + //cli units is ms, working units is us + mExtSettings->mBounceBackHold = int(atof(optarg) * 1e3); + else + mExtSettings->mBounceBackHold = 0; + } + if (bouncebackperiod) { + bouncebackperiod = 0; + setPeriodicBurst(mExtSettings); + if (optarg) { + float value = atof(optarg); + if (value > 1e-5) { // limit to 10 usecs + mExtSettings->mFPS = 1.0/atof(optarg); + } else { + mExtSettings->mFPS = -1; + } + } + } + break; + default: // ignore unknown + break; + } +} // end Interpret + + +static void generate_permit_key (struct thread_Settings *mExtSettings) { + Timestamp now; + mExtSettings->mPermitKeyTime.tv_sec = now.getSecs(); + mExtSettings->mPermitKeyTime.tv_usec = now.getUsecs(); + int usecs = mExtSettings->mPermitKeyTime.tv_usec; + int timestrlength = snprintf(NULL, 0, "%ld.%06d-", static_cast<long>(mExtSettings->mPermitKeyTime.tv_sec), usecs); + snprintf(mExtSettings->mPermitKey, (timestrlength+1), "%ld.%06d-", static_cast<long>(mExtSettings->mPermitKeyTime.tv_sec), usecs); + srand(static_cast<unsigned int>(time(NULL))); + int index; + char characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; + for(index = timestrlength; index < (DEFAULT_PERMITKEY_LEN + timestrlength); index++) { + int len = snprintf(mExtSettings->mPermitKey + index, sizeof(char) + 1, "%c", \ + characters[rand() % (static_cast<int>(sizeof(characters)) - 1)]); + FAIL_errno ((len < 0), "permit-key gen", mExtSettings); + } + mExtSettings->mPermitKey[DEFAULT_PERMITKEY_LEN + timestrlength] = '\0'; + if (strlen(mExtSettings->mPermitKey) > MAX_PERMITKEY_LEN) { + fprintf(stderr, "ERROR: permit key too long\n"); + exit(1); + } +} + +static void strip_v6_brackets (char *v6addr) { + char * results; + if (v6addr && (*v6addr == '[') && ((results = strtok(v6addr, "]")) != NULL)) { + int len = strlen(v6addr); + for (int jx = 0; jx < len; jx++) { + v6addr[jx]= v6addr[jx + 1]; + } + } +} + +static char * isv6_bracketed_port (char *v6addr) { + char *results = NULL; + if (v6addr && (*v6addr == '[') && ((results = strtok(v6addr, "]")) != NULL)) { + results = strtok(NULL, ":"); + strip_v6_brackets(v6addr); + return results; + } + return NULL; +} +static char * isv4_port (char *v4addr) { + char *results = NULL; + if (((results = strtok(v4addr, ":")) != NULL) && ((results = strtok(NULL, ":")) != NULL)) { + return results; + } + return NULL; +} + + +// The commmand line options are position independent and hence some settings become "modal" +// i.e. two passes are required to get all the final settings correct. +// For example, -V indicates use IPv6 and -u indicates use UDP, and the default socket +// read/write (UDP payload) size is different for ipv4 and ipv6. +// So in the Settings_Interpret pass there is no guarantee to know all three of (-u and -V and not -l) +// while parsing them individually. +// +// Since Settings_Interpret() will set all the *individual* options and flags +// then the below code (per the example UDP, v4 or v6, and not -l) can set final +// values, e.g. a correct default mBufLen. Other examples that need this are multicast +// socket or not,-B local bind port parsing, and when to use the default UDP offered load +// +// Also apply the bail out or exit conditions if the user requested mutually exclusive +// or incompatabile options +void Settings_ModalOptions (struct thread_Settings *mExtSettings) { + char *results; + // Handle default read/write sizes based on v4, v6, UDP or TCP + if (!isBuflenSet(mExtSettings)) { + if (isUDP(mExtSettings)) { + if (isIPV6(mExtSettings) && mExtSettings->mThreadMode == kMode_Client) { + mExtSettings->mBufLen = kDefault_UDPBufLenV6; + } else { + mExtSettings->mBufLen = kDefault_UDPBufLen; + } + } else { + if (isBounceBack(mExtSettings)) + mExtSettings->mBufLen = kDefault_BBTCPBufLen; + else + mExtSettings->mBufLen = kDefault_TCPBufLen; + } + } + if (!mExtSettings->mPortLast) + mExtSettings->mPortLast = mExtSettings->mPort; + + // Handle default UDP offered load (TCP will be max, i.e. no read() or write() rate limiting) + if (!isBWSet(mExtSettings) && isUDP(mExtSettings)) { + mExtSettings->mAppRate = kDefault_UDPRate; + } + if (isTripTime(mExtSettings) && (isReverse(mExtSettings) || \ + isFullDuplex(mExtSettings) || \ + (mExtSettings->mMode != kTest_Normal))) { + setEnhanced(mExtSettings); + } + // Warnings + if (mExtSettings->mThreadMode == kMode_Client) { + if (isModeTime(mExtSettings) && infinitetime) { + unsetModeTime(mExtSettings); + setModeInfinite(mExtSettings); + fprintf(stderr, "WARNING: client will send traffic forever or until an external signal (e.g. SIGINT or SIGTERM) occurs to stop it\n"); + } + if (isFullDuplex(mExtSettings) && isCongestionControl(mExtSettings)) { + fprintf(stderr, "WARNING: tcp congestion control will only be applied on transmit traffic, use -Z on the server\n"); + } + } + if (isHideIPs(mExtSettings)) { + char hide_string[] = "(**hidden**)"; + mExtSettings->mHideHost = new char[strlen(hide_string) + 1]; + if (mExtSettings->mHideHost) + strcpy(mExtSettings->mHideHost, &hide_string[0]); + } + + // Bail outs + bool bail = false; + // compat mode doesn't support these test settings + int compat_nosupport = (isReverse(mExtSettings) | isFullDuplex(mExtSettings) | isTripTime(mExtSettings) | isVaryLoad(mExtSettings) \ + | isHistogram(mExtSettings) | isIsochronous(mExtSettings) \ + | isEnhanced(mExtSettings) | (mExtSettings->mMode != kTest_Normal)); + if (isCompat(mExtSettings) && compat_nosupport) { + fprintf(stderr, "ERROR: compatibility mode not supported with the requested with options\n"); + bail = true; + } +#if !(HAVE_DECL_IP_TOS) + if (isOverrideTOS(mExtSettings) || mExtSettings->mTOS) { + unsetOverrideTOS(mExtSettings); + fprintf(stderr, "WARN: IP_TOS not supported\n"); + } +#endif + if (isPermitKey(mExtSettings)) { + if (isUDP(mExtSettings)) { + fprintf(stderr, "ERROR: Option of --permit-key not supported with UDP\n"); + bail = true; + } else if (mExtSettings->mPermitKey[0] != '\0') { + int keylen = strnlen(mExtSettings->mPermitKey, MAX_PERMITKEY_LEN + 1); + if (keylen < MIN_PERMITKEY_LEN) { + fprintf(stderr, "ERROR: value for --permit-key must have at least %d characters\n", MIN_PERMITKEY_LEN); + bail = true; + } else if (keylen > MAX_PERMITKEY_LEN) { + fprintf(stderr, "ERROR: value for --permit-key can't be more than %d characters \n", MAX_PERMITKEY_LEN); + bail = true; + } + } + } +#if !HAVE_IPV6 + if (isIPV6(mExtSettings)) { + fprintf(stderr, "ERROR: ipv6 not supported\n"); + bail = true; + } +#endif + if (isIPV4(mExtSettings) && isIPV6(mExtSettings)) { + fprintf(stderr, "WARN: both ipv4 and ipv6 set\n"); + unsetIPV6(mExtSettings); + unsetIPV4(mExtSettings); + } + if (mExtSettings->mThreadMode == kMode_Client) { + if (isRemoveService(mExtSettings)) { + // -R on the client is overloaded and is the + // short option for --reverse, fix it now + setReverse(mExtSettings); + unsetRemoveService(mExtSettings); + } + if (isIncrSrcIP(mExtSettings) && (mExtSettings->mLocalhost==NULL)) { + fprintf(stderr, "ERROR: option of --incr-srcip requires -B bind option to be set\n"); + bail = true; + } + if (isSumServerDstIP(mExtSettings)) { + fprintf(stderr, "WARN: option of --sum-dstip not supported on the client\n"); + } + if (isOverrideTOS(mExtSettings)) { + unsetOverrideTOS(mExtSettings); + fprintf(stderr, "WARN: option of --tos-override not supported on the client\n"); + } + if (isRxClamp(mExtSettings)) { + fprintf(stderr, "WARN: option of --tcp-rx-window-clamp not supported on the client\n"); + unsetRxClamp(mExtSettings); + } + if (isJitterHistogram(mExtSettings)) { + fprintf(stderr, "WARN: option of --jitter-histogram not supported on the client\n"); + unsetJitterHistogram(mExtSettings); + } + if (isIncrSrcPort(mExtSettings) && !mExtSettings->mBindPort) { + fprintf(stderr, "WARN: option of --incr-srcport requires -B bind option w/port to be set\n"); + unsetIncrSrcPort(mExtSettings); + } + if (isPeriodicBurst(mExtSettings)) { + setEnhanced(mExtSettings); + setFrameInterval(mExtSettings); + } + if (mExtSettings->mTTL > MAXTTL) { + fprintf(stderr, "ERROR: option of -ttl (-T) must be less than %d\n", MAXTTL); + bail = true; + } + if (isPermitKey(mExtSettings) && (mExtSettings->mPermitKey[0] == '\0')) { + fprintf(stderr, "ERROR: option of --permit-key requires a value on the client\n"); + bail = true; + } + if (!isUDP(mExtSettings) && isTxHoldback(mExtSettings) && isTxStartTime(mExtSettings)) { + fprintf(stderr,"ERROR: options of --txstart-time and --txdelay-time are mutually exclusive\n"); + bail = true; + } else if (isTxStartTime(mExtSettings) || isTxHoldback(mExtSettings)) { + Timestamp now; + if (isTxStartTime(mExtSettings)) { + if (mExtSettings->txstart_epoch.tv_sec < 0) { + fprintf(stderr, "ERROR: --txstart-time must be a positive value\n"); + unsetTxStartTime(mExtSettings); + bail = true; + } else if ((mExtSettings->txstart_epoch.tv_sec - now.getSecs()) > MAXDIFFTXSTART) { + char timestr[120]; + struct timeval t; + t.tv_sec = now.getSecs(); + t.tv_usec = now.getUsecs(); + iperf_formattime(timestr, sizeof(timestr), t, isEnhanced(mExtSettings), isUTC(mExtSettings), YearThruSecTZ); + printf(error_starttime_exceeds, mExtSettings->txstart_epoch.tv_sec, mExtSettings->txstart_epoch.tv_usec, \ + timestr, MAXDIFFTXSTART); + bail = true; + } + } else if (mExtSettings->txholdback_timer.tv_sec > MAXDIFFTXDELAY) { + printf(error_delaytime_exceeds, mExtSettings->txholdback_timer.tv_sec, MAXDIFFTXDELAY); + bail = true; + } + } + if (isBounceBack(mExtSettings)) { + if (static_cast<int> (mExtSettings->mBurstSize) > 0) { + fprintf(stderr, "WARN: options of --burst-size for bounce-back ignored, use -l sets size\n"); + } + mExtSettings->mBounceBackBytes = mExtSettings->mBufLen; + mExtSettings->mBurstSize = mExtSettings->mBufLen; +#if HAVE_DECL_TCP_QUICKACK + if (notcpbbquickack_cliset && isTcpQuickAck(mExtSettings)) { + fprintf(stderr, "ERROR: --tcp-quickack and --bounceback-no-quickack are mutually exclusive\n"); + bail = true; + } + // be wary of double negatives here + if (!notcpbbquickack_cliset) { + setTcpQuickAck(mExtSettings); + } +#endif + // default bounceback period to 1 second + if (!isPeriodicBurst(mExtSettings)) { + mExtSettings->mFPS = 1.0; + setPeriodicBurst(mExtSettings); + if (mExtSettings->mIntervalMode == kInterval_None) { + mExtSettings->mIntervalMode = kInterval_Time; + mExtSettings->mInterval = 1000000; // units is us + } + } else if (mExtSettings->mFPS <= 1e-5) { + unsetPeriodicBurst(mExtSettings); + } + if (isPeriodicBurst(mExtSettings) && (mExtSettings->mBounceBackBurst == -1)) { + mExtSettings->mBounceBackBurst = 10; + } + } +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (isTripTime(mExtSettings) && !isUDP(mExtSettings)) { + if (isWritePrefetch(mExtSettings)) { + if (mExtSettings->mWritePrefetch <= 0) { + unsetWritePrefetch(mExtSettings); + } + } else { + mExtSettings->mWritePrefetch = SMALL_WRITE_PREFETCH; + setWritePrefetch(mExtSettings); + setEnhanced(mExtSettings); + } + } +#endif + if (isPeriodicBurst(mExtSettings)) { + if (isIsochronous(mExtSettings)) { + fprintf(stderr, "ERROR: options of --burst-period and --isochronous cannot be applied together\n"); + bail = true; + } else if (isNearCongest(mExtSettings)) { + fprintf(stderr, "ERROR: options of --burst-period and --near-congestion cannot be applied together\n"); + bail = true; + } else if (static_cast<int> (mExtSettings->mBurstSize) == 0) { + mExtSettings->mBurstSize = byte_atoi("1M"); //default to 1 Mbyte + } + if (static_cast<int> (mExtSettings->mBurstSize) < mExtSettings->mBufLen) { + fprintf(stderr, "ERROR: option of --burst-size %d must be equal or larger to write length (-l) %d\n", mExtSettings->mBurstSize, mExtSettings->mBufLen); + bail = true; + } + } else if (!isBounceBack(mExtSettings) && (static_cast<int> (mExtSettings->mBurstSize) > 0)) { + setPeriodicBurst(mExtSettings); + mExtSettings->mFPS = 1.0; + fprintf(stderr, "WARN: option of --burst-size without --burst-period defaults --burst-period to 1 second\n"); + } + if (isUDP(mExtSettings)) { + if (isPeerVerDetect(mExtSettings)) { + fprintf(stderr, "ERROR: option of -X or --peer-detect not supported with -u UDP\n"); + bail = true; + } + if (isConnectOnly(mExtSettings)) { + fprintf(stderr, "ERROR: option of --connect-only not supported with -u UDP\n"); + bail = true; + } + if (isBounceBack(mExtSettings)) { + fprintf(stderr, "ERROR: option of -X or --bounceback not supported with -u UDP\n"); + bail = true; + } + if (isNearCongest(mExtSettings)) { + fprintf(stderr, "ERROR: option of --near-congestion not supported with -u UDP\n"); + bail = true; + } + if (isIPG(mExtSettings) && isBWSet(mExtSettings)) { + fprintf(stderr, "ERROR: options of --b and --ipg cannot be applied together\n"); + bail = true; + } + if (mExtSettings->mBurstIPG < 0.0) { + fprintf(stderr, "ERROR: option --ipg must be a positive value\n"); + bail = true; + } + if (mExtSettings->mConnectRetries > 0) { + fprintf(stderr, "ERROR: option --connect-retries not supported with -u UDP\n"); + bail = true; + } + if (isWritePrefetch(mExtSettings)) { + fprintf(stderr, "WARN: setting of option --tcp-write-prefetch is not supported with -u UDP\n"); + unsetWritePrefetch(mExtSettings); + } + if (isTcpQuickAck(mExtSettings)) { + fprintf(stderr, "WARN: setting of option --tcp-quickack is not supported with -u UDP\n"); + unsetWritePrefetch(mExtSettings); + } + + { + double delay_target; + if (isIPG(mExtSettings)) { + delay_target = mExtSettings->mBurstIPG * 1e9; // convert from seconds to nanoseconds + } else { + // compute delay target in units of nanoseconds + if (mExtSettings->mAppRateUnits == kRate_BW) { + // compute delay for bandwidth restriction, constrained to [0,max] seconds + delay_target = (mExtSettings->mBufLen * 8e9) / mExtSettings->mAppRate; + } else { + delay_target = 1e9 / mExtSettings->mAppRate; + } + } + if (delay_target < 0 || + delay_target > MAXIPGSECS * 1e9) { + fprintf(stderr, "ERROR: IPG delay target of %.1f secs too large (max value is %d secs)\n", (delay_target / 1e9), MAXIPGSECS); + bail = true; + } + } + if (isTripTime(mExtSettings)) { + if (mExtSettings->mBufLen < MINTRIPTIMEPLAYOAD) { + if (isReverse(mExtSettings) || isFullDuplex(mExtSettings) || (mExtSettings->mMode != kTest_Normal)) { + fprintf(stderr, "ERROR: payload (-l) size of %d too small for --trip-times, must be %d or greater\n", mExtSettings->mBufLen, MINTRIPTIMEPLAYOAD); + bail = true; + } else { + setSmallTripTime(mExtSettings); + } + } + } + } else { + if ((mExtSettings->mAppRate > 0) && isNearCongest(mExtSettings)) { + fprintf(stderr, "ERROR: option of --near-congestion and -b rate limited are mutually exclusive\n"); + bail = true; + } + if (isBWSet(mExtSettings) && !(mExtSettings->mAppRateUnits == kRate_PPS) \ + && ((mExtSettings->mAppRate / 8) < static_cast<uintmax_t>(mExtSettings->mBufLen))) { + fprintf(stderr, "ERROR: option -b and -l of %d are incompatible, consider setting -l to %d or lower\n", \ + mExtSettings->mBufLen, static_cast<int>(mExtSettings->mAppRate / 8)); + bail = true; + } + if (isIPG(mExtSettings)) { + fprintf(stderr, "ERROR: option --ipg requires -u UDP\n"); + bail = true; + } + if (isNoUDPfin(mExtSettings)) { + fprintf(stderr, "ERROR: option --no-udp-fin requires -u UDP\n"); + bail = true; + } + if (isTxHoldback(mExtSettings) && isConnectOnly(mExtSettings)) { + fprintf(stderr,"ERROR: Fail because --txdelay-time and --connect-only cannot be applied together\n"); + bail = true; ; + } + if (mExtSettings->mAppRateUnits == kRate_PPS) { + fprintf(stderr, "ERROR: units of pps not supported with TCP\n"); + bail = true; + } + if (isJitterHistogram(mExtSettings)) { + fprintf(stderr, "ERROR: option of --jitter-histogram not supported with TCP\n"); + bail = true; + } + } + if (!isReverse(mExtSettings) && !isFullDuplex(mExtSettings) && isHistogram(mExtSettings)){ + setTcpWriteTimes(mExtSettings); + mExtSettings->mHistBins = 100000; // 10 seconds wide + mExtSettings->mHistBinsize = 100; // 100 usec bins + mExtSettings->mHistUnits = 6; // usecs 10 pow(x) + mExtSettings->mHistci_lower = 5; + mExtSettings->mHistci_upper = 95; + } + if (isCongestionControl(mExtSettings) && isReverse(mExtSettings)) { + fprintf(stderr, "ERROR: tcp congestion control -Z and --reverse cannot be applied together\n"); + bail = true; + } + { + int one_only = 0; + if (isFullDuplex(mExtSettings)) + one_only++; + if (isReverse(mExtSettings)) + one_only++; + if (mExtSettings->mMode != kTest_Normal) + one_only++; + if (one_only > 1) { + fprintf(stderr, "ERROR: options of --full-duplex, --reverse, -d and -r are mutually exclusive\n"); + bail = true; + } + } + if (isBWSet(mExtSettings) && isIsochronous(mExtSettings)) { + fprintf(stderr, "ERROR: options of --b and --isochronous cannot be applied together\n"); + bail = true; + } + } else { + if (mExtSettings->mPortLast && (!(mExtSettings->mPortLast >= mExtSettings->mPort))) { + fprintf(stderr, "ERROR: invalid port range of %d-%d\n",mExtSettings->mPort, mExtSettings->mPortLast); + bail = true; + } + if (isPermitKey(mExtSettings)) { + if (mExtSettings->mPermitKey[0]=='\0') { + generate_permit_key(mExtSettings); + } + if (mExtSettings->mListenerTimeout < 0) { + mExtSettings->mListenerTimeout = DEFAULT_PERMITKEY_LIFE; + } + } + if (isBounceBack(mExtSettings)) { + fprintf(stderr, "ERROR: setting of option --bounce-back is not supported on the server\n"); + bail = true; + } + if (isTripTime(mExtSettings)) { + fprintf(stderr, "WARN: setting of option --trip-times is not supported on the server\n"); + } + if (isWritePrefetch(mExtSettings)) { + fprintf(stderr, "WARN: setting of option --tcp-write-prefetch is not supported on the server\n"); + unsetWritePrefetch(mExtSettings); + } + if (isIncrSrcIP(mExtSettings)) { + fprintf(stderr, "WARN: setting of option --incr-srcip is not supported on the server\n"); + } + if (isVaryLoad(mExtSettings)) { + fprintf(stderr, "WARN: option of variance per -b is not supported on the server\n"); + } + if (isTxStartTime(mExtSettings)) { + fprintf(stderr, "WARN: option of --txstart-time is not supported on the server\n"); + } + if (isTxHoldback(mExtSettings)) { + fprintf(stderr, "WARN: option of --txdelay-time is not supported on the server\n"); + } + if (isIPG(mExtSettings)) { + fprintf(stderr, "WARN: option of --ipg is not supported on the server\n"); + } + if (isIsochronous(mExtSettings)) { + fprintf(stderr, "WARN: option of --isochronous is not supported on the server\n"); + } + if (isFullDuplex(mExtSettings)) { + fprintf(stderr, "WARN: option of --full-duplex is not supported on the server\n"); + } + if (isReverse(mExtSettings)) { + fprintf(stderr, "WARN: option of --reverse is not supported on the server\n"); + } + if (isIncrDstIP(mExtSettings)) { + fprintf(stderr, "WARN: option of --incr-dstip is not supported on the server\n"); + } + if (isFQPacing(mExtSettings)) { + fprintf(stderr, "WARN: option of --fq-rate is not supported on the server\n"); + } + if (isNoUDPfin(mExtSettings)) { + fprintf(stderr, "WARN: option of --no-udp-fin is not supported on the server\n"); + } + if (isPeerVerDetect(mExtSettings)) { + fprintf(stderr, "WARN: option of -X or --peer-detect not supported on the server\n"); + } + if (mExtSettings->mConnectRetries > 0) { + fprintf(stderr, "WARN: option --connect-retries not supported on the server\n"); + } + if (isNearCongest(mExtSettings)) { + fprintf(stderr, "WARN: option of --near-congestion not supported on the server\n"); + } + if (isPeriodicBurst(mExtSettings)) { + fprintf(stderr, "WARN: option of --burst-period can only be set on the client\n"); + } + if (mExtSettings->mBurstSize != 0) { + fprintf(stderr, "WARN: option of --burst-size not supported on the server\n"); + } + if (isUDP(mExtSettings) && isRxClamp(mExtSettings)) { + fprintf(stderr, "WARN: option of --tcp-rx-window-clamp not supported using -u UDP \n"); + unsetRxClamp(mExtSettings); + } + } + if (bail) + exit(1); + + // Histogram optional settings + if (isHistogram(mExtSettings)) { + if (!mExtSettings->mHistogramStr) { + if (mExtSettings->mThreadMode == kMode_Server) { + // set default rx histogram settings, milliseconds bins between 0 and 1 secs + mExtSettings->mHistBins = 1000; + mExtSettings->mHistBinsize = 1; + mExtSettings->mHistUnits = 3; + mExtSettings->mHistci_lower = 5; + mExtSettings->mHistci_upper = 95; + } else { + // set default tx histogram settings, microseconds with 100 us bins + mExtSettings->mHistBins = 10000; + mExtSettings->mHistBinsize = 100; + mExtSettings->mHistUnits = 6; + mExtSettings->mHistci_lower = 5; + mExtSettings->mHistci_upper = 95; + } + } else { + // check for optional arguments to change histogram settings + if (((results = strtok(mExtSettings->mHistogramStr, ",")) != NULL) && !strcmp(results,mExtSettings->mHistogramStr)) { + // scan for unit specifier + char *tmp = new char [strlen(results) + 1]; + strcpy(tmp, results); + if ((strtok(tmp, "u") != NULL) && strcmp(results,tmp) != 0) { + mExtSettings->mHistUnits = 6; // units is microseconds + } else { + strcpy(tmp, results); + if ((strtok(tmp, "m") != NULL) && strcmp(results,tmp) != 0) { + mExtSettings->mHistUnits = 3; // units is milliseconds + } + } + mExtSettings->mHistBinsize = atoi(tmp); + delete [] tmp; + mExtSettings->mHistci_lower = 5; + mExtSettings->mHistci_upper = 95; + if ((results = strtok(results+strlen(results)+1, ",")) != NULL) { + mExtSettings->mHistBins = byte_atoi(results); + if ((results = strtok(NULL, ",")) != NULL) { + mExtSettings->mHistci_lower = atof(results); + if ((results = strtok(NULL, ",")) != NULL) { + mExtSettings->mHistci_upper = atof(results); + } + } + } + } + } + } + if (isUDP(mExtSettings)) { + if (isFullDuplex(mExtSettings)) { + setNoUDPfin(mExtSettings); + } + if (mExtSettings->mThreadMode == kMode_Client) { + // L2 settings + if (l2checks && isUDP(mExtSettings)) { + l2checks = 0; +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) + // Request server to do length checks + setL2LengthCheck(mExtSettings); +#else + fprintf(stderr, "WARNING: option --l2checks not supported on this platform\n"); +#endif + } + } + } else { + if (mExtSettings->mBurstSize && (static_cast<int>(mExtSettings->mBurstSize) < mExtSettings->mBufLen)) { + fprintf(stderr, "WARN: Setting --burst-size to %d because value given is smaller than -l value\n", \ + mExtSettings->mBufLen); + mExtSettings->mBurstSize = mExtSettings->mBufLen; + } else if (isTripTime(mExtSettings) && !(mExtSettings->mBurstSize > 0)) { + mExtSettings->mBurstSize = mExtSettings->mBufLen; + } + } + if (isIsochronous(mExtSettings) && mExtSettings->mIsochronousStr) { + // parse client isochronous field, + // format is --isochronous <int>:<float>,<float> and supports + // human suffixes, e.g. --isochronous 60:100m,5m + // which is frames per second, mean and variance + if (mExtSettings->mThreadMode == kMode_Client) { + if (((results = strtok(mExtSettings->mIsochronousStr, ":")) != NULL) && !strcmp(results,mExtSettings->mIsochronousStr)) { + mExtSettings->mFPS = atof(results); + if ((results = strtok(NULL, ",")) != NULL) { + mExtSettings->mMean = bitorbyte_atof(results); + if (mExtSettings->mMean == 0.0) { + fprintf(stderr, "ERROR: Invalid --isochronous mean value, must be greater than zero\n"); + exit(1); + } + if (!isUDP(mExtSettings)) { + if (mExtSettings->mMean < 0) { + fprintf(stderr, "ERROR: Invalid --isochronous units of 'p' with TCP must be bytes\n"); + exit(1); + } + } else { // UDP + if (mExtSettings->mMean < 0) { + mExtSettings->mMean *= -8 * mExtSettings->mBufLen * mExtSettings->mFPS; + } + } + if ((results = strtok(NULL, ",")) != NULL) { + mExtSettings->mVariance = bitorbyte_atof(results); + } + } else { + mExtSettings->mMean = 20000000.0; + mExtSettings->mVariance = 0.0; + } + } else { + fprintf(stderr, "WARNING: Invalid --isochronous value, format is <fps>:<mean>,<variance> (e.g. 60:18M,1m)\n"); + } + } + } + + // Check for further mLocalhost (-B) and <dev> requests + // full addresses look like 192.168.1.1:6001%eth0 or [2001:e30:1401:2:d46e:b891:3082:b939]:6001%eth0 + iperf_sockaddr tmp; + // Parse -B addresses + if (mExtSettings->mLocalhost) { + if (((results = strtok(mExtSettings->mLocalhost, "%")) != NULL) && ((results = strtok(NULL, "%")) != NULL)) { + mExtSettings->mIfrname = static_cast<char *>(calloc(strlen(results) + 1, sizeof(char))); + strcpy(mExtSettings->mIfrname, results); + if (mExtSettings->mThreadMode == kMode_Client) { + fprintf(stderr, "WARNING: Client cannot set bind device %s via -B consider using -c\n", mExtSettings->mIfrname); + free(mExtSettings->mIfrname); + mExtSettings->mIfrname = NULL; + } + } + if (isIPV6(mExtSettings)) { + results = isv6_bracketed_port(mExtSettings->mLocalhost); + } else { + results = isv4_port(mExtSettings->mLocalhost); + } + if (results) { + if (mExtSettings->mThreadMode == kMode_Client) { + mExtSettings->mBindPort = atoi(results); + } else { + fprintf(stderr, "WARNING: port %s ignored - set receive port on server via -p or -L\n", results); + } + } + // Check for multicast per the -B + SockAddr_setHostname(mExtSettings->mLocalhost, &tmp, + (isIPV6(mExtSettings) ? 1 : 0)); + if ((mExtSettings->mThreadMode != kMode_Client) && SockAddr_isMulticast(&tmp)) { + setMulticast(mExtSettings); + } else if (SockAddr_isMulticast(&tmp)) { + if (mExtSettings->mIfrname) { + free(mExtSettings->mIfrname); + mExtSettings->mIfrname = NULL; + } + fprintf(stderr, "WARNING: Client src addr (per -B) must be ip unicast\n"); + } + } + // Parse client (-c) addresses for multicast, link-local and bind to device, port incr + if (mExtSettings->mThreadMode == kMode_Client) { + if (mExtSettings->mPortLast > mExtSettings->mPort) { + int prcnt = ((mExtSettings->mPortLast - mExtSettings->mPort) + 1); + int threads_needed = (prcnt > mExtSettings->mThreads) ? prcnt : mExtSettings->mThreads; + if (mExtSettings->mThreads < prcnt) { + fprintf(stderr, "WARNING: port-range and -P mismatch (adjusting -P to %d)\n", threads_needed); + mExtSettings->mThreads = threads_needed; + } else if ((mExtSettings->mThreads > 1) && (threads_needed > prcnt)) { + fprintf(stderr, "WARNING: port-range and -P mismatch (adjusting port-range to %d-%d)\n", \ + mExtSettings->mPort, mExtSettings->mPort + threads_needed); + } + } + mExtSettings->mIfrnametx = NULL; // default off SO_BINDTODEVICE + if (((results = strtok(mExtSettings->mHost, "%")) != NULL) && ((results = strtok(NULL, "%")) != NULL)) { + size_t len = strlen(results) + 1; + mExtSettings->mIfrnametx = static_cast<char *>(calloc(len, sizeof(char))); + strncpy(mExtSettings->mIfrnametx, results, len); + mExtSettings->mIfrnametx[len] = '\0'; + } + if (isIPV6(mExtSettings)) + strip_v6_brackets(mExtSettings->mHost); + // get the socket address settings from the host, needed for link-local and multicast tests + SockAddr_zeroAddress(&mExtSettings->peer); + SockAddr_remoteAddr(mExtSettings); + if (isIPV6(mExtSettings) && SockAddr_isLinklocal(&mExtSettings->peer)) { + // link-local doesn't use SO_BINDTODEVICE but includes it in the host string + // so stitch things back together and null the bind to name + if (mExtSettings->mIfrnametx) { + strcat(mExtSettings->mHost, "%"); + strcat(mExtSettings->mHost, mExtSettings->mIfrnametx); + free(mExtSettings->mIfrnametx); + mExtSettings->mIfrnametx = NULL; + } else { + fprintf(stderr, "WARNING: usage of ipv6 link-local requires a device specifier, e.g. %s%%eth0\n", mExtSettings->mHost); + } + SockAddr_zeroAddress(&mExtSettings->peer); // for link-local, force getaddrinfo() in the connect + } + if (SockAddr_isMulticast(&mExtSettings->peer)) { + bail = false; + if ((mExtSettings->mThreads > 1) && !isIncrDstIP(mExtSettings)) { + fprintf(stderr, "ERROR: client option of -P greater than 1 not supported with multicast address\n"); + bail = true; + } else if (isFullDuplex(mExtSettings) || isReverse(mExtSettings) || (mExtSettings->mMode != kTest_Normal)) { + fprintf(stderr, "ERROR: options of --full-duplex, --reverse, -d and -r not supported with multicast addresses\n"); + bail = true; + } + if (bail) + exit(1); + else + setMulticast(mExtSettings); + } +#ifndef HAVE_DECL_SO_BINDTODEVICE + if (mExtSettings->mIfrnametx) { + fprintf(stderr, "bind to device will be ignored because not supported\n"); + free(mExtSettings->mIfrnametx); + mExtSettings->mIfrnametx=NULL; + } +#endif + } + if ((mExtSettings->mIntervalMode == kInterval_Time) && (mExtSettings->mIntervalMode <= 0)) { + mExtSettings->mIntervalMode = kInterval_None; + mExtSettings->mInterval = 0; + } +} + +void Settings_GetUpperCaseArg (const char *inarg, char *outarg) { + int len = strlen(inarg); + strcpy(outarg,inarg); + + if ((len > 0) && (inarg[len-1] >='a') + && (inarg[len-1] <= 'z')) + outarg[len-1]= outarg[len-1]+'A'-'a'; +} + +void Settings_GetLowerCaseArg (const char *inarg, char *outarg) { + int len = strlen(inarg); + strcpy(outarg,inarg); + + if ((len > 0) && (inarg[len-1] >='A') + && (inarg[len-1] <= 'Z')) + outarg[len-1]= outarg[len-1]-'A'+'a'; +} + +/* + * Settings_GenerateListenerSettings + * Called to generate the settings to be passed to the Listener + * instance that will handle dual testings from the client side + * this should only return an instance if it was called on + * the struct thread_settings instance generated from the command line + * for client side execution + */ +#define DUALTIMER_MS 300 +void Settings_GenerateListenerSettings (struct thread_Settings *client, struct thread_Settings **listener) { + if ((client->mMode == kTest_DualTest) || (client->mMode == kTest_TradeOff)) { + Settings_Copy(client, listener, SHALLOW_COPY); + unsetDaemon((*listener)); + setCompat((*listener)); + if (client->mListenPort != 0) { + (*listener)->mPort = client->mListenPort; + } else { + (*listener)->mPort = client->mPort; + } + if (client->mMode == kTest_TradeOff) { + (*listener)->mAmount = client->mAmount + DUALTIMER_MS; + } else if (client->mMode == kTest_DualTest) { + (*listener)->mAmount = client->mAmount + (SLOPSECS * 100); + } + if ((client->mMode != kTest_Normal) && ((*listener)->mAmount < DUALTIMER_MS)) { + (*listener)->mAmount = DUALTIMER_MS; + } + (*listener)->mFileName = NULL; + (*listener)->mHost = NULL; + (*listener)->mLocalhost = NULL; + (*listener)->mOutputFileName = NULL; + (*listener)->mMode = kTest_Normal; + (*listener)->mThreadMode = kMode_Listener; + if (client->mHost != NULL) { + (*listener)->mHost = new char[strlen(client->mHost) + 1]; + strcpy((*listener)->mHost, client->mHost); + } + if (client->mLocalhost != NULL) { + (*listener)->mLocalhost = new char[strlen(client->mLocalhost) + 1]; + strcpy((*listener)->mLocalhost, client->mLocalhost); + } + if (client->mBufLen <= 0) { + if (isUDP((*listener))) { + (*listener)->mBufLen = kDefault_UDPBufLen; + } else { + (*listener)->mBufLen = kDefault_TCPBufLen; + } + } else { + (*listener)->mBufLen = client->mBufLen; + } + setReport((*listener)); + } else { + *listener = NULL; + } +} + +void Settings_ReadClientSettingsIsoch (struct thread_Settings **client, struct client_hdrext_isoch_settings *hdr) { + (*client)->mFPS = ntohl(hdr->FPSl); + (*client)->mFPS += ntohl(hdr->FPSu) / static_cast<double>(rMillion); + (*client)->mMean = ntohl(hdr->Meanl); + (*client)->mMean += ntohl(hdr->Meanu) / static_cast<double>(rMillion); + (*client)->mVariance = ntohl(hdr->Variancel); + (*client)->mVariance += ntohl(hdr->Varianceu) / static_cast<double>(rMillion); + (*client)->mBurstIPG = ntohl(hdr->BurstIPGl); + (*client)->mBurstIPG += ntohl(hdr->BurstIPGu) / static_cast<double>(rMillion); +} + +void Settings_ReadClientSettingsBurst (struct thread_Settings **client, struct client_hdrext_isoch_settings *hdr) { + (*client)->mFPS = ntohl(hdr->FPSl); + (*client)->mFPS += ntohl(hdr->FPSu) / static_cast<double>(rMillion); +} + +void Settings_ReadClientSettingsV1 (struct thread_Settings **client, struct client_hdr_v1 *hdr) { + (*client)->mTID = thread_zeroid(); + (*client)->mPort = static_cast<unsigned short>(ntohl(hdr->mPort)); + (*client)->mThreads = 1; + struct thread_Settings *tmpSettings = *client; + if (hdr->mBufLen != 0) { + (*client)->mBufLen = ntohl(hdr->mBufLen); + setBuflenSet(tmpSettings); + } else { +#ifdef DEFAULT_PAYLOAD_LEN_PER_MTU_DISCOVERY + checksock_max_udp_payload(tmpSettings); +#endif + } + (*client)->mAmount = ntohl(hdr->mAmount); + if (((*client)->mAmount & 0x80000000) > 0) { + setModeTime((*client)); +#ifndef WIN32 + (*client)->mAmount |= 0xFFFFFFFF00000000LL; +#else + (*client)->mAmount |= 0xFFFFFFFF00000000; +#endif + (*client)->mAmount = -(*client)->mAmount; + } else { + unsetModeTime((*client)); + } +} + +/* + * Settings_GenerateClientSettings + * + * Called by the Listener to generate the settings to be used by clients + * per things like dual tests. Set client pointer to null if a client isn't needed + * + * Note: mBuf should already be filled out per the Listener's apply_client_settings + */ +void Settings_GenerateClientSettings (struct thread_Settings *server, struct thread_Settings **client, void *mBuf) { + assert(server != NULL); + assert(mBuf != NULL); + uint32_t flags = isUDP(server) ? ntohl(*(uint32_t *)((char *)mBuf + sizeof(struct UDP_datagram))) : ntohl(*(uint32_t *)mBuf); + uint16_t upperflags = 0; + thread_Settings *reversed_thread = NULL; + *client = NULL; + bool v1test = (flags & HEADER_VERSION1) && !(flags & HEADER_VERSION2); +#ifdef HAVE_THREAD_DEBUG + if (v1test) + thread_debug("header set for a version 1 test"); +#endif + if (isFullDuplex(server) || isServerReverse(server)) + setTransferID(server, 1); + if (isFullDuplex(server) || v1test) { + Settings_Copy(server, client, SHALLOW_COPY); + reversed_thread = *client; + if (isFullDuplex(server) && !(flags & HEADER_VERSION1)) { + setFullDuplex(reversed_thread); + } else { + unsetFullDuplex(reversed_thread); + } + } else if (isServerReverse(server)) { + reversed_thread = server; + } else { + assert(0); + return; + } + reversed_thread->mThreadMode = kMode_Client; + + if (isUDP(server)) { // UDP test information passed in every packet per being stateless + struct client_udp_testhdr *hdr = static_cast<struct client_udp_testhdr *>(mBuf); + Settings_ReadClientSettingsV1(&reversed_thread, &hdr->base); + if (isFullDuplex(server) || v1test) { + server->mAmount = reversed_thread->mAmount + (SLOPSECS * 100); + } + if (v1test) { + setServerReverse(reversed_thread); + if (flags & RUN_NOW) { + reversed_thread->mMode = kTest_DualTest; + } else { + reversed_thread->mMode = kTest_TradeOff; + } + } + if (flags & HEADER_EXTEND) { + reversed_thread->mAppRate = ntohl(hdr->extend.lRate); +#ifdef HAVE_INT64_T + reversed_thread->mAppRate |= (static_cast<uint64_t>(ntohl(hdr->extend.uRate) >> 8) << 32); +#endif + upperflags = ntohs(hdr->extend.upperflags); + if (upperflags & HEADER_NOUDPFIN) { + setNoUDPfin(reversed_thread); + } + if ((upperflags & HEADER_UNITS_PPS) == HEADER_UNITS_PPS) { + reversed_thread->mAppRateUnits = kRate_PPS; + } else { + reversed_thread->mAppRateUnits = kRate_BW; + } + reversed_thread->mTOS = ntohs(hdr->extend.tos); + if (isIsochronous(server)) { + Settings_ReadClientSettingsIsoch(&reversed_thread, &hdr->isoch_settings); + } + if (upperflags & HEADER_FQRATESET) { + setFQPacing(reversed_thread); + reversed_thread->mFQPacingRate = ntohl(hdr->start_fq.fqratel); +#ifdef HAVE_INT64_T + reversed_thread->mFQPacingRate |= (static_cast<uint64_t>(ntohl(hdr->start_fq.fqrateu)) << 32); +#endif + } + } + } else { //tcp first payload + struct client_tcp_testhdr *hdr = static_cast<struct client_tcp_testhdr *>(mBuf); + Settings_ReadClientSettingsV1(&reversed_thread, &hdr->base); + + if (isFullDuplex(server) || v1test) { + server->mAmount = reversed_thread->mAmount + (SLOPSECS * 100); + } + if (v1test) { + setServerReverse(reversed_thread); + if (flags & RUN_NOW) { + reversed_thread->mMode = kTest_DualTest; + } else { + reversed_thread->mMode = kTest_TradeOff; + } + } + if (flags & HEADER_EXTEND) { + reversed_thread->mAppRate = ntohl(hdr->extend.lRate); +#ifdef HAVE_INT64_T + reversed_thread->mAppRate |= (static_cast<uint64_t>(ntohl(hdr->extend.uRate) >> 8) << 32); +#endif + upperflags = ntohs(hdr->extend.upperflags); + reversed_thread->mTOS = ntohs(hdr->extend.tos); + + if (isIsochronous(server)) { + Settings_ReadClientSettingsIsoch(&reversed_thread, &hdr->isoch_settings); + } else if (isPeriodicBurst(server)) { + Settings_ReadClientSettingsBurst(&reversed_thread, &hdr->isoch_settings); + } + if (upperflags & HEADER_FQRATESET) { + setFQPacing(reversed_thread); + reversed_thread->mFQPacingRate = ntohl(hdr->start_fq.fqratel); +#ifdef HAVE_INT64_T + reversed_thread->mFQPacingRate |= (static_cast<uint64_t>(ntohl(hdr->start_fq.fqrateu)) << 32); +#endif + } + } + } + unsetTxHoldback(reversed_thread); + setNoSettReport(reversed_thread); + setNoConnectSync(reversed_thread); + // for legacy -d and -r need so set the reversed threads mHost + if (v1test) { + reversed_thread->mHost = new char[REPORT_ADDRLEN]; + if ((reinterpret_cast<sockaddr*>(&server->peer))->sa_family == AF_INET) { + inet_ntop(AF_INET, &(reinterpret_cast<sockaddr_in*>(&server->peer))->sin_addr, + reversed_thread->mHost, REPORT_ADDRLEN); + } +#if HAVE_IPV6 + else { + inet_ntop(AF_INET6, &(reinterpret_cast<sockaddr_in6*>(&server->peer))->sin6_addr, + reversed_thread->mHost, REPORT_ADDRLEN); + } +#endif + } else { + reversed_thread->mMode = kTest_Normal; +#if HAVE_DECL_SO_MAX_PACING_RATE + if (isFQPacing(reversed_thread)) { + int rc = setsockopt(reversed_thread->mSock, SOL_SOCKET, SO_MAX_PACING_RATE, \ + &reversed_thread->mFQPacingRate, sizeof(reversed_thread->mFQPacingRate)); + WARN_errno(rc == SOCKET_ERROR, "setsockopt SO_MAX_PACING_RATE"); + #ifdef HAVE_THREAD_DEBUG + #ifdef HAVE_INT64_T + thread_debug("Set socket %d pacing rate to %ld byte/sec", reversed_thread->mSock, reversed_thread->mFQPacingRate); + #else + thread_debug("Set socket %d pacing rate to %d byte/sec", reversed_thread->mSock, reversed_thread->mFQPacingRate); + #endif + #endif + } +#endif // MAX_PACING_RATE + } +} + +int Settings_GenerateClientHdrV1 (struct thread_Settings *client, struct client_hdr_v1 *hdr) { + if (isBuflenSet(client)) { + hdr->mBufLen = htonl(client->mBufLen); + } else { + hdr->mBufLen = 0; + } + if (client->mListenPort != 0) { + hdr->mPort = htonl(client->mListenPort); + } else { + hdr->mPort = htonl(client->mPort); + } + hdr->numThreads = htonl(client->mThreads); + if (isModeTime(client)) { + hdr->mAmount = htonl(-(long)client->mAmount); + } else { + hdr->mAmount = htonl((long)client->mAmount); + hdr->mAmount &= htonl(0x7FFFFFFF); + } + return (sizeof(struct client_hdr_v1)); +} + +/* + * Settings_GenerateClientHdr + * + * Called to generate the client header to be passed to the listener/server + * + * This will handle: + * o) dual testings from the listener/server side + * o) advanced udp test settings + * + * Returns size of header in bytes + */ +int Settings_GenerateClientHdr (struct thread_Settings *client, void *testhdr, struct timeval startTime) { + uint16_t len = 0; + uint16_t upperflags = 0; + uint16_t lowerflags = 0; + uint32_t flags = 0; + + // Check the corner case of small packets and trip times + if (isUDP(client) && isSmallTripTime(client)) { + int buflen = (client->mBufLen < (int) sizeof(struct client_udpsmall_testhdr)) ? client->mBufLen \ + : sizeof(struct client_udpsmall_testhdr); + struct client_udpsmall_testhdr *hdr = static_cast<struct client_udpsmall_testhdr *>(testhdr); + memset(hdr, 0, buflen); + hdr->flags = htons(HEADER16_SMALL_TRIPTIMES); +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDP small trip times flags = %X", ntohs(hdr->flags)); +#endif + return (MINIPERFPAYLOAD); + } + // flags common to both TCP and UDP + if (isReverse(client) && !isCompat(client)) { + upperflags |= HEADER_REVERSE; + if (isTxStartTime(client) && !TimeZero(startTime)) { + upperflags |= HEADER_EPOCH_START; + } + } + if (isFullDuplex(client) && !isCompat(client)) { + upperflags |= HEADER_FULLDUPLEX; + if (isTxStartTime(client) && !TimeZero(startTime)) { + upperflags |= HEADER_EPOCH_START; + } + } + if (isTxStartTime(client) && isTripTime(client) && !TimeZero(startTime)) { + upperflags |= HEADER_EPOCH_START; + } + + // Now setup UDP and TCP specific passed settings from client to server + if (isUDP(client)) { // UDP test information passed in every packet per being stateless + struct client_udp_testhdr *hdr = static_cast<struct client_udp_testhdr *>(testhdr); + int buflen = (client->mBufLen < (int) sizeof(struct client_udp_testhdr)) ? client->mBufLen \ + : sizeof(struct client_udp_testhdr); + memset(hdr, 0, buflen); + flags |= HEADER_SEQNO64B; // use 64 bit by default + flags |= HEADER_EXTEND; + hdr->extend.version_u = htonl(IPERF_VERSION_MAJORHEX); + hdr->extend.version_l = htonl(IPERF_VERSION_MINORHEX); + hdr->extend.tos = htons(client->mTOS & 0xFF); + if (isBWSet(client) && (client->mAppRate > 0)) { + uint64_t bw = 0; + if ((client->mAppRateUnits == kRate_PPS) && (isFullDuplex(client) || isReverse(client) || (client->mMode != kTest_Normal))) { + bw = client->mAppRate * 8 * client->mBufLen; + } else { + bw = client->mAppRate; + } + hdr->extend.lRate = htonl((uint32_t)(bw)); +#ifdef HAVE_INT64_T + hdr->extend.uRate = htonl(((uint32_t)(bw >> 32)) << 8); +#endif + } else { + hdr->extend.lRate = htonl(kDefault_UDPRate); + hdr->extend.uRate = 0x0; + } + len += sizeof(struct client_hdrext); + len += Settings_GenerateClientHdrV1(client, &hdr->base); + if (!isCompat(client) && (client->mMode != kTest_Normal)) { + flags |= HEADER_VERSION1; + if (client->mMode == kTest_DualTest) + flags |= RUN_NOW; + hdr->base.flags = htonl(flags); + } + /* + * set the default offset where underlying "inline" subsystems can write into the udp payload + */ + if (isL2LengthCheck(client)) { + flags |= HEADER_UDPTESTS; + if (isL2LengthCheck(client)) { + upperflags |= HEADER_L2LENCHECK; + if (isIPV6(client)) + upperflags |= HEADER_L2ETHPIPV6; + } + } + if (isIsochronous(client)) { + flags |= (HEADER_UDPTESTS | HEADER_EXTEND) ; + upperflags |= HEADER_ISOCH; + if (isFullDuplex(client) || isReverse(client)) { + upperflags |= HEADER_ISOCH_SETTINGS; + hdr->isoch_settings.FPSl = htonl((long)(client->mFPS)); + hdr->isoch_settings.FPSu = htonl((long)((client->mFPS - (long)(client->mFPS)) * rMillion)); + hdr->isoch_settings.Meanl = htonl((long)(client->mMean)); + hdr->isoch_settings.Meanu = htonl((long)(((client->mMean) - (long)(client->mMean)) * rMillion)); + hdr->isoch_settings.Variancel = htonl((long)(client->mVariance)); + hdr->isoch_settings.Varianceu = htonl((long)((client->mVariance - (long)(client->mVariance)) * rMillion)); + hdr->isoch_settings.BurstIPGl = htonl((long)(client->mBurstIPG)); + hdr->isoch_settings.BurstIPGu = htonl((long)((client->mBurstIPG - (long)(client->mBurstIPG)) * rMillion)); + len += sizeof(struct client_hdrext_isoch_settings); + } + } + if (isReverse(client) || isFullDuplex(client)) { + flags |= (HEADER_UDPTESTS | HEADER_VERSION2); + } + if (isNoUDPfin(client)) { + flags |= (HEADER_UDPTESTS | HEADER_EXTEND); + upperflags |= HEADER_NOUDPFIN; + } + if (isTripTime(client) || isFQPacing(client) || isTxStartTime(client)) { + flags |= HEADER_UDPTESTS; + if (isTripTime(client) || isTxStartTime(client)) { + hdr->start_fq.start_tv_sec = htonl(startTime.tv_sec); + hdr->start_fq.start_tv_usec = htonl(startTime.tv_usec); + if (isTripTime(client)) + upperflags |= HEADER_TRIPTIME; + } + if (isFQPacing(client)) { + upperflags |= HEADER_FQRATESET; + hdr->start_fq.fqratel = htonl((uint32_t) client->mFQPacingRate); +#ifdef HAVE_INT64_T + hdr->start_fq.fqrateu = htonl((uint32_t) (client->mFQPacingRate >> 32)); +#endif + } + } + // Write flags to header so the listener can determine the tests requested + hdr->extend.upperflags = htons(upperflags); + hdr->extend.lowerflags = htons(lowerflags); + + // isoch payload is an enclave field between v 0.13 and v0.14 + // so figure out if it's there now - UDP only + // will be filled in by the client write + if (isTripTime(client) || isFQPacing(client) || isIsochronous(client)) + len += sizeof (struct isoch_payload); + + if (len > 0) { + len += sizeof(struct UDP_datagram); + flags |= ((len << 1) & HEADER_KEYLEN_MASK) | HEADER_LEN_BIT; + } + hdr->base.flags = htonl(flags); +#ifdef HAVE_THREAD_DEBUG + thread_debug("UDPflags = %X", ntohl(hdr->base.flags)); +#endif + } else { // TCP first write with test information + struct client_tcp_testhdr *hdr = static_cast<struct client_tcp_testhdr *>(testhdr); +#ifdef HAVE_THREAD_DEBUG + thread_debug("Client header init size %d (%p)", sizeof(struct client_tcp_testhdr), (void *) hdr); +#endif + if (isBounceBack(client)) { + flags = HEADER_BOUNCEBACK; + len = sizeof(struct bounceback_hdr); + } else { + int buflen = (client->mBufLen < (int) sizeof(struct client_tcp_testhdr)) ? client->mBufLen \ + : sizeof(struct client_tcp_testhdr); + memset(hdr, 0, buflen); + flags |= HEADER_EXTEND; + hdr->extend.version_u = htonl(IPERF_VERSION_MAJORHEX); + hdr->extend.version_l = htonl(IPERF_VERSION_MINORHEX); + hdr->extend.tos = htons(client->mTOS & 0xFF); + if (isBWSet(client)) { + hdr->extend.lRate = htonl((uint32_t)(client->mAppRate)); +#ifdef HAVE_INT64_T + hdr->extend.uRate = htonl(((uint32_t)(client->mAppRate >> 32)) << 8); +#endif + } + len += sizeof(struct client_hdrext); + len += Settings_GenerateClientHdrV1(client, &hdr->base); + if (!isCompat(client) && (client->mMode != kTest_Normal)) { + flags |= HEADER_VERSION1; + if (client->mMode == kTest_DualTest) + flags |= RUN_NOW; + } + if (isPeerVerDetect(client)) { + flags |= (HEADER_V2PEERDETECT | HEADER_VERSION2); + } + if (isTripTime(client) || isFQPacing(client) || isIsochronous(client) || isTxStartTime(client)) { + hdr->start_fq.start_tv_sec = htonl(startTime.tv_sec); + hdr->start_fq.start_tv_usec = htonl(startTime.tv_usec); + hdr->start_fq.fqratel = htonl((uint32_t) client->mFQPacingRate); +#ifdef HAVE_INT64_T + hdr->start_fq.fqrateu = htonl((uint32_t) (client->mFQPacingRate >> 32)); +#endif + len += sizeof(struct client_hdrext_starttime_fq); + // Set flags on + if (isTripTime(client)) { + upperflags |= HEADER_TRIPTIME; + } + if (isFQPacing(client)) { + upperflags |= HEADER_FQRATESET; + } + } +#if HAVE_DECL_TCP_NOTSENT_LOWAT + if (isWritePrefetch(client) && (isReverse(client) || isFullDuplex(client))) { + upperflags |= HEADER_WRITEPREFETCH; + hdr->extend.TCPWritePrefetch = htonl((long)client->mWritePrefetch); + } +#endif +#if HAVE_DECL_TCP_QUICKACK + if (isTcpQuickAck(client) && (!isReverse(client) || isFullDuplex(client))) { + upperflags |= HEADER_TCPQUICKACK; + } +#endif + if (isIsochronous(client) || isPeriodicBurst(client)) { + if (isPeriodicBurst(client)) { + upperflags |= HEADER_PERIODICBURST; // overload the isoch settings + } else { + upperflags |= HEADER_ISOCH; + } + if (isFullDuplex(client) || isReverse(client) || isPeriodicBurst(client)) { + hdr->isoch_settings.FPSl = htonl((long)client->mFPS); + hdr->isoch_settings.FPSu = htonl((long)((client->mFPS - (long)(client->mFPS)) * rMillion)); + hdr->isoch_settings.Variancel = htonl((long)(client->mVariance)); + hdr->isoch_settings.Varianceu = htonl((long)((client->mVariance - (long)(client->mVariance)) * rMillion)); + if (!isPeriodicBurst(client)) { + hdr->isoch_settings.Meanl = htonl((long)(client->mMean)); + hdr->isoch_settings.Meanu = htonl((long)(((client->mMean) - (long)(client->mMean)) * rMillion)); + hdr->isoch_settings.BurstIPGl = htonl((long)client->mBurstIPG); + hdr->isoch_settings.BurstIPGu = htonl(((long)(client->mBurstIPG) - (long)client->mBurstIPG * rMillion)); + } else { + hdr->isoch_settings.Meanl = htonl((long)(client->mBurstSize)); + } + len += sizeof(struct client_hdrext_isoch_settings); + } + } + if (isReverse(client) || isFullDuplex(client)) { + flags |= HEADER_VERSION2; + } + hdr->extend.upperflags = htons(upperflags); + hdr->extend.lowerflags = htons(lowerflags); + if (len > 0) { + flags |= HEADER_LEN_BIT; + int keylen = 0; + if (!isServerReverse(client) && isPermitKey(client) && (client->mPermitKey[0] != '\0')) { + keylen = static_cast<int>(strnlen(client->mPermitKey, MAX_PERMITKEY_LEN)); + flags |= HEADER_KEYCHECK; + struct permitKey *thiskey = reinterpret_cast<struct permitKey *>(static_cast<char *>(testhdr) + len); + thiskey->length = htons((uint16_t)keylen); + memcpy(thiskey->value, client->mPermitKey, keylen); + len += sizeof(thiskey->length); + } + flags |= ((len << 1) & HEADER_KEYLEN_MASK); // this is the key value offset passed to the server + len += keylen; + } + } + hdr->base.flags = htonl(flags); + } + return (len); +} + +int Settings_ClientTestHdrLen (uint32_t flags, struct thread_Settings *inSettings) { + int peeklen = 0; + if ((flags & HEADER_VERSION1) || (flags & HEADER_VERSION2) || (flags & HEADER_EXTEND) || isPermitKey(inSettings)) { + if (flags & HEADER_LEN_BIT) { + peeklen = static_cast<int>((flags & HEADER_LEN_MASK) >> 1); + if (peeklen > MAX_HEADER_LEN) { + fprintf(stderr, "WARN: header of %d length too large\n", peeklen); + peeklen = -1; + } + } else { + if (flags & (HEADER_VERSION1 | HEADER_EXTEND)) { + peeklen = sizeof(struct client_hdr_v1); + } + if (flags & (HEADER_VERSION2 | HEADER_EXTEND)) { + peeklen += sizeof(struct client_hdrext); + } + } + } + return peeklen; +} diff --git a/src/SocketAddr.c b/src/SocketAddr.c new file mode 100644 index 0000000..4322475 --- /dev/null +++ b/src/SocketAddr.c @@ -0,0 +1,941 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * Socket.cpp + * by Ajay Tirumala <tirumala@ncsa.uiuc.edu> + * and Mark Gates <mgates@nlanr.net> + * ------------------------------------------------------------------- */ + +#define HEADERS() + +#include "headers.h" + +#include "SocketAddr.h" +#ifdef HAVE_IFADDRS_H +#include <ifaddrs.h> +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------------------------------------------------------- + * Create a socket address. If inHostname is not null, resolve that + * address and fill it in. Fill in the port number. Use IPv6 ADDR_ANY + * if that is what is desired. + * ------------------------------------------------------------------- */ +void SockAddr_remoteAddr (struct thread_Settings *inSettings) { + if (SockAddr_isZeroAddress(&inSettings->peer) == 0) { + if (inSettings->mHost != NULL) { + SockAddr_setHostname(inSettings->mHost, &inSettings->peer, isIPV6(inSettings)); + if (inSettings->incrdstip) + SockAddr_incrAddress(&inSettings->peer, inSettings->incrdstip); + } else { +#if HAVE_IPV6 + if (isIPV6(inSettings)) { + ((struct sockaddr*)&inSettings->peer)->sa_family = AF_INET6; + } else { + ((struct sockaddr*)&inSettings->peer)->sa_family = AF_INET; + } + } + if (SockAddr_isIPv6(&inSettings->peer)) { + inSettings->size_peer = sizeof(struct sockaddr_in6); + } else { + inSettings->size_peer = sizeof(struct sockaddr_in); + } +#else + } + ((struct sockaddr*)&inSettings->peer)->sa_family = AF_INET; + inSettings->size_peer = sizeof(struct sockaddr_in); +#endif + SockAddr_setPort(&inSettings->peer, inSettings->mPort); + } +} +// end SocketAddr + +void SockAddr_localAddr (struct thread_Settings *inSettings) { + SockAddr_zeroAddress(&inSettings->local); + + if (inSettings->mLocalhost != NULL) { + SockAddr_setHostname(inSettings->mLocalhost, &inSettings->local, + isIPV6(inSettings)); + if (inSettings->incrsrcip) + SockAddr_incrAddress(&inSettings->local, inSettings->incrsrcip); + + } else { +#if HAVE_IPV6 + if (isIPV6(inSettings)) { + ((struct sockaddr*)&inSettings->local)->sa_family = AF_INET6; + } else { + ((struct sockaddr*)&inSettings->local)->sa_family = AF_INET; + } + } + + if (SockAddr_isIPv6(&inSettings->local)) { + inSettings->size_local = sizeof(struct sockaddr_in6); + } else { + inSettings->size_local = sizeof(struct sockaddr_in); + } +#else + ((struct sockaddr*)&inSettings->local)->sa_family = AF_INET; + } + inSettings->size_local = sizeof(struct sockaddr_in); +#endif + /* + * This section handles the *local* port binding (which is messy) + * Quintuple is Proto:LocalIP:LocalPort:DstIP:DstPort + * + * There are three threads being Client, Listener and Server + * mPort comes from the -p command (which defaults to 5001) + * mLocalhost indicates -B set requesting a local binding + * mBindPort comes from -B IP:<port> (where port defaults to 0) + * Multicast IP address, e.g. 239.1.1.1, is set per a -B + * Zero will cause the OS to auto assign a LocalPort + * For iperf -s; Windows uses listener thread, *nix a server thread + * (so, effectively, Listener and Server threads are the same) + * Client threads support either auto assignment (default) or + * user specified (via -B) + */ + if (inSettings->mLocalhost == NULL) { + if (inSettings->mThreadMode == kMode_Client) { + /* + * Client thread, -p and no -B, + * OS will auto assign a free local port + */ + SockAddr_setPortAny (&inSettings->local); + } else { + /* Server or Listener thread, -p and no -B */ + SockAddr_setPort(&inSettings->local, inSettings->mPort); + } + } else { + // -B was set + if (inSettings->mThreadMode == kMode_Client) { + /* Client thread */ + if (inSettings->mBindPort) { + /* + * User specified port so use it + */ +#if HAVE_DECL_SO_REUSEPORT + int boolean = 1; + Socklen_t len = sizeof(boolean); + setsockopt(inSettings->mSock, SOL_SOCKET, SO_REUSEPORT, (char*) &boolean, len); +#endif + SockAddr_setPort(&inSettings->local, (inSettings->mBindPort + inSettings->incrsrcport)); + } else { + /* + * No user specified port, let OS assign a free one + */ + SockAddr_setPortAny (&inSettings->local); + } + } else { + /* + * Server or Listener thread, both always use -p port + * any -B port will be ignored + */ + SockAddr_setPort(&inSettings->local, inSettings->mPort); + } + } +} +// end SocketAddr + +/* ------------------------------------------------------------------- + * Resolve the hostname address and fill it in. + * ------------------------------------------------------------------- */ +void SockAddr_setHostname (const char* inHostname, iperf_sockaddr *inSockAddr, int isIPv6) { + // ..I think this works for both ipv6 & ipv4... we'll see + bool found = false; + int ret_ga; + struct addrinfo *res = NULL, *itr; + struct addrinfo hints; + memset(&hints, 0, sizeof(hints)); + if (!isIPv6) { + hints.ai_family = AF_INET; + ret_ga = getaddrinfo(inHostname, NULL, &hints, &res); + if (ret_ga == 0) { + if (res && res->ai_addr) { + itr = res; + // Now search for a IPv4 Address + while (itr != NULL) { + if (itr->ai_family == AF_INET) { + memcpy(inSockAddr, (itr->ai_addr), (itr->ai_addrlen)); + freeaddrinfo(res); + found = true; + break; + } else { + itr = itr->ai_next; + } + } + } + } + } +#if HAVE_IPV6 + if (!found) { + hints.ai_family = AF_INET6; + ret_ga = getaddrinfo(inHostname, NULL, &hints, &res); + if (ret_ga == 0) { + if (res && res->ai_addr) { + // Now search for a IPv6 Address + itr = res; + while (itr != NULL) { + if (itr->ai_family == AF_INET6) { + memcpy(inSockAddr, (itr->ai_addr), (itr->ai_addrlen)); + freeaddrinfo(res); + found = true; + break; + } else { + itr = itr->ai_next; + } + } + } + } + } +#endif // IPV6 + // getaddrinfo didn't find an address, fallback to gethostbyname for v4 + if (!found && !isIPv6) { + // first try just converting dotted decimal + // on Windows gethostbyname doesn't understand dotted decimal + struct sockaddr_in *sockaddr = (struct sockaddr_in *)inSockAddr; + int rc = inet_pton(AF_INET, inHostname, &sockaddr->sin_addr); + sockaddr->sin_family = AF_INET; + if (rc == 0) { + struct hostent *hostP = gethostbyname(inHostname); + if (hostP == NULL) { + /* this is the same as herror() but works on more systems */ + const char* format; + switch (h_errno) { + case HOST_NOT_FOUND: + format = "%s: Unknown host\n"; + break; + case NO_ADDRESS: + format = "%s: No address associated with name\n"; + break; + case NO_RECOVERY: + format = "%s: Unknown server error\n"; + break; + case TRY_AGAIN: + format = "%s: Host name lookup failure\n"; + break; + default: + format = "%s: Unknown resolver error\n"; + break; + } + fprintf(stderr, format, inHostname); + exit(1); + return; // TODO throw + } + found = true; + memcpy(&sockaddr->sin_addr, *(hostP->h_addr_list), (hostP->h_length)); + } + } + if (!found) { + fprintf(stderr, "ERROR: failed to find an ip address for host '%s'\n", inHostname); + exit(1); + } +} +// end setHostname + +/* ------------------------------------------------------------------- + * Copy the IP address into the string. + * ------------------------------------------------------------------- */ +void SockAddr_getHostAddress (iperf_sockaddr *inSockAddr, char* outAddress, + size_t len) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET) { + inet_ntop(AF_INET, &(((struct sockaddr_in*) inSockAddr)->sin_addr), + outAddress, len); + } +#if HAVE_IPV6 + else { + inet_ntop(AF_INET6, &(((struct sockaddr_in6*) inSockAddr)->sin6_addr), + outAddress, len); + } +#endif +} +// end getHostAddress + +/* ------------------------------------------------------------------- + * Set the address to any (generally all zeros). + * ------------------------------------------------------------------- */ +void SockAddr_setAddressAny (iperf_sockaddr *inSockAddr) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET) + memset(&(((struct sockaddr_in*) inSockAddr)->sin_addr), 0, + sizeof(struct in_addr)); +#if HAVE_IPV6 + else + memset(&(((struct sockaddr_in6*) inSockAddr)->sin6_addr), 0, + sizeof(struct in6_addr)); +#endif +} +// end setAddressAny + +/* ------------------------------------------------------------------- + * Incr the address by value + * ------------------------------------------------------------------- */ +void SockAddr_incrAddress (iperf_sockaddr *inSockAddr, int value) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET) + ((struct sockaddr_in *)inSockAddr)->sin_addr.s_addr += htonl(value); +#if HAVE_IPV6 + else { + uint32_t *lower = (uint32_t *)&((struct sockaddr_in6 *)inSockAddr)->sin6_addr.s6_addr[12]; + *lower += htonl(value); + } +#endif +} +// end setAddressAny + + +/* ------------------------------------------------------------------- + * Set the port to the given port. Handles the byte swapping. + * ------------------------------------------------------------------- */ +void SockAddr_setPort (iperf_sockaddr *inSockAddr, unsigned short inPort) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET) + ((struct sockaddr_in*) inSockAddr)->sin_port = htons(inPort); +#if HAVE_IPV6 + else + ((struct sockaddr_in6*) inSockAddr)->sin6_port = htons(inPort); +#endif + +} +// end setPort + +/* ------------------------------------------------------------------- + * Set the port to zero, which lets the OS pick the port. + * ------------------------------------------------------------------- */ +void SockAddr_setPortAny (iperf_sockaddr *inSockAddr) { + SockAddr_setPort(inSockAddr, 0); +} +// end setPortAny + +/* ------------------------------------------------------------------- + * Return the port. Handles the byte swapping. + * ------------------------------------------------------------------- */ +unsigned short SockAddr_getPort (iperf_sockaddr *inSockAddr) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET) + return ntohs(((struct sockaddr_in*) inSockAddr)->sin_port); +#if HAVE_IPV6 + else + return ntohs(((struct sockaddr_in6*) inSockAddr)->sin6_port); +#endif + return 0; + +} +// end getPort + +/* ------------------------------------------------------------------- + * Return the IPv4 Internet Address from the sockaddr_in structure + * ------------------------------------------------------------------- */ +struct in_addr* SockAddr_get_in_addr (iperf_sockaddr *inSockAddr) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET) + return &(((struct sockaddr_in*) inSockAddr)->sin_addr); + + fprintf(stderr, "FATAL: get_in_addr called on IPv6 address\n"); + return NULL; +} + +/* ------------------------------------------------------------------- + * Return the IPv6 Internet Address from the sockaddr_in6 structure + * ------------------------------------------------------------------- */ +#if HAVE_IPV6 +struct in6_addr* SockAddr_get_in6_addr (iperf_sockaddr *inSockAddr) { + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET6) + return &(((struct sockaddr_in6*) inSockAddr)->sin6_addr); + + fprintf(stderr, "FATAL: get_in6_addr called on IPv4 address\n"); + return NULL; +} +#endif + + +/* ------------------------------------------------------------------- + * Return the size of the appropriate address structure. + * ------------------------------------------------------------------- */ +Socklen_t SockAddr_get_sizeof_sockaddr (iperf_sockaddr *inSockAddr) { +#if HAVE_IPV6 + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET6) { + return(sizeof(struct sockaddr_in6)); + } +#endif + return(sizeof(struct sockaddr_in)); +} +// end get_sizeof_sockaddr + + +/* ------------------------------------------------------------------- + * Return if IPv6 socket + * ------------------------------------------------------------------- */ +int SockAddr_isIPv6 (iperf_sockaddr *inSockAddr) { +#if HAVE_IPV6 + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET6) { + return 1; + } +#endif + return 0; +} +// end get_sizeof_sockaddr + +/* ------------------------------------------------------------------- + * Return true if the address is multicast ip address. + * ------------------------------------------------------------------- */ +int SockAddr_isMulticast (iperf_sockaddr *inSockAddr) { +#if HAVE_IPV6 + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET6) { + return(IN6_IS_ADDR_MULTICAST(&(((struct sockaddr_in6*) inSockAddr)->sin6_addr))); + } else +#endif + { + +#ifdef IN_MULTICAST + // 224.0.0.0 to 239.255.255.255 (e0.00.00.00 to ef.ff.ff.ff) + // convert from network to host byte order + uint32_t maddr = ntohl((uint32_t)(((struct sockaddr_in*) inSockAddr)->sin_addr.s_addr)); + return (IN_MULTICAST(maddr)); +#else + const unsigned long kClassD_Mask = 0xf0000000L; + const unsigned long kMulticast = 0xe0000000L; + return((((ntohl(((struct sockaddr_in*) inSockAddr)->sin_addr.s_addr)) & kClassD_Mask) == kMulticast)); +#endif + } +} +// end isMulticast + +/* ------------------------------------------------------------------- + * Return true if the address is multicast ip address. + * ------------------------------------------------------------------- */ +int SockAddr_isLinklocal (iperf_sockaddr *inSockAddr) { +#if HAVE_IPV6 + if (((struct sockaddr*)inSockAddr)->sa_family == AF_INET6) { + return(IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6*) inSockAddr)->sin6_addr))); + } else +#endif + { + return 0; + } +} + +/* ------------------------------------------------------------------- + * Zero out the address structure. + * ------------------------------------------------------------------- */ +void SockAddr_zeroAddress (iperf_sockaddr *inSockAddr) { + memset(inSockAddr, 0, sizeof(iperf_sockaddr)); +} + +int SockAddr_isZeroAddress (iperf_sockaddr *inSockAddr) { + iperf_sockaddr zeroSockAddr; + memset(&zeroSockAddr, 0, sizeof(iperf_sockaddr)); + return(memcmp((void *)inSockAddr, (void *)&zeroSockAddr, sizeof(iperf_sockaddr))); +} + +/* ------------------------------------------------------------------- + * Compare two sockaddrs and return true if they are equal + * ------------------------------------------------------------------- */ +int SockAddr_are_Equal (iperf_sockaddr *first, iperf_sockaddr *second) { + if (((struct sockaddr*)first)->sa_family == AF_INET && ((struct sockaddr*)second)->sa_family == AF_INET) { + // compare IPv4 adresses + return(((long) ((struct sockaddr_in*)first)->sin_addr.s_addr == (long) ((struct sockaddr_in*)second)->sin_addr.s_addr) + && (((struct sockaddr_in*)first)->sin_port == ((struct sockaddr_in*)second)->sin_port)); + } +#if HAVE_IPV6 + if (((struct sockaddr*)first)->sa_family == AF_INET6 && ((struct sockaddr*)second)->sa_family == AF_INET6) { + // compare IPv6 addresses + return(!memcmp(((struct sockaddr_in6*)first)->sin6_addr.s6_addr, ((struct sockaddr_in6*)second)->sin6_addr.s6_addr, sizeof(struct in6_addr)) + && (((struct sockaddr_in6*)first)->sin6_port == ((struct sockaddr_in6*)second)->sin6_port)); + } +#endif + return 0; +} + +/* ------------------------------------------------------------------- + * Compare two sockaddrs and return true if the hosts are equal + * ------------------------------------------------------------------- */ +int SockAddr_Hostare_Equal (iperf_sockaddr* first, iperf_sockaddr *second) { + if (((struct sockaddr*)first)->sa_family == AF_INET && ((struct sockaddr*)second)->sa_family == AF_INET) { + // compare IPv4 adresses + return((long) ((struct sockaddr_in*)first)->sin_addr.s_addr == + (long) ((struct sockaddr_in*)second)->sin_addr.s_addr); + } +#if HAVE_IPV6 + if (((struct sockaddr*)first)->sa_family == AF_INET6 && ((struct sockaddr*)second)->sa_family == AF_INET6) { + // compare IPv6 addresses + return(!memcmp(((struct sockaddr_in6*)first)->sin6_addr.s6_addr, + ((struct sockaddr_in6*)second)->sin6_addr.s6_addr, sizeof(struct in6_addr))); + } +#endif + return 0; +} + +/* ------------------------------------------------------------------- + * Find the interface name of a connected socket (when not already set) + * Can be forced with -B <ip>%<name> (server), -c <ip>%<name> (client) + * Note that kernel maps, e.g. via routing tables, to the actual device + * so these can change. Assume they won't change during the life + * of a thread. + * + * Store (and cache) the results in the thread settings structure + * Return 0 if set, -1 if not + * ------------------------------------------------------------------- */ +int SockAddr_Ifrname (struct thread_Settings *inSettings) { +#ifdef HAVE_IFADDRS_H + if (inSettings->mIfrname == NULL) { + struct sockaddr_storage myaddr; + struct ifaddrs* ifaddr; + struct ifaddrs* ifa; + socklen_t addr_len; + addr_len = sizeof(struct sockaddr_storage); + getsockname(inSettings->mSock, (struct sockaddr*)&myaddr, &addr_len); + getifaddrs(&ifaddr); + + // look which interface contains the desired IP per getsockname() which sets myaddr + // When found, ifa->ifa_name contains the name of the interface (eth0, eth1, ppp0...) + if (myaddr.ss_family == AF_INET) { + // v4 socket family (supports v4 only) + struct sockaddr_in* addr = (struct sockaddr_in*)&myaddr; + for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { + if ((ifa->ifa_addr) && (ifa->ifa_addr->sa_family == AF_INET)) { + struct sockaddr_in* inaddr = (struct sockaddr_in*)ifa->ifa_addr; + if ((inaddr->sin_addr.s_addr == addr->sin_addr.s_addr) && (ifa->ifa_name)) { + // Found v4 address in v4 addr family, copy it to thread settings structure + inSettings->mIfrname = calloc (strlen(ifa->ifa_name) + 1, sizeof(char)); + strcpy(inSettings->mIfrname, ifa->ifa_name); + break; + } + } + } + } else if (myaddr.ss_family == AF_INET6) { + // v6 socket family (supports both v4 and v6) + struct sockaddr_in6* addr = (struct sockaddr_in6*)&myaddr; + // Link local address are shared amongst all devices + // Try to pull the interface from the destination + if ((inSettings->mThreadMode == kMode_Client) && (IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr))) { + char *results; + char *copy = (char *)malloc(strlen(inSettings->mHost)+1); + strcpy(copy,(const char *)inSettings->mHost); + if (((results = strtok(copy, "%")) != NULL) && ((results = strtok(NULL, "%")) != NULL)) { + inSettings->mIfrname = calloc (strlen(results) + 1, sizeof(char)); + strcpy(inSettings->mIfrname, results); + } + free(copy); + } else if ((inSettings->mThreadMode == kMode_Server) && (IN6_IS_ADDR_V4MAPPED (&addr->sin6_addr))) { + for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { + if ((ifa->ifa_addr) && (ifa->ifa_addr->sa_family == AF_INET)) { + struct sockaddr_in* inaddr = (struct sockaddr_in*)ifa->ifa_addr; + uint32_t v4; + memcpy(&v4, &addr->sin6_addr.s6_addr[12], 4); + if ((ifa->ifa_name) && (inaddr->sin_addr.s_addr == v4)) { + // Found v4 address in v4 addr family, copy it to thread settings structure + inSettings->mIfrname = calloc (strlen(ifa->ifa_name) + 1, sizeof(char)); + strcpy(inSettings->mIfrname, ifa->ifa_name); + break; + } + } + } + } else { + // Hunt the v6 interfaces + for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { + if ((ifa->ifa_addr) && (ifa->ifa_addr->sa_family == AF_INET6)) { + struct sockaddr_in6* inaddr = (struct sockaddr_in6*)ifa->ifa_addr; + if ((ifa->ifa_name) && (IN6_ARE_ADDR_EQUAL(&addr->sin6_addr, &inaddr->sin6_addr))) { + // Found v6 address in v6 addr family, copy it to thread settings structure + inSettings->mIfrname = calloc (strlen(ifa->ifa_name) + 1, sizeof(char)); + strcpy(inSettings->mIfrname, ifa->ifa_name); + break; + } + } + } + } + } + freeifaddrs(ifaddr); + } +#endif + return ((inSettings->mIfrname == NULL) ? -1 : 0); +} + + +#if defined(HAVE_LINUX_FILTER_H) && defined(HAVE_AF_PACKET) +int SockAddr_Drop_All_BPF (int sock) { + struct sock_filter udp_filter[] = { + { 0x6, 0, 0, 0x00000000 }, + }; + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} + +// +// [root@ryzen3950 iperf2-code]# tcpdump ip and udp dst port 5001 -e -dd -i any +// tcpdump: data link type LINUX_SLL2 +// { 0x28, 0, 0, 0x00000000 }, +// { 0x15, 0, 8, 0x00000800 }, +// { 0x30, 0, 0, 0x0000001d }, +// { 0x15, 0, 6, 0x00000011 }, +// { 0x28, 0, 0, 0x0000001a }, +// { 0x45, 4, 0, 0x00001fff }, +// { 0xb1, 0, 0, 0x00000014 }, +// { 0x48, 0, 0, 0x00000016 }, +// { 0x15, 0, 1, 0x00001389 }, +// { 0x6, 0, 0, 0x00040000 }, +// { 0x6, 0, 0, 0x00000000 }, + +// { 0x28, 0, 0, 0x00000014 }, +// { 0x45, 4, 0, 0x00001fff }, +// { 0xb1, 0, 0, 0x0000001e }, +// { 0x48, 0, 0, 0x00000010 }, +// { 0x15, 0, 1, 0x00001389 }, + + +int SockAddr_v4_Accept_BPF (int sock, uint16_t port) { + // tcpdump udp dst port 5001 -dd to get c code filter + // UDP port is the 5 and 13 bytecodes (5001 = 0x1389) + // see linux/filter.h + struct sock_filter udp_filter[] = { + { 0x28, 0, 0, 0x0000000c }, + { 0x15, 0, 8, 0x00000800 }, + { 0x30, 0, 0, 0x00000017 }, + { 0x15, 0, 6, 0x00000011 }, + { 0x28, 0, 0, 0x00000014 }, + { 0x45, 4, 0, 0x00001fff }, + { 0xb1, 0, 0, 0x0000000e }, + { 0x48, 0, 0, 0x00000010 }, + { 0x15, 0, 1, 0x00001389 }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + }; + udp_filter[8].k = port; + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} + +//[root@ryzen3950 iperf2-code]# tcpdump udp dst port 5001 and dst host 1.1.1.1 -dd +//Warning: assuming Ethernet +//{ 0x28, 0, 0, 0x0000000c }, +//{ 0x15, 11, 0, 0x000086dd }, +//{ 0x15, 0, 10, 0x00000800 }, +//{ 0x30, 0, 0, 0x00000017 }, +//{ 0x15, 0, 8, 0x00000011 }, +//{ 0x28, 0, 0, 0x00000014 }, +//{ 0x45, 6, 0, 0x00001fff }, +//{ 0xb1, 0, 0, 0x0000000e }, +//{ 0x48, 0, 0, 0x00000010 }, +//{ 0x15, 0, 3, 0x00001389 }, +//{ 0x20, 0, 0, 0x0000001e }, +//{ 0x15, 0, 1, 0x01010101 }, +//{ 0x6, 0, 0, 0x00040000 }, +//{ 0x6, 0, 0, 0x00000000 }, +// +// BPF for TAP interaces with explicit v4 IP and UDP dst port +int SockAddr_Accept_V4_TAP_BPF (int sock, uint32_t dstip, uint16_t port) { + struct sock_filter udp_filter[] = { + { 0x28, 0, 0, 0x0000000c }, + { 0x15, 11, 0, 0x000086dd }, + { 0x15, 0, 10, 0x00000800 }, + { 0x30, 0, 0, 0x00000017 }, + { 0x15, 0, 8, 0x00000011 }, + { 0x28, 0, 0, 0x00000014 }, + { 0x45, 6, 0, 0x00001fff }, + { 0xb1, 0, 0, 0x0000000e }, + { 0x48, 0, 0, 0x00000010 }, + { 0x15, 0, 3, 0x00001389 }, + { 0x20, 0, 0, 0x0000001e }, + { 0x15, 0, 1, 0x00000000 }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + }; + udp_filter[12].k = htonl(dstip); + udp_filter[9].k = htons(port); + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} + +// Simulate the UDP connect for the AF_PACKET (or PF_PACKET) +// +int SockAddr_v4_Connect_BPF (int sock, uint32_t dstip, uint32_t srcip, uint16_t dstport, uint16_t srcport) { + // Use full quintuple, proto, src ip, dst ip, src port, dst port + // ip proto is already set per the PF_PACKET ETH_P_IP + // tcpdump udp and ip src 127.0.0.1 and ip dst 127.0.0.2 and src port 5001 and dst port 5002 -dd + // + // tcpdump udp and ip src 127.0.0.1 and ip dst 127.0.0.2 and src port 5001 and dst port 5002 -d + // (000) ldh [12] + // (001) jeq #0x86dd jt 17 jf 2 + // (002) jeq #0x800 jt 3 jf 17 + // (003) ldb [23] + // (004) jeq #0x11 jt 5 jf 17 + // (005) ld [26] + // (006) jeq #0x7f000001 jt 7 jf 17 + // (007) ld [30] + // (008) jeq #0x7f000002 jt 9 jf 17 + // (009) ldh [20] + // (010) jset #0x1fff jt 17 jf 11 + // (011) ldxb 4*([14]&0xf) + // (012) ldh [x + 14] + // (013) jeq #0x1389 jt 14 jf 17 + // (014) ldh [x + 16] + // (015) jeq #0x138a jt 16 jf 17 + // (016) ret #262144 + // (017) ret #0 + // + struct sock_filter udp_filter[] = { + { 0x28, 0, 0, 0x0000000c }, + { 0x15, 15, 0, 0x000086dd }, + { 0x15, 0, 14, 0x00000800 }, + { 0x30, 0, 0, 0x00000017 }, + { 0x15, 0, 12, 0x00000011 }, + { 0x20, 0, 0, 0x0000001a }, + { 0x15, 0, 10, 0x7f000001 }, + { 0x20, 0, 0, 0x0000001e }, + { 0x15, 0, 8, 0x7f000002 }, + { 0x28, 0, 0, 0x00000014 }, + { 0x45, 6, 0, 0x00001fff }, + { 0xb1, 0, 0, 0x0000000e }, + { 0x48, 0, 0, 0x0000000e }, + { 0x15, 0, 3, 0x00001389 }, + { 0x48, 0, 0, 0x00000010 }, + { 0x15, 0, 1, 0x0000138a }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + }; + udp_filter[6].k = htonl(srcip); + udp_filter[8].k = htonl(dstip); + udp_filter[13].k = htons(srcport); + udp_filter[15].k = htons(dstport); + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} +int SockAddr_v4_Connect_TAP_BPF (int sock, uint32_t dstip, uint32_t srcip, uint16_t dstport, uint16_t srcport) { + // [root@ryzen3950 iperf2-code]# tcpdump ip and src 127.0.0.1 and dst 127.0.0.2 and udp src port 5001 and dst port 5002 -d + // Warning: assuming Ethernet + // (000) ldh [12] + // (001) jeq #0x800 jt 2 jf 16 + // (002) ld [26] + // (003) jeq #0x7f000001 jt 4 jf 16 + // (004) ld [30] + // (005) jeq #0x7f000002 jt 6 jf 16 + // (006) ldb [23] + // (007) jeq #0x11 jt 8 jf 16 + // (008) ldh [20] + // (009) jset #0x1fff jt 16 jf 10 + // (010) ldxb 4*([14]&0xf) + // (011) ldh [x + 14] + // (012) jeq #0x1389 jt 13 jf 16 + // (013) ldh [x + 16] + // (014) jeq #0x138a jt 15 jf 16 + // (015) ret #262144 + // (016) ret #0 + // [root@ryzen3950 iperf2-code]# tcpdump ip and src 127.0.0.1 and dst 127.0.0.2 and udp src port 5001 and dst port 5002 -dd + // Warning: assuming Ethernet + struct sock_filter udp_filter[] = { + { 0x28, 0, 0, 0x0000000c }, + { 0x15, 0, 14, 0x00000800 }, + { 0x20, 0, 0, 0x0000001a }, + { 0x15, 0, 12, 0x7f000001 }, + { 0x20, 0, 0, 0x0000001e }, + { 0x15, 0, 10, 0x7f000002 }, + { 0x30, 0, 0, 0x00000017 }, + { 0x15, 0, 8, 0x00000011 }, + { 0x28, 0, 0, 0x00000014 }, + { 0x45, 6, 0, 0x00001fff }, + { 0xb1, 0, 0, 0x0000000e }, + { 0x48, 0, 0, 0x0000000e }, + { 0x15, 0, 3, 0x00001389 }, + { 0x48, 0, 0, 0x00000010 }, + { 0x15, 0, 1, 0x0000138a }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + }; + udp_filter[3].k = htonl(srcip); + udp_filter[5].k = htonl(dstip); + udp_filter[12].k = htons(srcport); + udp_filter[14].k = htons(dstport); + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} + +int SockAddr_v4_Connect_BPF_Drop (int sock, uint32_t dstip, uint32_t srcip, uint16_t dstport, uint16_t srcport) { + // Use full quintuple, proto, src ip, dst ip, src port, dst port + // ip proto is already set per the PF_PACKET ETH_P_IP + // tcpdump udp and ip src 127.0.0.1 and ip dst 127.0.0.2 and src port 5001 and dst port 5002 -dd + + struct sock_filter udp_filter[] = { + { 0x28, 0, 0, 0x0000000c }, + { 0x15, 15, 0, 0x000086dd }, + { 0x15, 0, 14, 0x00000800 }, + { 0x30, 0, 0, 0x00000017 }, + { 0x15, 0, 12, 0x00000011 }, + { 0x20, 0, 0, 0x0000001a }, + { 0x15, 0, 10, 0x7f000001 }, + { 0x20, 0, 0, 0x0000001e }, + { 0x15, 0, 8, 0x7f000002 }, + { 0x28, 0, 0, 0x00000014 }, + { 0x45, 6, 0, 0x00001fff }, + { 0xb1, 0, 0, 0x0000000e }, + { 0x48, 0, 0, 0x0000000e }, + { 0x15, 0, 3, 0x00001389 }, + { 0x48, 0, 0, 0x00000010 }, + { 0x15, 0, 1, 0x0000138a }, + { 0x6, 0, 0, 0x00000000 }, + { 0x6, 0, 0, 0x00000000 }, + }; + udp_filter[6].k = htonl(srcip); + udp_filter[8].k = htonl(dstip); + udp_filter[13].k = htons(srcport); + udp_filter[15].k = htons(dstport); + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} +#if HAVE_IPV6 +// +// v6 Connected BPF, use 32 bit values +// +int SockAddr_v6_Connect_BPF (int sock, struct in6_addr *dst, struct in6_addr *src, uint16_t dstport, uint16_t srcport) { + // Use full quintuple, proto, src ip, dst ip, src port, dst port + // tcpdump udp and ip6 src fe80::428d:5cff:fe6a:2d85 and ip6 dst fe80::428d:5cff:fe6a:2d86 and src port 5001 and dst port 5002 -dd + // + //tcpdump udp and ip6 src fe80::428d:5cff:fe6a:2d85 and ip6 dst fe80::428d:5cff:fe6a:2d86 and src port 5001 and dst port 5002 -d + // (000) ldh [12] + // (001) jeq #0x86dd jt 2 jf 32 + // (002) ldb [20] + // (003) jeq #0x11 jt 7 jf 4 + // (004) jeq #0x2c jt 5 jf 32 + // (005) ldb [54] + // (006) jeq #0x11 jt 7 jf 32 + // (007) ld [22] + // (008) jeq #0xfe800000 jt 9 jf 32 + // (009) ld [26] + // (010) jeq #0x0 jt 11 jf 32 + // (011) ld [30] + // (012) jeq #0x428d5cff jt 13 jf 32 + // (013) ld [34] + // (014) jeq #0xfe6a2d85 jt 15 jf 32 + // (015) ld [38] + // (016) jeq #0xfe800000 jt 17 jf 32 + // (017) ld [42] + // (018) jeq #0x0 jt 19 jf 32 + // (019) ld [46] + // (020) jeq #0x428d5cff jt 21 jf 32 + // (021) ld [50] + // (022) jeq #0xfe6a2d86 jt 23 jf 32 + // (023) ldb [20] + // (024) jeq #0x84 jt 27 jf 25 + // (025) jeq #0x6 jt 27 jf 26 + // (026) jeq #0x11 jt 27 jf 32 + // (027) ldh [54] + // (028) jeq #0x1389 jt 29 jf 32 + // (029) ldh [56] + // (030) jeq #0x138a jt 31 jf 32 + // (031) ret #262144 + // (032) ret #0 + // + struct sock_filter udp_filter[] = { + { 0x28, 0, 0, 0x0000000c }, + { 0x15, 0, 30, 0x000086dd }, + { 0x30, 0, 0, 0x00000014 }, + { 0x15, 3, 0, 0x00000011 }, + { 0x15, 0, 27, 0x0000002c }, + { 0x30, 0, 0, 0x00000036 }, + { 0x15, 0, 25, 0x00000011 }, + { 0x20, 0, 0, 0x00000016 }, + { 0x15, 0, 23, 0xfe800000 }, + { 0x20, 0, 0, 0x0000001a }, + { 0x15, 0, 21, 0x00000000 }, + { 0x20, 0, 0, 0x0000001e }, + { 0x15, 0, 19, 0x428d5cff }, + { 0x20, 0, 0, 0x00000022 }, + { 0x15, 0, 17, 0xfe6a2d85 }, + { 0x20, 0, 0, 0x00000026 }, + { 0x15, 0, 15, 0xfe800000 }, + { 0x20, 0, 0, 0x0000002a }, + { 0x15, 0, 13, 0x00000000 }, + { 0x20, 0, 0, 0x0000002e }, + { 0x15, 0, 11, 0x428d5cff }, + { 0x20, 0, 0, 0x00000032 }, + { 0x15, 0, 9, 0xfe6a2d86 }, + { 0x30, 0, 0, 0x00000014 }, + { 0x15, 2, 0, 0x00000084 }, + { 0x15, 1, 0, 0x00000006 }, + { 0x15, 0, 5, 0x00000011 }, + { 0x28, 0, 0, 0x00000036 }, + { 0x15, 0, 3, 0x00001389 }, + { 0x28, 0, 0, 0x00000038 }, + { 0x15, 0, 1, 0x0000138a }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + }; + udp_filter[8].k = htonl((*src).s6_addr32[0]); + udp_filter[10].k = htonl((*src).s6_addr32[1]); + udp_filter[12].k = htonl((*src).s6_addr32[2]); + udp_filter[14].k = htonl((*src).s6_addr32[3]); + udp_filter[16].k = htonl((*dst).s6_addr32[0]); + udp_filter[18].k = htonl((*dst).s6_addr32[1]); + udp_filter[20].k = htonl((*dst).s6_addr32[2]); + udp_filter[22].k = htonl((*dst).s6_addr32[3]); + udp_filter[28].k = htons(srcport); + udp_filter[30].k = htons(dstport); + struct sock_fprog bpf = { + .len = (sizeof(udp_filter) / sizeof(struct sock_filter)), + .filter = udp_filter, + }; + return(setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf))); +} +# endif // HAVE_V6 +#endif // HAVE_LINUX_FILTER + +#ifdef __cplusplus +} /* end extern "C" */ +#endif diff --git a/src/active_hosts.cpp b/src/active_hosts.cpp new file mode 100644 index 0000000..a3455ab --- /dev/null +++ b/src/active_hosts.cpp @@ -0,0 +1,261 @@ +/*--------------------------------------------------------------- + * Copyrig h(c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * active_hosts.c (was List.cpp) + * rewrite by Robert McMahon + * + * This is a list to hold active traffic and create sum groups + * sum groups are traffic sessions from the same client host + * ------------------------------------------------------------------- + */ + +#include "active_hosts.h" +#include "Mutex.h" +#include "SocketAddr.h" +#include "Reporter.h" + +/* + * Global table with active hosts, their sum reports and active thread counts + */ +static struct Iperf_Table active_table; +static bool Iperf_host_port_present (iperf_sockaddr *find); +static struct Iperf_ListEntry* Iperf_host_present (iperf_sockaddr *find); + +#if HAVE_THREAD_DEBUG +static void active_table_show_entry(const char *action, Iperf_ListEntry *entry, int found) { + assert(action != NULL); + assert(entry != NULL); + char tmpaddr[200]; + size_t len=200; + unsigned short port = SockAddr_getPort(&(entry->host)); + SockAddr_getHostAddress(&(entry->host), tmpaddr, len); + thread_debug("active table: %s %s port %d (flag=%d) rootp=%p entryp=%p totcnt/activecnt/hostcnt = %d/%d/%d", \ + action, tmpaddr, port, found, (void *) active_table.root, (void *) entry, active_table.total_count, \ + active_table.count, entry->thread_count); +} +static void active_table_show_compare(const char *action, Iperf_ListEntry *entry, iperf_sockaddr *host, const char *type) { + assert(action != NULL); + assert(entry != NULL); + char lookupaddr[200]; + char findaddr[200]; + size_t len=200; + unsigned short port = SockAddr_getPort(&(entry->host)); + unsigned short findport = SockAddr_getPort(host); + SockAddr_getHostAddress(&(entry->host), lookupaddr, len); + SockAddr_getHostAddress(host, findaddr, len); + thread_debug("active table: compare table entry %s %s/%d against host %s/%d (%s)", type, lookupaddr, port, findaddr, findport, action); +} +#endif + +void Iperf_initialize_active_table () { + Mutex_Initialize(&active_table.my_mutex); + active_table.root = NULL; + active_table.groupid = 0; +} + +/* + * Add Entry add to the list or update thread count + */ +static void active_table_update (iperf_sockaddr *host, struct thread_Settings *agent) { + assert(host != NULL); + assert(agent != NULL); + Iperf_ListEntry *this_entry = Iperf_host_present(host); + active_table.total_count++; + if (this_entry == NULL) { + this_entry = new Iperf_ListEntry(); + assert(this_entry != NULL); + this_entry->host = *host; + this_entry->next = active_table.root; + this_entry->thread_count = 1; + this_entry->socket = agent->mSock; + active_table.count++; + active_table.groupid++; + active_table.root = this_entry; + this_entry->sum_report = InitSumReport(agent, active_table.total_count, 0); + IncrSumReportRefCounter(this_entry->sum_report); + agent->mSumReport = this_entry->sum_report; + this_entry->sum_report->info.common->transferID = -active_table.groupid; // sum ids are negative +#if HAVE_THREAD_DEBUG + active_table_show_entry("new entry", this_entry, ((SockAddr_are_Equal(&this_entry->host, host) && SockAddr_Hostare_Equal(&this_entry->host, host)))); +#endif + } else { + this_entry->thread_count++; + agent->mSumReport = this_entry->sum_report; + IncrSumReportRefCounter(this_entry->sum_report); +#if HAVE_THREAD_DEBUG + active_table_show_entry("incr entry", this_entry, 1); +#endif + } +} + +static inline iperf_sockaddr *active_table_get_host_key (struct thread_Settings *agent) { + iperf_sockaddr *key = (isSumServerDstIP(agent) ? &agent->local : &agent->peer); + return key; +} + +// Thread access to store a host +int Iperf_push_host (struct thread_Settings *agent) { + iperf_sockaddr *host = active_table_get_host_key(agent); + Mutex_Lock(&active_table.my_mutex); + active_table_update(host, agent); + int groupid = active_table.groupid; + Mutex_Unlock(&active_table.my_mutex); + return groupid; +} + +// Used for UDP push of a new host, returns negative value if the host/port is already present +// This is critical because UDP is connectionless and designed to be stateless +int Iperf_push_host_port_conditional (struct thread_Settings *agent) { + iperf_sockaddr *host = active_table_get_host_key(agent); + int rc = -1; + Mutex_Lock(&active_table.my_mutex); + if (!Iperf_host_port_present(host)) { + active_table_update(host, agent); + rc = active_table.groupid; + } + Mutex_Unlock(&active_table.my_mutex); + return (rc); +} + +/* + * Remove a host from the table + */ +void Iperf_remove_host (struct thread_Settings *agent) { + iperf_sockaddr *del = active_table_get_host_key(agent); + // remove_list_entry(entry) { + // indirect = &head; + // while ((*indirect) != entry) { + // indirect = &(*indirect)->next; + // } + // *indirect = entry->next + Mutex_Lock(&active_table.my_mutex); + Iperf_ListEntry **tmp = &active_table.root; + while ((*tmp) && !(SockAddr_Hostare_Equal(&(*tmp)->host, del))) { +#if HAVE_THREAD_DEBUG + active_table_show_compare("miss", *tmp, del, "client ip"); +#endif + tmp = &(*tmp)->next; + } + if (*tmp) { + if (--(*tmp)->thread_count == 0) { + Iperf_ListEntry *remove = (*tmp); + active_table.count--; + agent->mSumReport = NULL; +#if HAVE_THREAD_DEBUG + active_table_show_entry("delete", remove, 1); +#endif + *tmp = remove->next; + FreeSumReport(remove->sum_report); + delete remove; + } else { + DecrSumReportRefCounter((*tmp)->sum_report); +#if HAVE_THREAD_DEBUG + active_table_show_entry("decr", (*tmp), 1); +#endif + } + } + Mutex_Unlock(&active_table.my_mutex); +} + +/* + * Destroy the table + */ +void Iperf_destroy_active_table () { + Iperf_ListEntry *itr1 = active_table.root, *itr2; + while (itr1 != NULL) { + itr2 = itr1->next; + delete itr1; + itr1 = itr2; + } + Mutex_Destroy(&active_table.my_mutex); + active_table.root = NULL; + active_table.count = 0; + active_table.total_count = 0; +} + +/* + * Check if the host and port are present in the active table + */ +bool Iperf_host_port_present (iperf_sockaddr *find) { + Iperf_ListEntry *itr = active_table.root; + bool rc = false; + while (itr != NULL) { + if (SockAddr_are_Equal(&itr->host, find)) { +#if HAVE_THREAD_DEBUG + active_table_show_compare("match", itr, find, "client ip/port"); +#endif + rc = true; + break; + } else { +#if HAVE_THREAD_DEBUG + active_table_show_compare("miss", itr, find, "client ip/port"); +#endif + itr = itr->next; + } + } + return rc; +} + +/* + * Check if the host is present in the active table + */ +static Iperf_ListEntry* Iperf_host_present (iperf_sockaddr *find) { + Iperf_ListEntry *itr = active_table.root; + while (itr != NULL) { + if (SockAddr_Hostare_Equal(&itr->host, find)) { +#if HAVE_THREAD_DEBUG + active_table_show_compare("match", itr, find, "client ip"); +#endif + break; + } else { +#if HAVE_THREAD_DEBUG + active_table_show_compare("miss", itr, find, "client ip"); +#endif + itr = itr->next; + } + } + return itr; +} diff --git a/src/checkdelay.c b/src/checkdelay.c new file mode 100644 index 0000000..1c35d64 --- /dev/null +++ b/src/checkdelay.c @@ -0,0 +1,203 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2014 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * checkdelay.c + * Simple tool to measure mean/min/max of nanosleep + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, rmcmahon@broadcom.com) + * ------------------------------------------------------------------- */ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <ctype.h> +#include <unistd.h> +#include "headers.h" +#include "util.h" +#include "delay.h" +#if HAVE_SCHED_SETSCHEDULER +#include <sched.h> +#ifdef HAVE_MLOCKALL +#include <sys/mman.h> +#endif +#endif + + + +#define BILLION 1000000000 +#define MILLION 1000000 + +int main (int argc, char **argv) { + double sum=0; + double time1, time2; + double delta, max=0, min=-1; + int ix, delay=1,loopcount=1000; + int c; + int clockgettime = 0, kalman = 0; +#if HAVE_DECL_CPU_SET + int affinity = 0; +#endif +#if HAVE_SCHED_SETSCHEDULER + int realtime = 0; + struct sched_param sp; +#endif +#ifdef HAVE_CLOCK_GETTIME + struct timespec t1; +#else + struct timeval t1; +#endif + + while ((c=getopt(argc, argv, "a:bkd:i:r")) != -1) + switch (c) { + case 'b': + clockgettime = 1; + break; + case 'k': + kalman = 1; + break; + case 'd': + delay = atoi(optarg); + break; + case 'i': + loopcount = atoi(optarg); + break; +#if HAVE_DECL_CPU_SET + case 'a': + affinity=atoi(optarg); + break; +#endif +#if HAVE_SCHED_SETSCHEDULER + case 'r': + realtime = 1; + break; +#endif + case '?': + fprintf(stderr,"Usage -b busyloop, -d usec delay, -i iterations" +#if HAVE_DECL_CPU_SET + ", -a affinity" +#endif +#if HAVE_SCHED_SETSCHEDULER + ", -r realtime" +#endif + "\n"); + return 1; + default: + abort(); + } + +#ifndef HAVE_NANOSLEEP + clockgettime = 1; +#endif + +#if HAVE_SCHED_SETSCHEDULER + if (realtime) { + fprintf(stdout,"Setting scheduler to realtime via SCHED_RR\n"); + // SCHED_OTHER, SCHED_FIFO, SCHED_RR + sp.sched_priority = sched_get_priority_max(SCHED_RR); + WARN_errno(sched_setscheduler(0, SCHED_RR, &sp) < 0, + "Client set scheduler"); +#ifdef HAVE_MLOCKALL + // lock the threads memory + WARN_errno(mlockall(MCL_CURRENT | MCL_FUTURE) != 0, "mlockall"); +#endif + } +#if HAVE_DECL_CPU_SET + if (affinity) { + fprintf(stdout,"CPU affinity set to %d\n", affinity); + cpu_set_t myset; + CPU_ZERO(&myset); + CPU_SET(affinity,&myset); + } +#endif +#endif + if (loopcount > 1000) + fprintf(stdout,"Measuring %s over %.0e iterations using %d usec delay\n", + kalman ? "kalman" : + clockgettime ? "clock_gettime" : "nanosleep", + (double) loopcount, delay); + else + fprintf(stdout,"Measuring %s over %d iterations using %d usec delay\n", + kalman ? "kalman" : + clockgettime ? "clock_gettime" : "nanosleep", + loopcount, delay); + fflush(stdout); + for (ix=0; ix < loopcount; ix++) { + // Find the max jitter for delay call +#ifdef HAVE_CLOCK_GETTIME + clock_gettime(CLOCK_REALTIME, &t1); + time1 = t1.tv_sec + (t1.tv_nsec / 1000000000.0); +#else + gettimeofday( &t1, NULL ); + time1 = t1.tv_sec + (t1.tv_usec / 1000000.0); +#endif +#ifdef HAVE_KALMAN + if (kalman) { + delay_kalman(delay); + } else +#endif + if (clockgettime) { + delay_busyloop(delay); + } else { +#ifdef HAVE_NANOSLEEP + delay_nanosleep(delay); +#endif + } +#ifdef HAVE_CLOCK_GETTIME + clock_gettime(CLOCK_REALTIME, &t1); + time2 = t1.tv_sec + (t1.tv_nsec / 1000000000.0); +#else + gettimeofday( &t1, NULL ); + time2 = t1.tv_sec + (t1.tv_usec / 1000000.0); +#endif + delta = (time2 - time1) * 1e6; + if (delta > max) { + max = delta; + } + if (delta < min || min < 0) { + min = delta; + } + sum += (double) delta; + } + fprintf(stdout,"delay=%.03f/%.03f/%.03f usec (mean/min/max)\n", + (sum / loopcount), min, max); + return(0); +} diff --git a/src/checkisoch.cpp b/src/checkisoch.cpp new file mode 100644 index 0000000..a770e6d --- /dev/null +++ b/src/checkisoch.cpp @@ -0,0 +1,129 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2017 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * checkisoch.cpp + * + * Test routine to test the isochronous functions + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- */ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <errno.h> +#include <string.h> +#include <math.h> +#include <unistd.h> +#include "headers.h" +#include "isochronous.hpp" +#include "delay.h" +#include "pdfs.h" +#include "util.h" + +static void posttimestamp(int, int); + +int main (int argc, char **argv) { + int c, count=100, frequency=100; + float mean=1e8; + float variance=3e7; + bool forceslip = false; + + Isochronous::FrameCounter *fc = NULL; + + while ((c = getopt(argc, argv, "c:f:m:sv:")) != -1) { + switch (c) { + case 'c': + count = atoi(optarg); + break; + case 'f': + frequency = atoi(optarg); + break; + case 'm': + mean=byte_atof(optarg); + break; + case 's': + forceslip = true; + break; + case 'v': + variance=byte_atof(optarg); + break; + case '?': + fprintf (stderr, "usage: -c <count> -f <frames per second> -m <mean> -v <variance>\n"); + return 1; + default: + abort (); + } + } + fc = new Isochronous::FrameCounter(frequency); + + fprintf(stdout,"Timestamping %d times at %d fps\n", count, frequency); + fflush(stdout); + while (count-- > 0) { + if (forceslip && count == 8) { + delay_loop (1000000/frequency + 10); + } + fc->wait_tick(); + posttimestamp(count, (round(lognormal(mean,variance)) / (frequency * 8))); + if (fc->slip) { + fprintf(stdout,"Slip occurred\n"); + fc->slip = 0; + } + } + DELETE_PTR(fc); +} + +void posttimestamp (int count, int bytes) { + struct timespec t1; + double timestamp; + int err; + + err = clock_gettime(CLOCK_REALTIME, &t1); + if (err < 0) { + perror("clock_getttime"); + } else { + timestamp = t1.tv_sec + (t1.tv_nsec / 1000000000.0); + fprintf(stdout,"%f counter(%d), sending %d bytes\n", timestamp, count, bytes); + } + fflush(stdout); +} diff --git a/src/checkpdfs.c b/src/checkpdfs.c new file mode 100644 index 0000000..87577c7 --- /dev/null +++ b/src/checkpdfs.c @@ -0,0 +1,217 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2017 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * pdfs.c + * Produce probability distribution functions, expected to be used + * for iperf client traffic emulations + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- */ + +/* Produce normal and log normal + * + * Implements the Polar form of the Box-Muller Transformation + * + * +*/ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <math.h> +#include <unistd.h> +#include "headers.h" +#include "util.h" +#include "pdfs.h" + +#define MAXBINS 1024 +#define TRUE 1 +#define FALSE 0 +#define MILLION 1000000 +#define BILLION 1000000000 + +#ifdef HAVE_CLOCK_GETTIME +static double timespec_diff(struct timespec tv1, struct timespec tv0); +#else +static double timeval_diff (struct timeval tv1, struct timeval tv0); +#endif + +int main (int argc, char **argv) { + int c, i; + int minbin = MAXBINS; + int maxbin = 0; + int bincount=MAXBINS; + time_t t; + int histogram[MAXBINS]; + float mean=100.0; + float variance=30.0; + int count = 10000; + int gaussian = TRUE; + int printout = FALSE; + int speedonly = FALSE; + int exectime; + int random = FALSE; + double total; + double binwidth=1.0; + + while ((c=getopt(argc, argv, "b:c:lm:prsv:w:")) != -1) + switch (c) { + case 'b': + bincount = atoi(optarg); + break; + case 'c': + count = atoi(optarg); + break; + case 'l': + gaussian = FALSE; + break; + case 'm': + mean = bitorbyte_atof(optarg); + break; + case 'p': + printout = TRUE; + break; + case 'r': + random = TRUE; + break; + case 's': + speedonly = TRUE; + break; + case 'v': + variance = bitorbyte_atof(optarg); + break; + case 'w': + binwidth = bitorbyte_atof(optarg); + break; + case '?': + default: + fprintf(stderr,"Usage -b bins, -c count, -l log normal, -m mean, -p print, -s speed only, -v variance"); + exit(-1); + } + if (bincount > MAXBINS) { + int max = MAXBINS; + fprintf(stderr, "Maximum number of bins is %d while %d requested\n", max, bincount); + abort(); + } + /* Intializes random number generator */ + if (random) { + srand((unsigned) time(&t)); + printf("seed = %ld\n", t); + } + memset(histogram, 0, sizeof(histogram)); +#ifdef HAVE_CLOCK_GETTIME + struct timespec t1; + clock_gettime(CLOCK_REALTIME, &t1); +#else + struct timeval t1; + gettimeofday( &t1, NULL ); +#endif + if (gaussian) { + for( i = 0 ; i < count ; i++ ) { + int result = round(normal(mean,variance)/binwidth); + if (!speedonly) { + if (result >= 0 && result < (MAXBINS - 1)) { + histogram[result]++; + if (result < minbin) + minbin = result; + if (result > maxbin) + maxbin = result; + } + } + } + } else { + for( i = 0 ; i < count ; i++ ) { + int result = round(lognormal(mean,variance)/binwidth); + if (!speedonly) { + if (result >= 0 && result < (MAXBINS - 1)) { + histogram[result]++; + if (result < minbin) + minbin = result; + if (result > maxbin) + maxbin = result; + } + } + } + } +#ifdef HAVE_CLOCK_GETTIME + struct timespec t2; + clock_gettime(CLOCK_REALTIME, &t2); + total = timespec_diff(t2, t1); +#else + struct timeval t2; + gettimeofday( &t2, NULL ); + total = timeval_diff(t2, t1); +#endif + if (printout) { + for( i = minbin ; i <= maxbin ; i++ ) + printf("%.0f %d\n", i * binwidth, histogram[i]); + } + exectime = round(1e9 * total / count); + if (!printout) { + printf("Total time=%f secs, count= %d, average generate time of %d nanoseconds\n", total, count, exectime); + } + return(0); +} +#ifdef HAVE_CLOCK_GETTIME +// tv1 assumed greater than tv0 +static double timespec_diff (struct timespec tv1, struct timespec tv0) { + double result; + if (tv1.tv_nsec < tv0.tv_nsec) { + tv1.tv_nsec += BILLION; + tv1.tv_sec--; + } + result = (double) (((tv1.tv_sec - tv0.tv_sec) * BILLION) + (tv1.tv_nsec - tv0.tv_nsec)); + return (result / 1e9); +} +#else +// tv1 assumed greater than tv0 +static double timeval_diff (struct timeval tv1, struct timeval tv0) { + double result; + if (tv1.tv_usec < tv0.tv_usec) { + tv1.tv_usec += MILLION; + tv1.tv_sec--; + } + result = (double) (((tv1.tv_sec - tv0.tv_sec) * MILLION) + (tv1.tv_usec - tv0.tv_usec)); + return (result / 1e6); +} +#endif diff --git a/src/checksums.c b/src/checksums.c new file mode 100644 index 0000000..852f195 --- /dev/null +++ b/src/checksums.c @@ -0,0 +1,229 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2018 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * UDP checksums v4 and v6 + * + * The checksum calculation is defined in RFC 768 + * hints as to how to calculate it efficiently are in RFC 1071 + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- + */ +#include "headers.h" + +/* + * + * Compute Internet Checksum for UDP packets (assumes 32 bit system) + * + * IPV4 Notes: + * + * User Datagram Header Format + * 0 7 8 15 16 23 24 31 + * +--------+--------+--------+--------+ + * | Source | Destination | + * | Port | Port | + * +--------+--------+--------+--------+ + * | | | + * | Length | Checksum | + * +--------+--------+--------+--------+ + * | + * | data octets ... + * +---------------- ... + * + * + * Checksum is the 16-bit one's complement of the one's complement sum of a + * pseudo header of information from the IP header, the UDP header, and the + * data, padded with zero octets at the end (if necessary) to make a + * multiple of two octets. + * + * The ipv4 pseudo header conceptually prefixed to the UDP header contains the + * source address, the destination address, the protocol, and the UDP + * length. This information gives protection against misrouted datagrams. + * This checksum procedure is the same as is used in TCP. + * + * 0 7 8 15 16 23 24 31 + * +--------+--------+--------+--------+ + * | source address | + * +--------+--------+--------+--------+ + * | destination address | + * +--------+--------+--------+--------+ + * | zero |protocol| UDP length | + * +--------+--------+--------+--------+ + * + * If the computed checksum is zero, it is transmitted as all ones (the + * equivalent in one's complement arithmetic). An all zero transmitted + * checksum value means that the transmitter generated no checksum (for + * debugging or for higher level protocols that don't care). + * + * + * IPV6 Notes: + * + * Any transport or other upper-layer protocol that includes the + * addresses from the IP header in its checksum computation must be + * modified for use over IPv6, to include the 128-bit IPv6 addresses + * instead of 32-bit IPv4 addresses. In particular, the following + * illustration shows the TCP and UDP "pseudo-header" for IPv6: + * + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * + + + * | | + * + Source Address + + * | | + * + + + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | | + * + + + * | | + * + Destination Address + + * | | + * + + + * | | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Upper-Layer Packet Length | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | zero | Next Header | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * o If the IPv6 packet contains a Routing header, the Destination + * Address used in the pseudo-header is that of the final + * destination. At the originating node, that address will be in + * the last element of the Routing header; at the recipient(s), + * that address will be in the Destination Address field of the + * IPv6 header. + * + * o The Next Header value in the pseudo-header identifies the + * upper-layer protocol (e.g., 6 for TCP, or 17 for UDP). It will + * differ from the Next Header value in the IPv6 header if there + * are extension headers between the IPv6 header and the upper- + * layer header. + * + * o The Upper-Layer Packet Length in the pseudo-header is the + * length of the upper-layer header and data (e.g., TCP header + * plus TCP data). Some upper-layer protocols carry their own + * length information (e.g., the Length field in the UDP header); + * for such protocols, that is the length used in the pseudo- + * header. Other protocols (such as TCP) do not carry their own + * length information, in which case the length used in the + * pseudo-header is the Payload Length from the IPv6 header, minus + * the length of any extension headers present between the IPv6 + * header and the upper-layer header. + * + * o Unlike IPv4, when UDP packets are originated by an IPv6 node, + * the UDP checksum is not optional. That is, whenever + * originating a UDP packet, an IPv6 node must compute a UDP + * checksum over the packet and the pseudo-header, and, if that + * computation yields a result of zero, it must be changed to hex + * FFFF for placement in the UDP header. IPv6 receivers must + * discard UDP packets containing a zero checksum, and should log + * the error. + * + * + * Returns zero on checksum success, non zero otherwise + */ + +#define IPV4SRCOFFSET 12 // the ipv4 source address offset from the l3 pdu +#define IPV6SRCOFFSET 8 // the ipv6 source address offset +#define IPV6SIZE 8 // units is number of 16 bits, i.e. 128 bits is eight 16 bits +#define IPV4SIZE 2 // v4 is two 16 bits (32 bits) +#define UDPPROTO 17 // UDP protocol value for psuedo header +uint32_t udpchecksum(const void *l3pdu, const void *l4pdu, int udplen, int v6) { + register uint32_t sum = 0; + const uint16_t *data; + int i; + + const struct udphdr *udp_hdr = (const struct udphdr *)l4pdu; + if (!udp_hdr->check) { + if (v6) + // v6 requires checksums + return -1; + else + // v4 checksums are optional + return 0; + } + + /* + * Build pseudo headers, partially from the packet + * (which are in network byte order) and + * the protocol of UDP (value of 17). Also, the IP dst + * addr immediately follows the src so double the size + * per each loop to cover both addrs + */ + if (v6) { + // skip to the ip header v6 src field, offset 8 (see ipv6 header) + data = (const uint16_t *)((char *)l3pdu + IPV6SRCOFFSET); + for (i = 0; i < (2 * IPV6SIZE); i++) { + sum += *data++; + } + } else { + // skip to the ip header v4 src field, offset 12 (see ipv4 header) + data = (const uint16_t *)((char *)l3pdu + IPV4SRCOFFSET); + for (i = 0; i < (2 * IPV4SIZE); i++) { + sum += *data++; + } + } + // These should work for both v4 and v6 even though + // v6 psuedo header uses 32 bit values because the + // uppers in v6 will be zero + sum += htons(UDPPROTO); // proto of UDP is 17 + sum += htons(udplen); // For UDP, the pseudo hdr len equals udp len + + /* + * UDP hdr + payload + */ + data = (const uint16_t *) l4pdu; + while( udplen > 1 ) { + sum += *data++; + udplen -= 2; + } + /* Add left-over byte, if any */ + if( udplen > 0 ) + sum += * (uint8_t *) data; + + /* Fold 32-bit sum to 16 bits */ + while (sum>>16) + sum = (sum & 0xffff) + (sum >> 16); + + /* return ones complement */ + sum = (sum ^ 0xffff); + return sum; +} diff --git a/src/dscp.c b/src/dscp.c new file mode 100644 index 0000000..de691a7 --- /dev/null +++ b/src/dscp.c @@ -0,0 +1,180 @@ +/* DSCP lookup routines lifted from openssh, modified a bit for WiFi WMMM + * + * Copyright (c) 2000 Markus Friedl. All rights reserved. + * Copyright (c) 2005,2006 Damien Miller. All rights reserved. + * Copyright (c) 2022 Robert McMahon. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#if HAVE_CONFIG_H +#include <config.h> +#endif + +#include <stdio.h> +#if HAVE_STRING_H +#include <string.h> +#endif +#if HAVE_STDLIB_H +#include <stdlib.h> +#endif + +#if HAVE_INTTYPES_H +#include <inttypes.h> +#endif + +#ifdef WIN32 +#define strcasecmp(a,b) _stricmp(a,b) +#define snprintf _snprintf +#endif + +#include "dscp.h" + +/* + * Definitions for IP type of service (ip_tos) + */ + +#if HAVE_NETINET_IN_SYSTM_H +#if defined(__FreeBSD__) +#include <sys/types.h> +#endif +#include <netinet/in_systm.h> +#endif +#if HAVE_NETINET_IP_H +#include <netinet/ip.h> +#endif + +#ifndef IPTOS_LOWDELAY +# define IPTOS_LOWDELAY 0x10 +# define IPTOS_THROUGHPUT 0x08 +# define IPTOS_RELIABILITY 0x04 +# define IPTOS_LOWCOST 0x02 +# define IPTOS_MINCOST IPTOS_LOWCOST +#endif /* IPTOS_LOWDELAY */ + +/* + * Definitions for DiffServ Codepoints as per RFC2474, rfc8622, rfc8325 + */ +#ifndef IPTOS_DSCP_AF11 +# define IPTOS_DSCP_AF11 0x28 +# define IPTOS_DSCP_AF12 0x30 +# define IPTOS_DSCP_AF13 0x38 +# define IPTOS_DSCP_AF21 0x48 +# define IPTOS_DSCP_AF22 0x50 +# define IPTOS_DSCP_AF23 0x58 +# define IPTOS_DSCP_AF31 0x68 +# define IPTOS_DSCP_AF32 0x70 +# define IPTOS_DSCP_AF33 0x78 +# define IPTOS_DSCP_AF41 0x88 +# define IPTOS_DSCP_AF42 0x90 +# define IPTOS_DSCP_AF43 0x98 +# define IPTOS_DSCP_EF 0xb8 +# define IPTOS_DSCP_LE 0x01 // rfc8622 +# define IPTOS_DSCP_NQB 0x05 // rfc8325 +# define IPTOS_DSCP_NQB2 0x2D // rfc8325 45 decimal + +#endif /* IPTOS_DSCP_AF11 */ + +#ifndef IPTOS_DSCP_CS0 +# define IPTOS_DSCP_CS0 0x00 +# define IPTOS_DSCP_CS1 0x20 +# define IPTOS_DSCP_CS2 0x40 +# define IPTOS_DSCP_CS3 0x60 +# define IPTOS_DSCP_CS4 0x80 +# define IPTOS_DSCP_CS5 0xa0 +# define IPTOS_DSCP_CS6 0xc0 +# define IPTOS_DSCP_CS7 0xe0 +#endif /* IPTOS_DSCP_CS0 */ +#ifndef IPTOS_DSCP_EF +# define IPTOS_DSCP_EF 0xb8 +#endif /* IPTOS_DSCP_EF */ + +static const struct { + const char *name; + int value; +} ipqos[] = { + { "af11", IPTOS_DSCP_AF11 }, + { "af12", IPTOS_DSCP_AF12 }, + { "af13", IPTOS_DSCP_AF13 }, + { "af21", IPTOS_DSCP_AF21 }, + { "af22", IPTOS_DSCP_AF22 }, + { "af23", IPTOS_DSCP_AF23 }, + { "af31", IPTOS_DSCP_AF31 }, + { "af32", IPTOS_DSCP_AF32 }, + { "af33", IPTOS_DSCP_AF33 }, + { "af41", IPTOS_DSCP_AF41 }, + { "af42", IPTOS_DSCP_AF42 }, + { "af43", IPTOS_DSCP_AF43 }, + { "cs0", IPTOS_DSCP_CS0 }, + { "cs1", IPTOS_DSCP_CS1 }, + { "cs2", IPTOS_DSCP_CS2 }, + { "cs3", IPTOS_DSCP_CS3 }, + { "cs4", IPTOS_DSCP_CS4 }, + { "cs5", IPTOS_DSCP_CS5 }, + { "cs6", IPTOS_DSCP_CS6 }, + { "cs7", IPTOS_DSCP_CS7 }, + { "ef", IPTOS_DSCP_EF }, + { "le", IPTOS_DSCP_LE }, + { "nqb", IPTOS_DSCP_NQB }, + { "nqb2", IPTOS_DSCP_NQB2 }, + { "ac_be", IPTOS_DSCP_CS0 }, + { "ac_bk", IPTOS_DSCP_CS1 }, + { "ac_vi", IPTOS_DSCP_CS4 }, + { "ac_vo", IPTOS_DSCP_EF }, + { "lowdelay", IPTOS_LOWDELAY }, + { "throughput", IPTOS_THROUGHPUT }, + { "reliability", IPTOS_RELIABILITY }, + { NULL, -1 } +}; + +int +parse_ipqos(const char *cp) +{ + unsigned int i; + char *ep = NULL; + long val; + + if (cp == NULL) + return -1; + for (i = 0; ipqos[i].name != NULL; i++) { + if (strcasecmp(cp, ipqos[i].name) == 0) + return ipqos[i].value; + } + /* Try parsing as an integer */ + val = strtol(cp, &ep, 0); + if (*cp == '\0' || *ep != '\0' || val < 0 || val > 255) + return -1; + return val; +} + +const char * +iptos2str(int iptos) +{ + int i; + static char iptos_str[sizeof "0xff"]; + if (iptos < 0 || iptos > 64) iptos = 0; + for (i = 0; ipqos[i].name != NULL; i++) { + if (ipqos[i].value == iptos) + return ipqos[i].name; + } + snprintf(iptos_str, sizeof iptos_str, "0x%02x", iptos); + return iptos_str; +} diff --git a/src/gnu_getopt.c b/src/gnu_getopt.c new file mode 100644 index 0000000..6905278 --- /dev/null +++ b/src/gnu_getopt.c @@ -0,0 +1,818 @@ +/* Getopt for GNU. + NOTE: gnu_getopt is now part of the C library, so if you don't know what + "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu + before changing it! + + Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97 + Free Software Foundation, Inc. + + This file is part of the GNU C Library. Its master source is NOT part of + the C library, however. The master source lives in /gd/gnu/lib. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* + * modified July 9, 1999 by mark gates <mgates@nlanr.net> + * Dec 17, 1999 + * + * renamed all functions and variables by prepending "gnu_" + * removed/redid a bunch of stuff under the assumption we're + * using a modern standard C compiler. + * add #include <string.h> here for strncmp(). Originally + * it was included only under special conditions. + * + * $Id: gnu_getopt.c,v 1.1.1.1 2004/05/18 01:50:44 kgibbs Exp $ + */ + + + +#include <stdio.h> +#include <stdlib.h> +#ifndef _MSC_VER /* Visual C++ doesn't have unistd.h */ + #include <unistd.h> +#endif +#include <string.h> + +#ifndef _ +/* This is for other GNU distributions with internationalized messages. + When compiling libc, the _ macro is predefined. */ + #ifdef HAVE_LIBINTL_H + #include <libintl.h> + #define _(msgid) gettext (msgid) + #else + #define _(msgid) (msgid) + #endif +#endif + +/* This version of `gnu_getopt' appears to the caller like standard + Unix `getopt' but it behaves differently for the user, since it + allows the user to intersperse the options with the other + arguments. + + As `gnu_getopt' works, it permutes the elements of ARGV so that, + when it is done, all the options precede everything else. Thus + all application programs are extended to handle flexible argument order. + + Setting the environment variable POSIXLY_CORRECT disables permutation. + Then the behavior is completely standard. + + GNU application programs can use a third alternative mode in which + they can distinguish the relative order of options and other arguments. */ + +#include "gnu_getopt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* For communication from `gnu_getopt' to the caller. + When `gnu_getopt' finds an option that takes an argument, + the argument value is returned here. + Also, when `ordering' is RETURN_IN_ORDER, + each non-option ARGV-element is returned here. */ + +char *gnu_optarg = NULL; + +/* Index in ARGV of the next element to be scanned. + This is used for communication to and from the caller + and for communication between successive calls to `gnu_getopt'. + + On entry to `gnu_getopt', zero means this is the first call; initialize. + + When `gnu_getopt' returns -1, this is the index of the first of the + non-option elements that the caller should itself scan. + + Otherwise, `gnu_optind' communicates from one call to the next + how much of ARGV has been scanned so far. */ + +/* 1003.2 says this must be 1 before any call. */ +int gnu_optind = 1; + +/* Formerly, initialization of gnu_getopt depended on gnu_optind==0, which + causes problems with re-calling gnu_getopt as programs generally don't + know that. */ + +int __gnu_getopt_initialized = 0; + +/* The next char to be scanned in the option-element + in which the last option character we returned was found. + This allows us to pick up the scan where we left off. + + If this is zero, or a null string, it means resume the scan + by advancing to the next ARGV-element. */ + +static char *nextchar; + +/* Callers store zero here to inhibit the error message + for unrecognized options. */ + +int gnu_opterr = 1; + +/* Set to an option character which was unrecognized. + This must be initialized on some systems to avoid linking in the + system's own gnu_getopt implementation. */ + +int gnu_optopt = '?'; + +/* Describe how to deal with options that follow non-option ARGV-elements. + + If the caller did not specify anything, + the default is REQUIRE_ORDER if the environment variable + POSIXLY_CORRECT is defined, PERMUTE otherwise. + + REQUIRE_ORDER means don't recognize them as options; + stop option processing when the first non-option is seen. + This is what Unix does. + This mode of operation is selected by either setting the environment + variable POSIXLY_CORRECT, or using `+' as the first character + of the list of option characters. + + PERMUTE is the default. We permute the contents of ARGV as we scan, + so that eventually all the non-options are at the end. This allows options + to be given in any order, even with programs that were not written to + expect this. + + RETURN_IN_ORDER is an option available to programs that were written + to expect options and other ARGV-elements in any order and that care about + the ordering of the two. We describe each non-option ARGV-element + as if it were the argument of an option with character code 1. + Using `-' as the first character of the list of option characters + selects this mode of operation. + + The special argument `--' forces an end of option-scanning regardless + of the value of `ordering'. In the case of RETURN_IN_ORDER, only + `--' can cause `gnu_getopt' to return -1 with `gnu_optind' != ARGC. */ + +static enum { + REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER +} ordering; + +/* Value of POSIXLY_CORRECT environment variable. */ +static char *posixly_correct; + + +/* Avoid depending on library functions or files + whose names are inconsistent. */ + +static char * +my_index( const char* str, int chr ) { + while ( *str ) { + if ( *str == chr ) + return(char *) str; + str++; + } + return 0; +} + + +/* Handle permutation of arguments. */ + +/* Describe the part of ARGV that contains non-options that have + been skipped. `first_nonopt' is the index in ARGV of the first of them; + `last_nonopt' is the index after the last of them. */ + +static int first_nonopt; +static int last_nonopt; + +/* Exchange two adjacent subsequences of ARGV. + One subsequence is elements [first_nonopt,last_nonopt) + which contains all the non-options that have been skipped so far. + The other is elements [last_nonopt,gnu_optind), which contains all + the options processed since those non-options were skipped. + + `first_nonopt' and `last_nonopt' are relocated so that they describe + the new indices of the non-options in ARGV after they are moved. */ + +static void exchange( char **argv ); + +static void +exchange( char **argv ) { + int bottom = first_nonopt; + int middle = last_nonopt; + int top = gnu_optind; + char *tem; + + /* Exchange the shorter segment with the far end of the longer segment. + That puts the shorter segment into the right place. + It leaves the longer segment in the right place overall, + but it consists of two parts that need to be swapped next. */ + + while ( top > middle && middle > bottom ) { + if ( top - middle > middle - bottom ) { + /* Bottom segment is the short one. */ + int len = middle - bottom; + register int i; + + /* Swap it with the top part of the top segment. */ + for ( i = 0; i < len; i++ ) { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + } + /* Exclude the moved bottom segment from further swapping. */ + top -= len; + } else { + /* Top segment is the short one. */ + int len = top - middle; + register int i; + + /* Swap it with the bottom part of the bottom segment. */ + for ( i = 0; i < len; i++ ) { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + } + /* Exclude the moved top segment from further swapping. */ + bottom += len; + } + } + + /* Update records for the slots the non-options now occupy. */ + + first_nonopt += (gnu_optind - last_nonopt); + last_nonopt = gnu_optind; +} + +/* Initialize the internal data when the first call is made. */ + +static const char * +_gnu_getopt_initialize( int argc, + char *const * argv, + const char *optstring ); + +static const char * +_gnu_getopt_initialize( int argc, + char *const * argv, + const char *optstring ) { + /* Start processing options with ARGV-element 1 (since ARGV-element 0 + is the program name); the sequence of previously skipped + non-option ARGV-elements is empty. */ + + first_nonopt = last_nonopt = gnu_optind = 1; + + nextchar = NULL; + + posixly_correct = getenv ("POSIXLY_CORRECT"); + + /* Determine how to handle the ordering of options and nonoptions. */ + + if ( optstring[0] == '-' ) { + ordering = RETURN_IN_ORDER; + ++optstring; + } else if ( optstring[0] == '+' ) { + ordering = REQUIRE_ORDER; + ++optstring; + } else if ( posixly_correct != NULL ) + ordering = REQUIRE_ORDER; + else + ordering = PERMUTE; + + return optstring; +} + +/* Scan elements of ARGV (whose length is ARGC) for option characters + given in OPTSTRING. + + If an element of ARGV starts with '-', and is not exactly "-" or "--", + then it is an option element. The characters of this element + (aside from the initial '-') are option characters. If `gnu_getopt' + is called repeatedly, it returns successively each of the option characters + from each of the option elements. + + If `gnu_getopt' finds another option character, it returns that character, + updating `gnu_optind' and `nextchar' so that the next call to `gnu_getopt' can + resume the scan with the following option character or ARGV-element. + + If there are no more option characters, `gnu_getopt' returns -1. + Then `gnu_optind' is the index in ARGV of the first ARGV-element + that is not an option. (The ARGV-elements have been permuted + so that those that are not options now come last.) + + OPTSTRING is a string containing the legitimate option characters. + If an option character is seen that is not listed in OPTSTRING, + return '?' after printing an error message. If you set `gnu_opterr' to + zero, the error message is suppressed but we still return '?'. + + If a char in OPTSTRING is followed by a colon, that means it wants an arg, + so the following text in the same ARGV-element, or the text of the following + ARGV-element, is returned in `gnu_optarg'. Two colons mean an option that + wants an optional arg; if there is text in the current ARGV-element, + it is returned in `gnu_optarg', otherwise `gnu_optarg' is set to zero. + + If OPTSTRING starts with `-' or `+', it requests different methods of + handling the non-option ARGV-elements. + See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. + + Long-named options begin with `--' instead of `-'. + Their names may be abbreviated as long as the abbreviation is unique + or is an exact match for some defined option. If they have an + argument, it follows the option name in the same ARGV-element, separated + from the option name by a `=', or else the in next ARGV-element. + When `gnu_getopt' finds a long-named option, it returns 0 if that option's + `flag' field is nonzero, the value of the option's `val' field + if the `flag' field is zero. + + The elements of ARGV aren't really const, because we permute them. + But we pretend they're const in the prototype to be compatible + with other systems. + + LONGOPTS is a vector of `struct option' terminated by an + element containing a name which is zero. + + LONGIND returns the index in LONGOPT of the long-named option found. + It is only valid when a long-named option has been found by the most + recent call. + + If LONG_ONLY is nonzero, '-' as well as '--' can introduce + long-named options. */ + +int +_gnu_getopt_internal( int argc, + char *const *argv, + const char *optstring, + const struct option *longopts, + int *longind, + int long_only ) { + gnu_optarg = NULL; + + if ( !__gnu_getopt_initialized || gnu_optind == 0 ) { + optstring = _gnu_getopt_initialize (argc, argv, optstring); + gnu_optind = 1; /* Don't scan ARGV[0], the program name. */ + __gnu_getopt_initialized = 1; + } + + /* Test whether ARGV[gnu_optind] points to a non-option argument. + Either it does not have option syntax, or there is an environment flag + from the shell indicating it is not an option. The later information + is only used when the used in the GNU libc. */ + +#define NONOPTION_P (argv[gnu_optind][0] != '-' || argv[gnu_optind][1] == '\0') + + if ( nextchar == NULL || *nextchar == '\0' ) { + /* Advance to the next ARGV-element. */ + + /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been + moved back by the user (who may also have changed the arguments). */ + if ( last_nonopt > gnu_optind ) + last_nonopt = gnu_optind; + if ( first_nonopt > gnu_optind ) + first_nonopt = gnu_optind; + + if ( ordering == PERMUTE ) { + /* If we have just processed some options following some non-options, + exchange them so that the options come first. */ + + if ( first_nonopt != last_nonopt && last_nonopt != gnu_optind ) + exchange ((char **) argv); + else if ( last_nonopt != gnu_optind ) + first_nonopt = gnu_optind; + + /* Skip any additional non-options + and extend the range of non-options previously skipped. */ + + while ( gnu_optind < argc && NONOPTION_P ) + gnu_optind++; + last_nonopt = gnu_optind; + } + + /* The special ARGV-element `--' means premature end of options. + Skip it like a null option, + then exchange with previous non-options as if it were an option, + then skip everything else like a non-option. */ + + if ( gnu_optind != argc && !strcmp (argv[gnu_optind], "--") ) { + gnu_optind++; + + if ( first_nonopt != last_nonopt && last_nonopt != gnu_optind ) + exchange ((char **) argv); + else if ( first_nonopt == last_nonopt ) + first_nonopt = gnu_optind; + last_nonopt = argc; + + gnu_optind = argc; + } + + /* If we have done all the ARGV-elements, stop the scan + and back over any non-options that we skipped and permuted. */ + + if ( gnu_optind == argc ) { + /* Set the next-arg-index to point at the non-options + that we previously skipped, so the caller will digest them. */ + if ( first_nonopt != last_nonopt ) + gnu_optind = first_nonopt; + return -1; + } + + /* If we have come to a non-option and did not permute it, + either stop the scan or describe it to the caller and pass it by. */ + + if ( NONOPTION_P ) { + if ( ordering == REQUIRE_ORDER ) + return -1; + gnu_optarg = argv[gnu_optind++]; + return 1; + } + + /* We have found another option-ARGV-element. + Skip the initial punctuation. */ + + nextchar = (argv[gnu_optind] + 1 + + (longopts != NULL && argv[gnu_optind][1] == '-')); + } + + /* Decode the current option-ARGV-element. */ + + /* Check whether the ARGV-element is a long option. + + If long_only and the ARGV-element has the form "-f", where f is + a valid short option, don't consider it an abbreviated form of + a long option that starts with f. Otherwise there would be no + way to give the -f short option. + + On the other hand, if there's a long option "fubar" and + the ARGV-element is "-fu", do consider that an abbreviation of + the long option, just like "--fu", and not "-f" with arg "u". + + This distinction seems to be the most useful approach. */ + + if ( longopts != NULL + && (argv[gnu_optind][1] == '-' + || (long_only && (argv[gnu_optind][2] || !my_index (optstring, argv[gnu_optind][1])))) ) { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = -1; + int option_index; + + for ( nameend = nextchar; *nameend && *nameend != '='; nameend++ ) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for ( p = longopts, option_index = 0; p->name; p++, option_index++ ) + if ( !strncmp (p->name, nextchar, nameend - nextchar) ) { + if ( (unsigned int) (nameend - nextchar) + == (unsigned int) strlen (p->name) ) { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } else if ( pfound == NULL ) { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } else + /* Second or later nonexact match found. */ + ambig = 1; + } + + if ( ambig && !exact ) { + if ( gnu_opterr ) + fprintf (stderr, _("%s: option `%s' is ambiguous\n"), + argv[0], argv[gnu_optind]); + nextchar += strlen (nextchar); + gnu_optind++; + gnu_optopt = 0; + return '?'; + } + + if ( pfound != NULL ) { + option_index = indfound; + gnu_optind++; + if ( *nameend ) { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if ( pfound->has_arg ) + gnu_optarg = nameend + 1; + else { + if ( gnu_opterr ) { + if ( argv[gnu_optind - 1][1] == '-' ) { + /* --option */ + fprintf (stderr, + _("%s: option `--%s' doesn't allow an argument\n"), + argv[0], pfound->name); + } else { + /* +option or -option */ + fprintf (stderr, + _("%s: option `%c%s' doesn't allow an argument\n"), + argv[0], argv[gnu_optind - 1][0], pfound->name); + } + } + + nextchar += strlen (nextchar); + + gnu_optopt = pfound->val; + return '?'; + } + } else if ( pfound->has_arg == 1 ) { + if ( gnu_optind < argc ) + gnu_optarg = argv[gnu_optind++]; + else { + if ( gnu_opterr ) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[gnu_optind - 1]); + nextchar += strlen (nextchar); + gnu_optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if ( longind != NULL ) + *longind = option_index; + if ( pfound->flag ) { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + + /* Can't find it as a long option. If this is not gnu_getopt_long_only, + or the option starts with '--' or is not a valid short + option, then it's an error. + Otherwise interpret it as a short option. */ + if ( !long_only || argv[gnu_optind][1] == '-' + || my_index (optstring, *nextchar) == NULL ) { + if ( gnu_opterr ) { + if ( argv[gnu_optind][1] == '-' ) + /* --option */ + fprintf (stderr, _("%s: unrecognized option `--%s'\n"), + argv[0], nextchar); + else + /* +option or -option */ + fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), + argv[0], argv[gnu_optind][0], nextchar); + } + nextchar = (char *) ""; + gnu_optind++; + gnu_optopt = 0; + return '?'; + } + } + + /* Look at and handle the next short option-character. */ + + { + char c = *nextchar++; + char *temp = my_index (optstring, c); + + /* Increment `gnu_optind' when we start to process its last character. */ + if ( *nextchar == '\0' ) + ++gnu_optind; + + if ( temp == NULL || c == ':' ) { + if ( gnu_opterr ) { + if ( posixly_correct ) + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: illegal option -- %c\n"), + argv[0], c); + else + fprintf (stderr, _("%s: invalid option -- %c\n"), + argv[0], c); + } + gnu_optopt = c; + return '?'; + } + /* Convenience. Treat POSIX -W foo same as long option --foo */ + if ( temp[0] == 'W' && temp[1] == ';' ) { + char *nameend; + const struct option *p; + const struct option *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = 0; + int option_index; + + /* This is an option that requires an argument. */ + if ( *nextchar != '\0' ) { + gnu_optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + gnu_optind++; + } else if ( gnu_optind == argc ) { + if ( gnu_opterr ) { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + gnu_optopt = c; + if ( optstring[0] == ':' ) + c = ':'; + else + c = '?'; + return c; + } else + /* We already incremented `gnu_optind' once; + increment it again when taking next ARGV-elt as argument. */ + gnu_optarg = argv[gnu_optind++]; + + /* gnu_optarg is now the argument, see if it's in the + table of longopts. */ + + for ( nextchar = nameend = gnu_optarg; *nameend && *nameend != '='; nameend++ ) + /* Do nothing. */ ; + + /* Test all long options for either exact match + or abbreviated matches. */ + for ( p = longopts, option_index = 0; p->name; p++, option_index++ ) + if ( !strncmp (p->name, nextchar, nameend - nextchar) ) { + if ( (unsigned int) (nameend - nextchar) == strlen (p->name) ) { + /* Exact match found. */ + pfound = p; + indfound = option_index; + exact = 1; + break; + } else if ( pfound == NULL ) { + /* First nonexact match found. */ + pfound = p; + indfound = option_index; + } else + /* Second or later nonexact match found. */ + ambig = 1; + } + if ( ambig && !exact ) { + if ( gnu_opterr ) + fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), + argv[0], argv[gnu_optind]); + nextchar += strlen (nextchar); + gnu_optind++; + return '?'; + } + if ( pfound != NULL ) { + option_index = indfound; + if ( *nameend ) { + /* Don't test has_arg with >, because some C compilers don't + allow it to be used on enums. */ + if ( pfound->has_arg ) + gnu_optarg = nameend + 1; + else { + if ( gnu_opterr ) + fprintf (stderr, _("\ +%s: option `-W %s' doesn't allow an argument\n"), + argv[0], pfound->name); + + nextchar += strlen (nextchar); + return '?'; + } + } else if ( pfound->has_arg == 1 ) { + if ( gnu_optind < argc ) + gnu_optarg = argv[gnu_optind++]; + else { + if ( gnu_opterr ) + fprintf (stderr, + _("%s: option `%s' requires an argument\n"), + argv[0], argv[gnu_optind - 1]); + nextchar += strlen (nextchar); + return optstring[0] == ':' ? ':' : '?'; + } + } + nextchar += strlen (nextchar); + if ( longind != NULL ) + *longind = option_index; + if ( pfound->flag ) { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + nextchar = NULL; + return 'W'; /* Let the application handle it. */ + } + if ( temp[1] == ':' ) { + if ( temp[2] == ':' ) { + /* This is an option that accepts an argument optionally. */ + if ( *nextchar != '\0' ) { + gnu_optarg = nextchar; + gnu_optind++; + } else + gnu_optarg = NULL; + nextchar = NULL; + } else { + /* This is an option that requires an argument. */ + if ( *nextchar != '\0' ) { + gnu_optarg = nextchar; + /* If we end this ARGV-element by taking the rest as an arg, + we must advance to the next element now. */ + gnu_optind++; + } else if ( gnu_optind == argc ) { + if ( gnu_opterr ) { + /* 1003.2 specifies the format of this message. */ + fprintf (stderr, + _("%s: option requires an argument -- %c\n"), + argv[0], c); + } + gnu_optopt = c; + if ( optstring[0] == ':' ) + c = ':'; + else + c = '?'; + } else + /* We already incremented `gnu_optind' once; + increment it again when taking next ARGV-elt as argument. */ + gnu_optarg = argv[gnu_optind++]; + nextchar = NULL; + } + } + return c; + } +} + +int +gnu_getopt ( int argc, + char *const *argv, + const char *optstring ) { + return _gnu_getopt_internal (argc, argv, optstring, + (const struct option *) 0, + (int *) 0, + 0); +} + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + + +#ifdef TEST + +/* Compile with -DTEST to make an executable for use in testing + the above definition of `gnu_getopt'. */ + +int +main (argc, argv) +int argc; +char **argv; +{ +int c; +int digit_optind = 0; + +while ( 1 ) { + int this_option_optind = gnu_optind ? gnu_optind : 1; + + c = gnu_getopt (argc, argv, "abc:d:0123456789"); + if ( c == -1 ) + break; + + switch ( c ) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if ( digit_optind != 0 && digit_optind != this_option_optind ) + fprintf ( stderr, "digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + fprintf ( stderr, "option %c\n", c); + break; + + case 'a': + fprintf ( stderr, "option a\n"); + break; + + case 'b': + fprintf ( stderr, "option b\n"); + break; + + case 'c': + fprintf ( stderr, "option c with value `%s'\n", gnu_optarg); + break; + + case '?': + break; + + default: + fprintf ( stderr, "?? gnu_getopt returned character code 0%o ??\n", c); + } +} + +if ( gnu_optind < argc ) { + fprintf (stderr, "non-option ARGV-elements: "); + while ( gnu_optind < argc ) + fprintf ( stderr, "%s ", argv[gnu_optind++]); + fprintf ( stderr, "\n"); +} + +exit (0); +} + +#endif /* TEST */ diff --git a/src/gnu_getopt_long.c b/src/gnu_getopt_long.c new file mode 100644 index 0000000..9049feb --- /dev/null +++ b/src/gnu_getopt_long.c @@ -0,0 +1,162 @@ +/* gnu_getopt_long and getopt_long_only entry points for GNU getopt. + Copyright (C) 1987,88,89,90,91,92,93,94,96,97 Free Software Foundation, Inc. + + This file is part of the GNU C Library. Its master source is NOT part of + the C library, however. The master source lives in /gd/gnu/lib. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* + * modified July 9, 1999 by mark gates <mgates@nlanr.net> + * Dec 17, 1999 + * + * renamed all functions and variables by prepending "gnu_" + * removed/redid a bunch of stuff under the assumption we're + * using a modern standard C compiler. + * renamed file to gnu_getopt_long.c (from gnu_getopt1.c) + * + * $Id: gnu_getopt_long.c,v 1.1.1.1 2004/05/18 01:50:44 kgibbs Exp $ + */ + + + +#include "gnu_getopt.h" + +#include <stdio.h> +#include <stdlib.h> + +#ifdef __cplusplus +extern "C" { +#endif + +int +gnu_getopt_long( int argc, + char *const *argv, + const char *options, + const struct option *long_options, + int *opt_index ) { + return _gnu_getopt_internal (argc, argv, options, long_options, opt_index, 0); +} + +/* Like gnu_getopt_long, but '-' as well as '--' can indicate a long option. + If an option that starts with '-' (not '--') doesn't match a long option, + but does match a short option, it is parsed as a short option + instead. */ + +int +gnu_getopt_long_only( int argc, + char *const *argv, + const char *options, + const struct option *long_options, + int *opt_index ) { + return _gnu_getopt_internal (argc, argv, options, long_options, opt_index, 1); +} + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + + +#ifdef TEST + + #include <stdio.h> + +int +main (argc, argv) +int argc; +char **argv; +{ +int c; +int digit_optind = 0; + +while ( 1 ) { + int this_option_optind = gnu_optind ? gnu_optind : 1; + int option_index = 0; + static struct option long_options[] = + { + {"add", 1, 0, 0}, + {"append", 0, 0, 0}, + {"delete", 1, 0, 0}, + {"verbose", 0, 0, 0}, + {"create", 0, 0, 0}, + {"file", 1, 0, 0}, + {0, 0, 0, 0} + }; + + c = gnu_getopt_long (argc, argv, "abc:d:0123456789", + long_options, &option_index); + if ( c == -1 ) + break; + + switch ( c ) { + case 0: + fprintf ( stderr, "option %s", long_options[option_index].name); + if ( gnu_optarg ) + fprintf ( stderr, " with arg %s", gnu_optarg); + fprintf ( stderr, "\n"); + break; + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if ( digit_optind != 0 && digit_optind != this_option_optind ) + fprintf ( stderr, "digits occur in two different argv-elements.\n"); + digit_optind = this_option_optind; + fprintf ( stderr, "option %c\n", c); + break; + + case 'a': + fprintf ( stderr, "option a\n"); + break; + + case 'b': + fprintf ( stderr, "option b\n"); + break; + + case 'c': + fprintf ( stderr, "option c with value `%s'\n", gnu_optarg); + break; + + case 'd': + fprintf ( stderr, "option d with value `%s'\n", gnu_optarg); + break; + + case '?': + break; + + default: + fprintf ( stderr, "?? gnu_getopt returned character code 0%o ??\n", c); + } +} + +if ( gnu_optind < argc ) { + fprintf ( stderr, "non-option ARGV-elements: "); + while ( gnu_optind < argc ) + fprintf ( stderr, "%s ", argv[gnu_optind++]); + fprintf ( stderr, "\n"); +} + +exit (0); +} + +#endif /* TEST */ diff --git a/src/histogram.c b/src/histogram.c new file mode 100644 index 0000000..3a9b82c --- /dev/null +++ b/src/histogram.c @@ -0,0 +1,269 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2017 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * histograms.c + * Suppport for histograms + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- + */ +#include "headers.h" +#include "histogram.h" +#ifdef HAVE_THREAD_DEBUG +// needed for thread_debug +#include "Thread.h" +#endif +struct histogram *histogram_init(unsigned int bincount, unsigned int binwidth, float offset, float units,\ + double ci_lower, double ci_upper, unsigned int id, char *name) { + struct histogram *this = (struct histogram *) malloc(sizeof(struct histogram)); + if (!this) { + fprintf(stderr,"Malloc failure in histogram init\n"); + return(NULL); + } + if (!bincount) + bincount = 1000; + this->mybins = (unsigned int *) malloc(sizeof(unsigned int) * bincount); + if (!this->mybins) { + fprintf(stderr,"Malloc failure in histogram init b\n"); + free(this); + return(NULL); + } + this->myname = (char *) malloc(sizeof(strlen(name))); + if (!this->myname) { + fprintf(stderr,"Malloc failure in histogram init n\n"); + free(this->mybins); + free(this); + return(NULL); + } + this->outbuf = (char *) malloc(120 + (32*bincount) + strlen(name)); + if (!this->outbuf) { + fprintf(stderr,"Malloc failure in histogram init o\n"); + free(this->myname); + free(this->mybins); + free(this); + return(NULL); + } + memset(this->mybins, 0, bincount * sizeof(unsigned int)); + strcpy(this->myname, name); + this->id = id; + this->bincount = bincount; + this->binwidth = binwidth; + this->populationcnt = 0; + this->offset=offset; + this->units=units; + this->cntloweroutofbounds=0; + this->cntupperoutofbounds=0; + this->ci_lower = ci_lower; + this->ci_upper = ci_upper; + this->prev = NULL; + this->maxbin = -1; + this->fmaxbin = -1; + this->maxts.tv_sec = 0; + this->maxts.tv_usec = 0; + this->fmaxts.tv_sec = 0; + this->fmaxts.tv_usec = 0; +#ifdef HAVE_THREAD_DEBUG + thread_debug("histo create %p", (void *) this); +#endif + return this; +} + +void histogram_delete(struct histogram *h) { +#ifdef HAVE_THREAD_DEBUG + thread_debug("histo delete %p", (void *) h); +#endif + if (h) { + if (h->prev) + histogram_delete(h->prev); + if (h->mybins) + free(h->mybins); + if (h->myname) + free(h->myname); + free(h); + } +} + +// value is units seconds +int histogram_insert(struct histogram *h, float value, struct timeval *ts) { + int bin; + // calculate the bin, convert the value units from seconds to units of interest + bin = (int) (h->units * (value - h->offset) / h->binwidth); + h->populationcnt++; + if (ts && (value > h->maxval)) { + h->maxbin = bin; + h->maxval = value; + h->maxts.tv_sec = ts->tv_sec; + h->maxts.tv_usec = ts->tv_usec; + // printf("imax=%ld.%ld %f\n",h->maxts.tv_sec, h->maxts.tv_usec, value); + if (value > h->fmaxval) { + h->fmaxbin = bin; + h->fmaxval = value; + h->fmaxts.tv_sec = ts->tv_sec; + h->fmaxts.tv_usec = ts->tv_usec; + // printf("fmax=%ld.%ld %f\n",h->fmaxts.tv_sec, h->fmaxts.tv_usec, value); + } + } + if (bin < 0) { + h->cntloweroutofbounds++; + return(-1); + } else if (bin > (int) h->bincount) { + h->cntupperoutofbounds++; + return(-2); + } + else { + h->mybins[bin]++; + return(h->mybins[bin]); + } +} + +void histogram_clear(struct histogram *h) { + memset(h->mybins, 0, (h->bincount * sizeof(unsigned int))); + h->populationcnt = 0; + h->cntloweroutofbounds=0; + h->cntupperoutofbounds=0; + h->maxbin = 0; + h->maxts.tv_sec = 0; + h->maxts.tv_usec = 0; + if (h->prev) + histogram_clear(h->prev); + h->prev = NULL; +} + +void histogram_add(struct histogram *to, struct histogram *from) { + int ix; + assert(to != NULL); + assert(from != NULL); + if (to->bincount <= from->bincount) { + for (ix=0; ix < to->bincount; ix ++) { + to->mybins[ix] += from->mybins[ix]; + } + to->populationcnt += from->populationcnt; + to->cntloweroutofbounds += from->cntloweroutofbounds; + to->cntupperoutofbounds += from->cntupperoutofbounds; + if (from->maxbin > to->maxbin) { + to->maxbin = from->maxbin; + } + if (from->maxts.tv_sec > to->maxts.tv_sec) { + to->maxts.tv_sec = from->maxts.tv_sec; + to->maxts.tv_usec = from->maxts.tv_usec; + } else if ((from->maxts.tv_sec == to->maxts.tv_sec) && \ + (from->maxts.tv_usec > to->maxts.tv_usec)) { + to->maxts.tv_usec = from->maxts.tv_usec; + } + } +} + +void histogram_print(struct histogram *h, double start, double end) { + if (h->final && h->prev) { + histogram_clear(h->prev); + } + if (!h->prev) { + h->prev = histogram_init(h->bincount, h->binwidth, h->offset, h->units, h->ci_lower, h->ci_upper, h->id, h->myname); + } + int n = 0, ix, delta, lowerci, upperci, outliercnt, fence_lower, fence_upper, upper3stdev; + int running=0; + int intervalpopulation, oob_u, oob_l; + intervalpopulation = h->populationcnt - h->prev->populationcnt; + strcpy(h->outbuf, h->myname); + sprintf(h->outbuf, "[%3d] " IPERFTimeFrmt " sec %s%s%s bin(w=%d%s):cnt(%d)=", h->id, start, end, h->myname, (h->final ? "(f)" : ""), "-PDF:",h->binwidth, ((h->units == 1e3) ? "ms" : "us"), intervalpopulation); + n = strlen(h->outbuf); + lowerci=0; + upperci=0; + upper3stdev = 0; + outliercnt=0; + fence_lower = 0; + fence_upper = 0; + int outside3fences = 0; + h->prev->populationcnt = h->populationcnt; + oob_l = h->cntloweroutofbounds - h->prev->cntloweroutofbounds; + h->prev->cntloweroutofbounds = h->cntloweroutofbounds; + oob_u = h->cntupperoutofbounds - h->prev->cntupperoutofbounds; + h->prev->cntupperoutofbounds = h->cntupperoutofbounds; + + for (ix = 0; ix < h->bincount; ix++) { + delta = h->mybins[ix] - h->prev->mybins[ix]; + if (delta > 0) { + running+=delta; + if (!lowerci && ((float)running/intervalpopulation > h->ci_lower/100.0)) { + lowerci = ix+1; + } + // use 10% and 90% for inner fence post, then 3 times for outlier + if ((float)running/intervalpopulation < 0.1) { + fence_lower=ix+1; + } + if ((float)running/intervalpopulation < 0.9) { + fence_upper=ix+1; + } else if (!outside3fences) { + outside3fences = fence_upper + (3 * (fence_upper - fence_lower)); + } else if (ix > outside3fences) { + outliercnt += delta; + } + if (!upperci && ((float)running/intervalpopulation > h->ci_upper/100.0)) { + upperci = ix+1; + } + if (!upper3stdev && ((float)running/intervalpopulation > 99.7/100.0)) { + upper3stdev = ix+1; + } + n += sprintf(h->outbuf + n,"%d:%d,", ix+1, delta); + h->prev->mybins[ix] = h->mybins[ix]; + } + } + h->outbuf[strlen(h->outbuf)-1] = '\0'; + if (!upperci) + upperci=h->bincount; + if (!upper3stdev) + upper3stdev=h->bincount; + if (h->ci_upper > 99.7) + fprintf(stdout, "%s (%.2f/99.7/%.2f/%%=%d/%d/%d,Outliers=%d,obl/obu=%d/%d)", \ + h->outbuf, h->ci_lower, h->ci_upper, lowerci, upper3stdev, upperci, outliercnt, oob_l, oob_u); + else + fprintf(stdout, "%s (%.2f/%.2f/99.7%%=%d/%d/%d,Outliers=%d,obl/obu=%d/%d)", \ + h->outbuf, h->ci_lower, h->ci_upper, lowerci, upperci, upper3stdev, outliercnt, oob_l, oob_u); + if (!h->final && (h->maxval > 0) && ((h->maxts.tv_sec > 0) || h->maxts.tv_usec > 0)) { + fprintf(stdout, " (%0.3f ms/%ld.%ld)\n", (h->maxval * 1e3), (long) h->maxts.tv_sec, (long) h->maxts.tv_usec); + h->maxbin = -1; + h->maxval = 0; + } else if (h->final && (h->fmaxval > 0) && ((h->maxts.tv_sec > 0) || h->maxts.tv_usec > 0)) { + fprintf(stdout, " (%0.3f ms/%ld.%ld)\n", (h->fmaxval * 1e3), (long) h->fmaxts.tv_sec, (long) h->fmaxts.tv_usec); + } else { + fprintf(stdout, "\n"); + } +} diff --git a/src/igmp_querier.c b/src/igmp_querier.c new file mode 100644 index 0000000..d18af5b --- /dev/null +++ b/src/igmp_querier.c @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2018 + * Broadcom Corporation + * All Rights Reserved. + * Redistribution and use in source and binary forms, with or without modification, are permitted + * provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this list of conditions + * and the following disclaimer. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the documentation and/or other + * materials provided with the distribution. Neither the name of the Broadcom nor the names of + * contributors may be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USEn, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Author Robert J. McMahon, Broadcom LTD + * Date April 2016 + * + * IGMP 2 querier that can be controlled remotely + * + * Author Robert J. McMahon (rmcmahon) + * Last modified: 06/25/2010 + * + * $Copyright Open Broadcom Corporation$ + * + */ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include <stdio.h> +#include <signal.h> +#include <unistd.h> +#include <stdlib.h> +#include <time.h> +#include <netinet/in.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <strings.h> +#include <string.h> +#include <errno.h> +#include <ctype.h> +#include <arpa/inet.h> +#include "headers.h" + +#define IGMP_HEADER_SIZE 8 + +void sigint(); +void siguser(); +void sigalrm(); +static int querier_sent_count = 0; +static int sendcount = 0; +static short daemonmode = 0; +static char mcast_queryaddr[20] = "224.0.0.1"; +static int send_igmp_allhosts_querier (char *); + + +int main (int argc, char **argv) { + char *tvalue = NULL; + char *cvalue = NULL; + int c; + int queryinterval; + int pid; + + opterr = 0; + while ((c = getopt (argc, argv, "c:dg:t:")) != -1) { + switch (c) { + case 'c': + cvalue = optarg; + break; + case 'g' : + strcpy(mcast_queryaddr, optarg); + break; + case 't': + tvalue = optarg; + break; + case 'd': + daemonmode = 1; + break; + case '?': + if (optopt == 't') + fprintf (stderr, "Option -%c requires an integer argument.\n", optopt); + else if (optopt == 'c') + fprintf (stderr, "Option -%c requires an integer argument.\n", optopt); + else if (isprint (optopt)) + fprintf (stderr, "Unknown option `-%c'.\n", optopt); + else + fprintf (stderr, + "Unknown option character `\\x%x'.\n", + optopt); + default: + fprintf(stderr,"Usage -c <count>, -d daemon, -g <group>, -t <period in seconds>\n"); + exit(-1); + } + } + if (tvalue != NULL) { + queryinterval = atoi(tvalue); + } else { + queryinterval = 0; + } + if (cvalue != NULL) { + sendcount = atoi(cvalue); + if (tvalue == NULL) + queryinterval = 0; + } else { + sendcount = 1; + } + signal(SIGINT, sigint); + signal(SIGUSR1, siguser); + signal(SIGALRM, sigalrm); + pid = (int) getpid(); + if (daemonmode) { + if (tvalue != NULL) { + sendcount = 1; + printf("IGMP All Hosts Querier (pid=%d) started as a daemon with interval of %d seconds to %s\n", pid, queryinterval, mcast_queryaddr); + } else { + sendcount = 0; + printf("IGMP All Hosts Querier (pid=%d) to %s started as a daemon only\n", pid, mcast_queryaddr); + } + } else { + printf("IGMP All Hosts Querier (pid=%d) sending %d reports with interval of %d seconds\n", pid, sendcount, queryinterval); + } + fflush(stdout); + while (daemonmode || sendcount) { + if (sendcount-- > 0) { + send_igmp_allhosts_querier(mcast_queryaddr); + } + if (queryinterval) { + alarm(queryinterval); + pause(); + } + if (daemonmode && sendcount <= 0) + pause(); + } +} + +void sigint (void) { + exit(0); +} + +void siguser (void) { + if (!send_igmp_allhosts_querier(mcast_queryaddr)) { + exit (-1); + } +} + +void sigalrm (void) { + if (daemonmode) + sendcount++; +} + +static int send_igmp_allhosts_querier (char *mcast_queryaddr) { + int sid=0; + int rc; + char buf[IGMP_HEADER_SIZE]; + unsigned int ttl=1; + char type = 17; + char maxresptime = 1; + // unsigned int groupaddr = 0; + char checksum_upper = 0xee; + char checksum_lower = 0xfe; + struct sockaddr_in msock; + const time_t timer = time(NULL); + + bzero (&buf, sizeof(buf)); + /* + * Note: with byte writes shouldn't need to worry about network/host + * byte ordering, though should double check on non intel system + */ + buf[0] = type; + buf[1] = maxresptime; + buf[2] = checksum_upper; + buf[3] = checksum_lower; + + bzero (&msock, sizeof(msock)); + msock.sin_family = AF_INET; + + inet_pton(AF_INET, mcast_queryaddr, &msock.sin_addr); + setuid(geteuid()); + sid = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP); + if (sid != -1) { + rc = setsockopt(sid, IPPROTO_IP, IP_TTL, (char *) &ttl, sizeof(ttl)); + if (rc != -1) { + rc = sendto(sid, &buf, IGMP_HEADER_SIZE, 0, (const struct sockaddr *) &msock, sizeof(msock)); + if (rc == -1) { + fprintf(stderr, "IGMP Query sendto error = %s\n", strerror(errno)); + } + } else { + fprintf(stderr, "IGMP Query setsockopt error = %s\n", strerror(errno)); + } + } else { + fprintf(stderr, "IGMP Query, socket error = %s\n", strerror(errno)); + } + if (sid > 0) { + close(sid); + rc=1; + } else { + rc = 0; + } + setuid(getuid()); + if (rc) { + printf("Sent IGMP all hosts querier to %s (count = %d) at %s",mcast_queryaddr, ++querier_sent_count, ctime(&timer)); + fflush(stdout); + } + return rc; +} diff --git a/src/iperf_formattime.c b/src/iperf_formattime.c new file mode 100644 index 0000000..df65650 --- /dev/null +++ b/src/iperf_formattime.c @@ -0,0 +1,100 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2023 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * iperf_formattime + * wrapper around strftime.c for iperf supported formatting + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- + */ +#include "headers.h" +#include "util.h" +#include "iperf_formattime.h" + +inline void iperf_formattime (char *timestr, int buflen, struct timeval timestamp, bool prec_ms, bool utc_time, enum TimeFormatType ftype) { + struct tm ts ; + ts = (utc_time ? *gmtime(×tamp.tv_sec) : *localtime(×tamp.tv_sec)); + switch (ftype) { + case YearThruSec: + strftime(timestr, buflen, "%Y-%m-%d %H:%M:%S", &ts); + if (prec_ms) { + int currlen = strlen(timestr); + if (currlen > 5) { + snprintf((timestr + currlen), 5, ".%.3d", (int) (timestamp.tv_usec/1000)); + } + } + break; + case YearThruSecTZ: + strftime(timestr, buflen, "%Y-%m-%d %H:%M:%S", &ts); + int currlen = strlen(timestr); + if (prec_ms) { + if (currlen > 5) { + snprintf((timestr + currlen), 5, ".%.3d", (int) (timestamp.tv_usec/1000)); + currlen = strlen(timestr); + } + } + if ((buflen - currlen) > 5) { + strftime((timestr + currlen), (buflen - currlen), " (%Z)", &ts); + } + break; + case CSV: + strftime(timestr, buflen, "%Y%m%d%H%M%S", &ts); + if (prec_ms) { + int currlen = strlen(timestr); + if (currlen > 5) { + snprintf((timestr + currlen), 5, ".%.3d", (int) (timestamp.tv_usec/1000)); + } + } + break; + case CSVTZ: + strftime(timestr, buflen, "%z:%Y%m%d%H%M%S", &ts); + if (prec_ms) { + int currlen = strlen(timestr); + if (currlen > 5) { + snprintf((timestr + currlen), 5, ".%.3d", (int) (timestamp.tv_usec/1000)); + } + } + break; + default: + FAIL_exit(1, "iperf_formattime program error"); + } + timestr[buflen - 1] = '\0'; // make sure string is null terminated +} diff --git a/src/isochronous.cpp b/src/isochronous.cpp new file mode 100644 index 0000000..573f05a --- /dev/null +++ b/src/isochronous.cpp @@ -0,0 +1,275 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2017-2021 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * isochronous.c + * Suppport for isochonronous traffic testing + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- + */ +#include "headers.h" +#include "Timestamp.hpp" +#include "isochronous.hpp" +#include "delay.h" + +#define BILLION 1000000000 + +using namespace Isochronous; + +FrameCounter::FrameCounter (double value, const Timestamp& start) : frequency(value) { + period = static_cast<unsigned int>(1000000 / frequency); + startTime = start; + nextslotTime=start; + lastcounter = 0; + slot_counter = 0; + slip = 0; +} +FrameCounter::FrameCounter (double value) : frequency(value) { +#ifdef WIN32 + /* Create timer */ + my_timer = CreateWaitableTimer(NULL, TRUE, NULL); + if (!SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL)) + WARN_errno(1, "SetThreadPriority"); +#endif + period = static_cast<unsigned int>(1000000 / frequency); // unit us + lastcounter = 0; + slot_counter = 0; + slip = 0; +} + + +FrameCounter::~FrameCounter () { +#ifdef WIN32 + /* Clean resources */ + if (my_timer) + CloseHandle(my_timer); +#endif +} + +#ifdef WIN32 +/* Windows sleep in 100ns units returns 0 on success as does clock_nanosleep*/ +int FrameCounter::mySetWaitableTimer (long delay_time) { + int rc = -1; + if (!my_timer) { + if ((my_timer = CreateWaitableTimer(NULL, TRUE, NULL))) { + /* Set timer properties */ + delay.QuadPart = -delay_time; + } else { + WARN_errno(1, "CreateWaitable"); + my_timer = NULL; + } + } + if (my_timer) { + /* Set timer properties */ + /* negative values are relative, positive absolute UTC time */ + delay.QuadPart = -delay_time; + if(!SetWaitableTimer(my_timer, &delay, 0, NULL, NULL, FALSE)) { + WARN_errno(1, "SetWaitableTimer"); + CloseHandle(my_timer); + my_timer = NULL; + } else { + // Wait for timer + if (WaitForSingleObject(my_timer, INFINITE)) { + WARN_errno(1, "WaitForSingleObject"); + } else { + rc = 0; + } + } + } + return rc; +} +#endif + +#if HAVE_CLOCK_NANOSLEEP +unsigned int FrameCounter::wait_tick (long *sched_err) { + Timestamp now; + int rc = true; + if (!slot_counter) { + slot_counter = 1; + now.setnow(); + nextslotTime = now; + } else { + while (!now.before(nextslotTime)) { + now.setnow(); + nextslotTime.add(period); +// printf("***** next slot %ld.%ld\n",nextslotTime.getSecs(), nextslotTime.getUsecs()); + slot_counter++; + } + if (lastcounter && ((slot_counter - lastcounter) > 1)) { + slip++; + } + } + #ifndef WIN32 + timespec txtime_ts; + txtime_ts.tv_sec = nextslotTime.getSecs(); + txtime_ts.tv_nsec = nextslotTime.getUsecs() * 1000; + rc = clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &txtime_ts, NULL); + #else + long duration = nextslotTime.subUsec(now); + rc = mySetWaitableTimer(10 * duration); // convert us to 100 ns + //int rc = clock_nanosleep(0, TIMER_ABSTIME, &txtime_ts, NULL); + #endif + if (sched_err) { + // delay_loop(2020); + Timestamp actual; + *sched_err = actual.subUsec(nextslotTime); +// printf("**** sched err %ld\n", *sched_err); + if (*sched_err < 0) { + *sched_err = -(*sched_err); // err is an absolute value + // Per windows docs, this timer can go off early per: + // APIs that deal with timers use various different hardware clocks. These clocks may have resolutions + // significantly different from what you expect: some may be measured in milliseconds (for those that + // use an RTC-based timer chip), to those measured in nanoseconds (for those that use ACPI or TSC counters). + // You can change the resolution of your API with a call to the timeBeginPeriod and timeEndPeriod functions. + // How precise you can change the resolution depends on which hardware clock the particular API uses. + // For more information, check your hardware documentation. + // + // I noticed the timer going off up to 8 ms early on a Windows 11 cross compile - yikes. + // Do a WAR hack here to add delay if & when that occurs +#ifdef WIN32 + if (*sched_err > 1000) { + delay_loop(*sched_err); + } +#endif + } + } + WARN_errno((rc!=0), "wait_tick failed"); + #ifdef HAVE_THREAD_DEBUG + // thread_debug("Client tick occurred per %ld.%ld", txtime_ts.tv_sec, txtime_ts.tv_nsec / 1000); + #endif + lastcounter = slot_counter; + return(slot_counter); +} +#else +unsigned int FrameCounter::wait_tick (long *sched_err) { + long remaining; + unsigned int framecounter; + + if (!lastcounter) { + reset(); + framecounter = 1; + } else { + framecounter = get(&remaining); + if ((framecounter - lastcounter) > 1) + slip++; +// delay_loop(remaining); + remaining *= 1000; + struct timespec tv0={0,0}, tv1; + tv0.tv_sec = (remaining / BILLION); + tv0.tv_nsec += (remaining % BILLION); + if (tv0.tv_nsec >= BILLION) { + tv0.tv_sec++; + tv0.tv_nsec -= BILLION; + } + Timestamp slotstart = startTime; + slot_counter = get(); + // period unit is in microseconds, convert to seconds + slotstart.add(slot_counter * period * 1e-6); + int rc = nanosleep(&tv0, &tv1); + if (sched_err) { + Timestamp actual; + *sched_err = actual.subUsec(slotstart); +// printf("**** slot %ld.%ld actual %ld.%ld %ld\n", slotstart.getSecs(), slotstart.getUsecs(), actual.getSecs(), actual.getUsecs(), *sched_err); + } + WARN_errno((rc != 0), "nanosleep wait_tick"); ; +// printf("****** rc = %d, remain %ld.%ld\n", rc, tv1.tv_sec, tv1.tv_nsec); + framecounter ++; + } + lastcounter = framecounter; + return(framecounter); +} +#endif +inline unsigned int FrameCounter::get () const { + Timestamp now; + return slot_counter + 1; +} + +inline unsigned int FrameCounter::get (const Timestamp& slot) const { + return(slot_counter + 1); // Frame counter for packets starts at 1 +} + +inline unsigned int FrameCounter::get (long *ticks_remaining) { + assert(ticks_remaining != NULL); + Timestamp sampleTime; // Constructor will initialize timestamp to now + long usecs = -startTime.subUsec(sampleTime); + unsigned int counter = static_cast<unsigned int>(usecs / period) + 1; + // figure out how many usecs before the next frame counter tick + // the caller can use this to delay until the next tick + *ticks_remaining = (counter * period) - usecs; + return(counter + 1); // Frame counter for packets starts at 1 +} + +inline Timestamp FrameCounter::next_slot () { + Timestamp next = startTime; + slot_counter = get(); + // period unit is in microseconds, convert to seconds + next.add(slot_counter * (period / 1e6)); + return next; +} + +unsigned int FrameCounter::period_us () { + return(period); +} + +void FrameCounter::reset () { + period = (1000000 / frequency); + startTime.setnow(); +} + +unsigned int FrameCounter::wait_sync (long sec, long usec) { + long remaining; + unsigned int framecounter; + startTime.set(sec, usec); + framecounter = get(&remaining); + delay_loop(remaining); + reset(); + framecounter = 1; + lastcounter = 1; + return(framecounter); +} + +long FrameCounter::getSecs () { + return startTime.getSecs(); +} + +long FrameCounter::getUsecs () { + return startTime.getUsecs(); +} diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..7038faa --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,479 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * main.cpp + * by Mark Gates <mgates@nlanr.net> + * & Ajay Tirumala <tirumala@ncsa.uiuc.edu> + * ------------------------------------------------------------------- + * main does initialization and creates the various objects that will + * actually run the iperf program, then waits in the Joinall(). + * ------------------------------------------------------------------- + * headers + * uses + * <stdlib.h> + * <string.h> + * + * <signal.h> + * ------------------------------------------------------------------- */ + +#define HEADERS() + +#include "headers.h" +#include "Settings.hpp" +#include "PerfSocket.hpp" +#include "Locale.h" +#include "Condition.h" +#include "Timestamp.hpp" +#include "Listener.hpp" +#include "active_hosts.h" +#include "util.h" +#include "Reporter.h" +#include "payloads.h" + +#ifdef WIN32 +#include "service.h" +#endif + +/* ------------------------------------------------------------------- + * prototypes + * ------------------------------------------------------------------- */ +// Function called at exit to clean up as much as possible +void cleanup(); +// signal handlers +static void Sig_Interupt(int inSigno); + +/* ------------------------------------------------------------------- + * global variables + * ------------------------------------------------------------------- */ +extern "C" { + // Global flag to signal a user interrupt + int sInterupted = 0; + // Global ID that we increment to be used + // as identifier for SUM reports + int groupID = 0; + // Mutex to protect access to the above ID + Mutex transferid_mutex; + // Condition used to signal the reporter thread + // when a packet ring is full. Shouldn't really + // be needed but is "belts and suspeners" + struct Condition ReportCond; + // Initialize reporter thread mutex + struct AwaitMutex reporter_state; + struct AwaitMutex threads_start; + struct BarrierMutex transmits_start; +} + + +// global variables only accessed within this file + +// Thread that received the SIGTERM or SIGINT signal +// Used to ensure that if multiple threads receive the +// signal we do not prematurely exit +nthread_t sThread; +static thread_Settings* ext_gSettings; +// The main thread uses this function to wait +// for all other threads to complete +void waitUntilQuit(); + +/* ------------------------------------------------------------------- + * main() + * Entry point into Iperf + * + * sets up signal handlers + * initialize global locks and conditions + * parses settings from environment and command line + * starts up server or client thread + * waits for all threads to complete + * ------------------------------------------------------------------- */ +int main(int argc, char **argv) { + + // Set SIGTERM and SIGINT to call our user interrupt function + my_signal(SIGTERM, Sig_Interupt); + my_signal(SIGINT, Sig_Interupt); +#ifndef WIN32 + my_signal(SIGALRM, Sig_Interupt); + // Ignore broken pipes + signal(SIGPIPE,SIG_IGN); +#else + // Start winsock + WSADATA wsaData; + int rc = WSAStartup(0x202, &wsaData); + WARN_errno(rc == SOCKET_ERROR, "WSAStartup"); + if (rc == SOCKET_ERROR) + return 0; + // Tell windows we want to handle our own signals + SetConsoleCtrlHandler(sig_dispatcher, true); +#endif + + // Initialize global mutexes and conditions + Iperf_initialize_active_table(); + Condition_Initialize (&ReportCond); + +#ifdef HAVE_THREAD_DEBUG + Mutex_Initialize(&packetringdebug_mutex); + Mutex_Initialize(&thread_debug_mutex); +#endif + Mutex_Initialize(&transferid_mutex); + + // Initialize reporter thread mutex + reporter_state.ready = 0; + threads_start.ready = 0; + transmits_start.count = 0; + Condition_Initialize(&reporter_state.await); + Condition_Initialize(&threads_start.await); + Condition_Initialize(&transmits_start.await); + + // Initialize the thread subsystem + thread_init(); + + // Initialize the interrupt handling thread to 0 + sThread = thread_zeroid(); + + // perform any cleanup when quitting Iperf + atexit(cleanup); + + // Allocate the "global" settings + ext_gSettings = new thread_Settings; + // Default reporting mode here to avoid unitialized warnings + // this won't be the actual mode + ThreadMode ReporterThreadMode = kMode_Reporter; + // Initialize settings to defaults + Settings_Initialize(ext_gSettings); + // read settings from environment variables + Settings_ParseEnvironment(ext_gSettings); + // read settings from command-line parameters + Settings_ParseCommandLine(argc, argv, ext_gSettings); + + // Check for either having specified client or server + if ((ext_gSettings->mThreadMode != kMode_Client) && (ext_gSettings->mThreadMode != kMode_Listener)) { + // neither server nor client mode was specified + // print usage and exit + +#ifdef WIN32 + // In Win32 we also attempt to start a previously defined service + // Starting in 2.0 to restart a previously defined service + // you must call iperf with "iperf -D" or using the environment variable + SERVICE_TABLE_ENTRY dispatchTable[] = + { + { (LPSTR)TEXT(SZSERVICENAME), (LPSERVICE_MAIN_FUNCTION)service_main}, + { NULL, NULL} + }; + + // starting the service by SCM, there is no arguments will be passed in. + // the arguments will pass into Service_Main entry. + if (!StartServiceCtrlDispatcher(dispatchTable)) + // If the service failed to start then print usage +#endif + fprintf(stderr, usage_short, argv[0], argv[0]); + return 0; + } + + if (!isSTDOUT(ext_gSettings)) { +#ifdef HAVE_FREOPEN + FILE *fd; + fprintf(stdout, "Output from stdout (but not from stderr) will be redirected to file %s\n", ext_gSettings->mOutputFileName); + fflush(stdout); + fd = freopen(ext_gSettings->mOutputFileName, "w", stdout); + FAIL_errno(fd == NULL, "freopen stdout\n", ext_gSettings); +#else + fprintf(stderr, "Output to file not supported\n"); +#endif + + } + + int mbuflen = (ext_gSettings->mBufLen > MINMBUFALLOCSIZE) ? ext_gSettings->mBufLen : MINMBUFALLOCSIZE; +#if (((HAVE_TUNTAP_TUN) || (HAVE_TUNTAP_TAP)) && (AF_PACKET)) + mbuflen += TAPBYTESSLOP; +#endif + ext_gSettings->mBuf = new char[mbuflen]; + memset(ext_gSettings->mBuf, 0, mbuflen); + + + unsetReport(ext_gSettings); + switch (ext_gSettings->mThreadMode) { + case kMode_Client : + if (isDaemon(ext_gSettings)) { + fprintf(stderr, "Iperf client cannot be run as a daemon\n"); + return 0; + } + // initialize client(s) + transmits_start.count = ext_gSettings->mThreads; + ext_gSettings->connects_done = &transmits_start; + client_init(ext_gSettings); + ReporterThreadMode = kMode_ReporterClient; + break; + case kMode_Listener : +#ifdef WIN32 + // Remove the Windows service if requested + if (isRemoveService(ext_gSettings)) { + // remove the service + if (CmdRemoveService()) { + fprintf(stderr, "IPerf Service is removed.\n"); + } + } + if (isDaemon(ext_gSettings)) { + CmdInstallService(argc, argv); + } else if (isRemoveService(ext_gSettings)) { + return 0; + } +#else // *nix system + if (isDaemon(ext_gSettings)) { + fprintf(stderr, "Running Iperf Server as a daemon\n"); + // Start the server as a daemon + // redirect stdin, stdout and sterr to /dev/null (see dameon and no close flag) + if (daemon(1, 0) < 0) { + perror("daemon"); + } + } +#endif + // Start up any parallel listener threads + if (ext_gSettings->mPortLast) { + listeners_init(ext_gSettings); + } + break; + default : + fprintf(stderr, "unknown mode"); + break; + } +#ifdef HAVE_THREAD + // Last step is to initialize the reporter then start all threads + { + thread_Settings *into = NULL; + // Create the settings structure for the reporter thread + Settings_Copy(ext_gSettings, &into, DEEP_COPY); + into->mThreadMode = ReporterThreadMode; + into->mSumReport = NULL; + into->mFullDuplexReport = NULL; + // Have the reporter launch the client or listener + into->runNow = ext_gSettings; + // Start all the threads that are ready to go + thread_start_all(into); + Condition_Lock(threads_start.await); + threads_start.ready = 1; + Condition_Signal(&threads_start.await); + Condition_Unlock(threads_start.await); + } +#else + // No need to make a reporter thread because we don't have threads + thread_start(ext_gSettings); +#endif + // wait for other (client, server) threads to complete + thread_joinall(); + // all done! + return 0; +} // end main + +/* ------------------------------------------------------------------- + * Signal handler sets the sInterupted flag, so the object can + * respond appropriately.. [static] + * ------------------------------------------------------------------- */ + +void Sig_Interupt (int inSigno) { +#ifdef HAVE_THREAD + // We try to not allow a single interrupt handled by multiple threads + // to completely kill the app so we save off the first thread ID + // then that is the only thread that can supply the next interrupt + if ((inSigno == SIGINT) && thread_equalid(sThread, thread_zeroid())) { + sThread = thread_getid(); + } else if (thread_equalid(sThread, thread_getid())) { + sig_exit(inSigno); + } + // global variable used by threads to see if they were interrupted + sInterupted = inSigno; + + // Note: ignore alarms per setitimer +#if HAVE_DECL_SIGALRM + if (inSigno != SIGALRM) +#endif + // with threads, stop waiting for non-terminating threads + // (ie Listener Thread) + thread_release_nonterm(inSigno); + +#else + // without threads, just exit quietly, same as sig_exit() + sig_exit(inSigno); +#endif +} + +/* ------------------------------------------------------------------- + * Any necesary cleanup before Iperf quits. Called at program exit, + * either by exit() or terminating main(). + * ------------------------------------------------------------------- */ + +void cleanup () { +#ifdef WIN32 + // Shutdown Winsock + WSACleanup(); +#endif + // clean up the list of active clients + Iperf_destroy_active_table(); + // done actions + // Destroy global mutexes and conditions + + Condition_Destroy (&ReportCond); + Condition_Destroy(&reporter_state.await); + Condition_Destroy(&threads_start.await); + Condition_Destroy(&transmits_start.await); +#ifdef HAVE_THREAD_DEBUG + Mutex_Destroy(&packetringdebug_mutex); + Mutex_Destroy(&thread_debug_mutex); +#endif + Mutex_Destroy(&transferid_mutex); + // shutdown the thread subsystem + thread_destroy(); +} // end cleanup + +#ifdef WIN32 +/*-------------------------------------------------------------------- + * ServiceStart + * + * each time starting the service, this is the entry point of the service. + * Start the service, certainly it is on server-mode + * + *-------------------------------------------------------------------- */ +VOID ServiceStart (DWORD dwArgc, LPTSTR *lpszArgv) { + thread_Settings* ext_gSettings; + + // report the status to the service control manager. + // + if (!ReportStatusToSCMgr( + SERVICE_START_PENDING, // service state + NO_ERROR, // exit code + 3000)) // wait hint + goto clean; + + ext_gSettings = new thread_Settings; + + // Initialize settings to defaults + Settings_Initialize(ext_gSettings); + // read settings from environment variables + Settings_ParseEnvironment(ext_gSettings); + // read settings from command-line parameters + Settings_ParseCommandLine(dwArgc, lpszArgv, ext_gSettings); + + // Arguments will be lost when the service is started by SCM, but + // we need to be at least a listener + ext_gSettings->mThreadMode = kMode_Listener; + + // report the status to the service control manager. + // + if (!ReportStatusToSCMgr( + SERVICE_START_PENDING, // service state + NO_ERROR, // exit code + 3000)) // wait hint + goto clean; + + // if needed, redirect the output into a specified file + if (!isSTDOUT(ext_gSettings)) { + redirect(ext_gSettings->mOutputFileName); + } + + // report the status to the service control manager. + // + if (!ReportStatusToSCMgr( + SERVICE_START_PENDING, // service state + NO_ERROR, // exit code + 3000)) // wait hint + goto clean; + + // initialize client(s) + if (ext_gSettings->mThreadMode == kMode_Client) { + client_init(ext_gSettings); + } + + // start up the reporter and client(s) or listener + { + thread_Settings *into = NULL; +#ifdef HAVE_THREAD + Settings_Copy(ext_gSettings, &into, DEEP_COPY); + into->mThreadMode = kMode_Reporter; + into->runNow = ext_gSettings; +#else + into = ext_gSettings; +#endif + thread_start_all(into); + } + + // report the status to the service control manager. + // + if (!ReportStatusToSCMgr( + SERVICE_RUNNING, // service state + NO_ERROR, // exit code + 0)) // wait hint + goto clean; + + clean: + // wait for other (client, server) threads to complete + thread_joinall(); +} + +// +// FUNCTION: ServiceStop +// +// PURPOSE: Stops the service +// +// PARAMETERS: +// none +// +// RETURN VALUE: +// none +// +// COMMENTS: +// If a ServiceStop procedure is going to +// take longer than 3 seconds to execute, +// it should spawn a thread to execute the +// stop code, and return. Otherwise, the +// ServiceControlManager will believe that +// the service has stopped responding. +// +VOID ServiceStop() { +#ifdef HAVE_THREAD + Sig_Interupt(1); +#else + sig_exit(1); +#endif +} + +#endif diff --git a/src/packet_ring.c b/src/packet_ring.c new file mode 100644 index 0000000..93e7578 --- /dev/null +++ b/src/packet_ring.c @@ -0,0 +1,219 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2019 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * Suppport for packet rings between threads + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * ------------------------------------------------------------------- + */ +#include "headers.h" +#include "packet_ring.h" +#include "Condition.h" +#include "Thread.h" + +#ifdef HAVE_THREAD_DEBUG +#include "Mutex.h" +static int totalpacketringcount = 0; +Mutex packetringdebug_mutex; +#endif + +struct PacketRing * packetring_init (int count, struct Condition *awake_consumer, struct Condition *awake_producer) { + assert(awake_consumer != NULL); + struct PacketRing *pr = NULL; + if ((pr = (struct PacketRing *) calloc(1, sizeof(struct PacketRing)))) { + pr->bytes = sizeof(struct PacketRing); + pr->data = (struct ReportStruct *) calloc(count, sizeof(struct ReportStruct)); + pr->bytes += count * sizeof(struct ReportStruct); + } + if (!pr || !pr->data) { + fprintf(stderr, "ERROR: no memory for packet ring of size %d count, try to reduce with option --NUM_REPORT_STRUCTS\n", count); + exit(1); + } + pr->producer = 0; + pr->consumer = 0; + pr->maxcount = count; + pr->awake_producer = awake_producer; + pr->awake_consumer = awake_consumer; + if (!awake_producer) + pr->mutex_enable=0; + else + pr->mutex_enable=1; + pr->consumerdone = 0; + pr->awaitcounter = 0; +#ifdef HAVE_THREAD_DEBUG + Mutex_Lock(&packetringdebug_mutex); + totalpacketringcount++; + thread_debug("Init %d element packet ring=%p consumer=%p producer=%p total rings=%d enable=%d", count, \ + (void *)pr, (void *) pr->awake_consumer, (void *) pr->awake_producer, totalpacketringcount, pr->mutex_enable); + Mutex_Unlock(&packetringdebug_mutex); +#endif + return (pr); +} + +inline void packetring_enqueue (struct PacketRing *pr, struct ReportStruct *metapacket) { + while (((pr->producer == pr->maxcount) && (pr->consumer == 0)) || \ + ((pr->producer + 1) == pr->consumer)) { + // Signal the consumer thread to process a full queue + if (pr->mutex_enable) { + assert(pr->awake_consumer != NULL); + Condition_Signal(pr->awake_consumer); + // Wait for the consumer to create some queue space + assert(pr->awake_producer != NULL); + Condition_Lock((*(pr->awake_producer))); + pr->awaitcounter++; +#ifdef HAVE_THREAD_DEBUG_PERF + { + struct timeval now; + static struct timeval prev={0, 0}; + gettimeofday( &now, NULL ); + if (!prev.tv_sec || (TimeDifference(now, prev) > 1.0)) { + prev = now; + thread_debug( "Not good, traffic's packet ring %p stalled per %p", (void *)pr, (void *)&pr->awake_producer); + } + } +#endif + Condition_TimedWait(pr->awake_producer, 1); + Condition_Unlock((*(pr->awake_producer))); + } + } + int writeindex; + if ((pr->producer + 1) == pr->maxcount) + writeindex = 0; + else + writeindex = (pr->producer + 1); + + /* Next two lines must be maintained as is */ + memcpy((pr->data + writeindex), metapacket, sizeof(struct ReportStruct)); + pr->producer = writeindex; +} + +inline struct ReportStruct *packetring_dequeue (struct PacketRing *pr) { + struct ReportStruct *packet = NULL; + if (pr->producer == pr->consumer) + return NULL; + + int readindex; + if ((pr->consumer + 1) == pr->maxcount) + readindex = 0; + else + readindex = (pr->consumer + 1); + packet = (pr->data + readindex); + // advance the consumer pointer last + pr->consumer = readindex; + if (pr->mutex_enable) { + // Signal the traffic thread assigned to this ring + // when the ring goes from having something to empty + if (pr->producer == pr->consumer) { +#ifdef HAVE_THREAD_DEBUG + // thread_debug( "Consumer signal packet ring %p empty per %p", (void *)pr, (void *)&pr->awake_producer); +#endif + assert(pr->awake_producer); + Condition_Signal(pr->awake_producer); + } + } + return packet; +} + +inline void enqueue_ackring (struct PacketRing *pr, struct ReportStruct *metapacket) { + packetring_enqueue(pr, metapacket); + // Keep the latency low by signaling the consumer thread + // per each enqueue +#ifdef HAVE_THREAD_DEBUG + // thread_debug( "Producer signal consumer ackring=%p per %p", (void *)pr, (void *)&pr->awake_consumer); +#endif + Condition_Signal(pr->awake_consumer); +} + +inline struct ReportStruct *dequeue_ackring (struct PacketRing *pr) { + struct ReportStruct *packet = NULL; + Condition_Lock((*(pr->awake_consumer))); + while ((packet = packetring_dequeue(pr)) == NULL) { + Condition_TimedWait(pr->awake_consumer, 1); + } + Condition_Unlock((*(pr->awake_consumer))); + if (packet) { + // Signal the producer thread for low latency + // indication of space available + Condition_Signal(pr->awake_producer); + } + return packet; +} + +void packetring_free (struct PacketRing *pr) { + if (pr) { + if (pr->awaitcounter > 1000) fprintf(stderr, "WARN: Reporter thread may be too slow, await counter=%d, " \ + "consider increasing NUM_REPORT_STRUCTS\n", pr->awaitcounter); + if (pr->data) { +#ifdef HAVE_THREAD_DEBUG + Mutex_Lock(&packetringdebug_mutex); + totalpacketringcount--; + thread_debug("Free packet ring=%p producer=%p (consumer=%p) awaits = %d total rings = %d", \ + (void *)pr, (void *) pr->awake_producer, (void *) pr->awake_consumer, pr->awaitcounter, totalpacketringcount); + Mutex_Unlock(&packetringdebug_mutex); +#endif + free(pr->data); + } + free(pr); + } +} + +void free_ackring(struct PacketRing *pr) { + packetring_free(pr); + Condition_Destroy(pr->awake_consumer); +} + +/* + * This is an estimate and can be incorrect as these counters + * done like this is not thread safe. Use with care as there + * is no guarantee the return value is accurate + */ +#ifdef HAVE_THREAD_DEBUG +inline int packetring_getcount (struct PacketRing *pr) { + int depth = 0; + if (pr->producer != pr->consumer) { + depth = (pr->producer > pr->consumer) ? \ + (pr->producer - pr->consumer) : \ + ((pr->maxcount - pr->consumer) + pr->producer); + // printf("DEBUG: Depth=%d for packet ring %p\n", depth, (void *)pr); + } + return depth; +} +#endif diff --git a/src/pdfs.c b/src/pdfs.c new file mode 100644 index 0000000..a1e0382 --- /dev/null +++ b/src/pdfs.c @@ -0,0 +1,100 @@ +/*--------------------------------------------------------------- + * Copyright (c) 2017 + * Broadcom Corporation + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the name of Broadcom Coporation, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * + * pdfs.c + * Produce probability distribution functions, expected to be used + * for iperf client traffic emulations + * + * Implements the Polar form of the Box-Muller Transformation + * + * by Robert J. McMahon (rjmcmahon@rjmcmahon.com, bob.mcmahon@broadcom.com) + * & Tim Auckland + * ------------------------------------------------------------------- + */ +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include <stdio.h> +#include <stdlib.h> +#include <time.h> +#include <math.h> +#include "headers.h" +#include "pdfs.h" + +#define FALSE 0 +#define TRUE 1 +float box_muller(void) { + float x1, x2, w, y1; + static float y2; + static int generate = FALSE; + /* Each iteration produces two values, if one exists use the value from previous call */ + generate = !generate; + if (!generate) { + y1 = y2; + } else { + int loopcontrol=100; + do { + x1 = 2.0 * (float)rand()/(float)(RAND_MAX) - 1.0; + x2 = 2.0 * (float)rand()/(float)(RAND_MAX) - 1.0; + w = x1 * x1 + x2 * x2; + } while ( w >= 1.0 && --loopcontrol > 0); + if (w >= 1.0) { + fprintf(stderr, "pdf box_muller() rand() error\n"); + return 0; + } else { + w = sqrt( (-2.0 * logf( w ) ) / w ); + y1 = x1 * w; + y2 = x2 * w; + } + } + return(y1); +} + +float normal(float mean, float variance) { + return (box_muller() * variance + mean); +} + +float lognormal(float mu, float sigma) { + float phi = sqrtf((mu * mu) + (sigma * sigma)); + float mu_prime = logf(((mu * mu)/phi)); + float sigma_prime = sqrtf(logf((phi * phi)/(mu * mu))); + return (expf(normal(mu_prime,sigma_prime))); +} diff --git a/src/socket_io.c b/src/socket_io.c new file mode 100644 index 0000000..0475310 --- /dev/null +++ b/src/socket_io.c @@ -0,0 +1,239 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * socket.c + * by Mark Gates <mgates@nlanr.net> + * ------------------------------------------------------------------- + * set/getsockopt and read/write wrappers + * ------------------------------------------------------------------- */ + +#include "headers.h" +#include "util.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------------------------------------------------------- + * Attempts to reads n bytes from a socket. + * Returns number actually read, or -1 on error. + * If number read < inLen then we reached EOF. + * + * from Stevens, 1998, section 3.9 + * ------------------------------------------------------------------- */ +ssize_t readn (int inSock, void *outBuf, size_t inLen) { + size_t nleft; + ssize_t nread; + char *ptr; + + assert(inSock >= 0); + assert(outBuf != NULL); + assert(inLen > 0); + + ptr = (char*) outBuf; + nleft = inLen; + + while (nleft > 0) { + nread = read(inSock, ptr, nleft); + if (nread < 0) { + if (errno == EINTR) + nread = 0; /* interupted, call read again */ + else + return -1; /* error */ + } else if (nread == 0) + break; /* EOF */ + + nleft -= nread; + ptr += nread; + } + + return(inLen - nleft); +} /* end readn */ + +/* ------------------------------------------------------------------- + * Similar to read but supports recv flags + * Returns number actually read, or -1 on error. + * If number read < inLen then we reached EOF. + * from Stevens, 1998, section 3.9 + * ------------------------------------------------------------------- */ +int recvn (int inSock, char *outBuf, int inLen, int flags) { + int nleft; + int nread = 0; + char *ptr; + + assert(inSock >= 0); + assert(outBuf != NULL); + assert(inLen > 0); + + ptr = outBuf; + nleft = inLen; +#if (HAVE_DECL_MSG_PEEK) + if (flags & MSG_PEEK) { + while ((nleft != nread) && !sInterupted) { + nread = recv(inSock, ptr, nleft, flags); + switch (nread) { + case SOCKET_ERROR : + // Note: use TCP fatal error codes even for UDP + if (FATALTCPREADERR(errno)) { + WARN_errno(1, "recvn peek"); + nread = -1; + sInterupted = 1; + goto DONE; + } +#ifdef HAVE_THREAD_DEBUG + WARN_errno(1, "recvn peek non-fatal"); +#endif + break; + case 0: +#ifdef HAVE_THREAD_DEBUG + WARN(1, "recvn peek peer close"); +#endif + goto DONE; + break; + default : + break; + } + } + } else +#endif + { + while ((nleft > 0) && !sInterupted) { +#if (HAVE_DECL_MSG_WAITALL) + nread = recv(inSock, ptr, nleft, MSG_WAITALL); +#else + nread = recv(inSock, ptr, nleft, 0); +#endif + switch (nread) { + case SOCKET_ERROR : + // Note: use TCP fatal error codes even for UDP + if (FATALTCPREADERR(errno)) { + WARN_errno(1, "recvn"); + nread = -1; + sInterupted = 1; + goto DONE; + } else { + nread = -2; + goto DONE; + } +#ifdef HAVE_THREAD_DEBUG + WARN_errno(1, "recvn non-fatal"); +#endif + break; + case 0: +#ifdef HAVE_THREAD_DEBUG + WARN(1, "recvn peer close"); +#endif + nread = inLen - nleft; + goto DONE; + break; + default : + nleft -= nread; + ptr += nread; + break; + } + nread = inLen - nleft; + } + } + DONE: + return(nread); +} /* end readn */ + +/* ------------------------------------------------------------------- + * Attempts to write n bytes to a socket. + * returns number actually written, or -1 on error. + * number written is always inLen if there is not an error. + * + * from Stevens, 1998, section 3.9 + * ------------------------------------------------------------------- */ + +int writen (int inSock, const void *inBuf, int inLen, int *count) { + int nleft; + int nwritten; + const char *ptr; + + assert(inSock >= 0); + assert(inBuf != NULL); + assert(inLen > 0); + assert(count != NULL); + + ptr = (char*) inBuf; + nleft = inLen; + nwritten = 0; + *count = 0; + + while ((nleft > 0) && !sInterupted) { + nwritten = write(inSock, ptr, nleft); + (*count)++; + switch (nwritten) { + case SOCKET_ERROR : + // check for a fatal error vs an error that should retry + if ((errno != EINTR) && (errno != EAGAIN) && (errno != EWOULDBLOCK)) { + nwritten = inLen - nleft; + fprintf(stdout, "FAIL: writen errno = %d\n", errno); + WARN_errno(1, "writen fatal"); + sInterupted = 1; + goto DONE; + } + break; + case 0: + // write timeout - retry + break; + default : + nleft -= nwritten; + ptr += nwritten; + break; + } + nwritten = inLen - nleft; + } + DONE: + return (nwritten); +} /* end writen */ + + + +#ifdef __cplusplus +} /* end extern "C" */ +#endif diff --git a/src/stdio.c b/src/stdio.c new file mode 100644 index 0000000..3bdf668 --- /dev/null +++ b/src/stdio.c @@ -0,0 +1,355 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * stdio.c + * by Mark Gates <mgates@nlanr.net> + * and Ajay Tirumalla <tirumala@ncsa.uiuc.edu> + * ------------------------------------------------------------------- + * input and output numbers, converting with kilo, mega, giga + * ------------------------------------------------------------------- */ + +#include "headers.h" +#include "util.h" + +#ifdef __cplusplus +extern "C" { +#endif + +const long kKilo_to_Unit = 1024; +const long kMega_to_Unit = 1024 * 1024; +const long kGiga_to_Unit = 1024 * 1024 * 1024; + +const long kkilo_to_Unit = 1000; +const long kmega_to_Unit = 1000 * 1000; +const long kgiga_to_Unit = 1000 * 1000 * 1000; + +/* ------------------------------------------------------------------- + * byte_atof + * + * Given a string of form #x where # is a number and x is a format + * character listed below, this returns the interpreted integer. + * Gg, Mm, Kk are giga, mega, kilo respectively + * ------------------------------------------------------------------- */ + +double byte_atof(const char *inString) { + double theNum; + char suffix = '\0'; + + assert(inString != NULL); + + /* scan the number and any suffices */ + sscanf(inString, "%lf%c", &theNum, &suffix); + + /* convert according to [Gg Mm Kk] */ + switch (suffix) { + case 'G': theNum *= kGiga_to_Unit; break; + case 'M': theNum *= kMega_to_Unit; break; + case 'K': theNum *= kKilo_to_Unit; break; + case 'g': theNum *= kgiga_to_Unit; break; + case 'm': theNum *= kmega_to_Unit; break; + case 'k': theNum *= kkilo_to_Unit; break; + default: break; + } + return theNum; +} /* end byte_atof */ + +/* ------------------------------------------------------------------- + * byte_atoi + * + * Given a string of form #x where # is a number and x is a format + * character listed below, this returns the interpreted integer. + * Gg, Mm, Kk are giga, mega, kilo respectively + * ------------------------------------------------------------------- */ + +intmax_t byte_atoi(const char *inString) { + double theNum; + char suffix = '\0'; + + assert(inString != NULL); + + /* scan the number and any suffices */ + sscanf(inString, "%lf%c", &theNum, &suffix); + + /* convert according to [Gg Mm Kk] */ + switch (suffix) { + case 'G': theNum *= kGiga_to_Unit; break; + case 'M': theNum *= kMega_to_Unit; break; + case 'K': theNum *= kKilo_to_Unit; break; + case 'g': theNum *= kgiga_to_Unit; break; + case 'm': theNum *= kmega_to_Unit; break; + case 'k': theNum *= kkilo_to_Unit; break; + default: break; + } + return (intmax_t) theNum; +} /* end byte_atof */ + +/* ------------------------------------------------------------------- + * bitorbyte_atoi + * + * Given a string of form #x where # is a number and x is a format + * character listed below, this returns the interpreted integer. + * Gg, Mm, Kk are giga, mega, kilo respectively + * ------------------------------------------------------------------- */ +uintmax_t bitorbyte_atoi(const char *inString) { + double theNum; + char suffix = '\0'; + + assert(inString != NULL); + + /* scan the number and any suffices */ + sscanf(inString, "%lf%c", &theNum, &suffix); + + /* convert according to [Gg Mm Kk] */ + switch (suffix) { + case 'G': theNum *= (kgiga_to_Unit * 8.0); break; + case 'M': theNum *= (kmega_to_Unit * 8.0); break; + case 'K': theNum *= (kkilo_to_Unit * 8.0); break; + case 'g': theNum *= kgiga_to_Unit; break; + case 'm': theNum *= kmega_to_Unit; break; + case 'k': theNum *= kkilo_to_Unit; break; + default: break; + } + return (uintmax_t) theNum; +} /* end byte_atof */ + +/* ------------------------------------------------------------------- + * bitorbyte_atof + * + * Given a string of form #x where # is a number and x is a format + * character listed below, this returns the interpreted integer. + * Gg, Mm, Kk are giga, mega, kilo respectively + * ------------------------------------------------------------------- */ +double bitorbyte_atof(const char *inString) { + double theNum; + char suffix = '\0'; + + assert(inString != NULL); + + /* scan the number and any suffices */ + sscanf(inString, "%lf%c", &theNum, &suffix); + + /* convert according to [Gg Mm Kk] */ + switch (suffix) { + case 'G': theNum *= (kgiga_to_Unit * 8.0); break; + case 'M': theNum *= (kmega_to_Unit * 8.0); break; + case 'K': theNum *= (kkilo_to_Unit * 8.0); break; + case 'g': theNum *= kgiga_to_Unit; break; + case 'm': theNum *= kmega_to_Unit; break; + case 'k': theNum *= kkilo_to_Unit; break; + case 'p': + case 'P': theNum *= -1; break; + default: break; + } + return theNum; +} /* end byte_atof */ + +/* ------------------------------------------------------------------- + * constants for byte_printf + * ------------------------------------------------------------------- */ + +/* used as indices into kConversion[], kLabel_Byte[], and kLabel_bit[] */ +enum { + kConv_Unit, + kConv_Kilo, + kConv_Mega, + kConv_Giga, + kConv_Tera, + kConv_Peta +}; + +/* factor to multiply the number by */ +const double kConversion[] = +{ + 1.0, /* unit */ + 1.0 / 1024, /* kilo */ + 1.0 / 1024 / 1024, /* mega */ + 1.0 / 1024 / 1024 / 1024, /* giga */ + 1.0 / 1024 / 1024 / 1024 / 1024, /* tera */ + 1.0 / 1024 / 1024 / 1024 / 1024 / 1024 /* peta */ +}; + +/* factor to multiply the number by for bits*/ +const double kConversionForBits[] = +{ + 1.0, /* unit */ + 1.0 / 1000, /* kilo */ + 1.0 / 1000 / 1000, /* mega */ + 1.0 / 1000 / 1000 / 1000, /* giga */ + 1.0 / 1000 / 1000 / 1000 / 1000, /* tera */ + 1.0 / 1000 / 1000 / 1000 / 1000/ 1000 /* peta */ +}; + + +/* labels for Byte formats [KMG] */ +const char* kLabel_Byte[] = +{ + "Byte", + "KByte", + "MByte", + "GByte", + "TByte", + "PByte" +}; + +/* labels for bit formats [kmg] */ +const char* kLabel_bit[] = +{ + "bit", + "Kbit", + "Mbit", + "Gbit", + "Tbit", + "Pbit" +}; + +/* ------------------------------------------------------------------- + * byte_snprintf + * + * Given a number in bytes and a format, converts the number and + * prints it out with a bits or bytes label. + * B, K, M, G, A, P, T for Byte, Kbyte, Mbyte, Gbyte, Tbyte, Pbyte adaptive byte + * b, k, m, g, a, p, t for bit, Kbit, Mbit, Gbit, Tbit, Pbit, adaptive bit + * adaptive picks the "best" one based on the number. + * outString should be at least 11 chars long + * (4 digits + space + 5 chars max + null) + * ------------------------------------------------------------------- */ + +void byte_snprintf(char* outString, int inLen, double inNum, char inFormat) { + int conv = 0; + const char* suffix; + const char* format; + double tmpNum; + + /* convert to bits for [bkmga] */ + if (!isupper((int)inFormat)) { + inNum *= 8; + } + + switch (toupper((int)inFormat)) { + case 'B': conv = kConv_Unit; break; + case 'K': conv = kConv_Kilo; break; + case 'M': conv = kConv_Mega; break; + case 'G': conv = kConv_Giga; break; + case 'T': conv = kConv_Tera; break; + case 'P': conv = kConv_Peta; break; + + default: + case 'A': { + tmpNum = (inNum < 0.0 ? (-1 * inNum) : inNum); + conv = kConv_Unit; + + if (isupper((int)inFormat)) { + while (tmpNum >= 1024.0 && conv < kConv_Peta) { + tmpNum /= 1024.0; + conv++; + } + } else { + while (tmpNum >= 1000.0 && conv < kConv_Peta) { + tmpNum /= 1000.0; + conv++; + } + } + break; + } + } + + if (!isupper((int)inFormat)) { + inNum *= kConversionForBits[conv]; + suffix = kLabel_bit[conv]; + } else { + inNum *= kConversion[conv]; + suffix = kLabel_Byte[conv]; + } + + /* print such that we always fit in 4 places */ + tmpNum = (inNum < 0.0 ? (-1 * inNum) : inNum); + if (tmpNum < 0.9995) { /* 0.995 would be rounded to 1.000 */ + format = "%4.3f %s"; /* #.## */ + } else if (tmpNum < 9.995) { /* 9.995 would be rounded to 10.00 */ + format = "%4.2f %s"; /* #.## */ + } else if (tmpNum < 99.95) { /* 99.95 would be rounded to 100.0 */ + format = "%4.1f %s"; /* ##.# */ + } else if (tmpNum < 999.5) { /* 999.5 would be rounded to 1000 */ + format = "%4.0f %s"; /* ### */ + } else { /* 1000-1024 fits in 4 places + * If not using Adaptive sizes then + * this code will not control spaces*/ + format = "%4.0f %s"; /* #### */ + } + snprintf(outString, inLen, format, inNum, suffix); +} /* end byte_snprintf */ + +/* ------------------------------------------------------------------- + * redirect + * + * redirect the stdout into a specified file + * return: none + * ------------------------------------------------------------------- */ + +void redirect(const char *inOutputFileName) { +#ifdef WIN32 + + FILE *fp; + + if (inOutputFileName == NULL) { + fprintf(stderr, "should specify the output file name.\n"); + return; + } + + fp = freopen(inOutputFileName, "a+", stdout); + if (fp == NULL) { + fprintf(stderr, "redirect stdout failed!\n"); + return; + } + +#endif + +} + + +#ifdef __cplusplus +} /* end extern "C" */ +#endif diff --git a/src/tcp_window_size.c b/src/tcp_window_size.c new file mode 100644 index 0000000..4b5d79b --- /dev/null +++ b/src/tcp_window_size.c @@ -0,0 +1,227 @@ +/*--------------------------------------------------------------- + * Copyright (c) 1999,2000,2001,2002,2003 + * The Board of Trustees of the University of Illinois + * All Rights Reserved. + *--------------------------------------------------------------- + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software (Iperf) and associated + * documentation files (the "Software"), to deal in the Software + * without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit + * persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * + * Redistributions of source code must retain the above + * copyright notice, this list of conditions and + * the following disclaimers. + * + * + * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimers in the documentation and/or other materials + * provided with the distribution. + * + * + * Neither the names of the University of Illinois, NCSA, + * nor the names of its contributors may be used to endorse + * or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES + * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE CONTIBUTORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * ________________________________________________________________ + * National Laboratory for Applied Network Research + * National Center for Supercomputing Applications + * University of Illinois at Urbana-Champaign + * http://www.ncsa.uiuc.edu + * ________________________________________________________________ + * + * tcp_window_size.c + * by Mark Gates <mgates@nlanr.net> + * ------------------------------------------------------------------- + * set/getsockopt + * ------------------------------------------------------------------- */ + +#include "headers.h" + +#include "util.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------------------------------------------------------- + * If inTCPWin > 0, set the TCP window size (via the socket buffer + * sizes) for inSock. Otherwise leave it as the system default. + * + * This must be called prior to calling listen() or connect() on + * the socket, for TCP window sizes > 64 KB to be effective. + * + * This now works on UNICOS also, by setting TCP_WINSHIFT. + * This now works on AIX, by enabling RFC1323. + * returns -1 on error, 0 on no error. + * ------------------------------------------------------------------- */ + +int setsock_tcp_windowsize (int inSock, int inTCPWin, int inSend) { +#ifdef SO_SNDBUF + int rc; + int newTCPWin; + + assert(inSock >= 0); + if (inTCPWin > 0) { +#ifdef TCP_WINSHIFT + /* UNICOS requires setting the winshift explicitly */ + if (inTCPWin > 65535) { + int winShift = 0; + int scaledWin = inTCPWin >> 16; + while (scaledWin > 0) { + scaledWin >>= 1; + winShift++; + } + + /* set TCP window shift */ + rc = setsockopt(inSock, IPPROTO_TCP, TCP_WINSHIFT, + (char*) &winShift, sizeof(winShift)); + if (rc < 0) { + return rc; + } + + /* Note: you cannot verify TCP window shift, since it returns + * a structure and not the same integer we use to set it. (ugh) */ + } +#endif /* TCP_WINSHIFT */ + +#ifdef TCP_RFC1323 + /* On AIX, RFC 1323 extensions can be set system-wide, + * using the 'no' network options command. But we can also set them + * per-socket, so let's try just in case. */ + if (inTCPWin > 65535) { + /* enable RFC 1323 */ + int on = 1; + rc = setsockopt(inSock, IPPROTO_TCP, TCP_RFC1323, + (char*) &on, sizeof(on)); + if (rc < 0) { + return rc; + } + } +#endif /* TCP_RFC1323 */ + + if (!inSend) { + /* receive buffer -- set + * note: results are verified after connect() or listen(), + * since some OS's don't show the corrected value until then. */ + newTCPWin = inTCPWin; + rc = setsockopt(inSock, SOL_SOCKET, SO_RCVBUF, + (char*) &newTCPWin, sizeof(newTCPWin)); + } else { + /* send buffer -- set + * note: results are verified after connect() or listen(), + * since some OS's don't show the corrected value until then. */ + newTCPWin = inTCPWin; + rc = setsockopt(inSock, SOL_SOCKET, SO_SNDBUF, + (char*) &newTCPWin, sizeof(newTCPWin)); + } + if (rc < 0) { + return rc; + } + } +#endif /* SO_SNDBUF */ + return 0; +} /* end setsock_tcp_windowsize */ + +/* ------------------------------------------------------------------- + * returns the TCP window size (on the sending buffer, SO_SNDBUF), + * or -1 on error. + * ------------------------------------------------------------------- */ + +int getsock_tcp_windowsize (int inSock, int inSend) { + int rc = -1; +#ifdef SO_SNDBUF + Socklen_t len; + int theTCPWin = 0; + /* send buffer -- query for buffer size */ + len = sizeof(theTCPWin); + if (inSend) { + rc = getsockopt(inSock, SOL_SOCKET, SO_SNDBUF, + (char*) &theTCPWin, &len); + } else { + rc = getsockopt(inSock, SOL_SOCKET, SO_RCVBUF, + (char*) &theTCPWin, &len); + } + if (rc == 0) { + rc = theTCPWin; + } +#endif + return rc; +} /* end getsock_tcp_windowsize */ + +#if HAVE_DECL_TCP_WINDOW_CLAMP +int setsock_tcp_windowclamp (int inSock, int clampsize) { + assert(inSock >= 0); + assert(clampsize > 0); + int rc; + Socklen_t len; + + len = sizeof(clampsize); + rc = setsockopt(inSock, IPPROTO_TCP, TCP_WINDOW_CLAMP, (char*)(&clampsize), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_WINDOW_CLAMP"); + return rc; +} + +int getsock_tcp_windowclamp (int inSock) { + assert(inSock >= 0); + int clamp = 0; + int rc; + Socklen_t len; + + /* send buffer -- query for buffer size */ + len = sizeof(clamp); + rc = getsockopt(inSock, IPPROTO_TCP, TCP_WINDOW_CLAMP, (char*)(&clamp), &len); + WARN_errno(rc == SOCKET_ERROR, "getsockopt TCP_WINDOW_CLAMP"); + if (rc < 0) { + return rc; + } + return clamp; +} +#endif + +#if HAVE_DECL_TCP_NOTSENT_LOWAT +int setsock_tcp_notsent_low_watermark (int inSock, int watermark) { + assert(inSock >= 0); + assert(watermark > 0); + int rc; + Socklen_t len; + + len = sizeof(watermark); + rc = setsockopt(inSock, IPPROTO_TCP, TCP_NOTSENT_LOWAT, (char*)(&watermark), len); + WARN_errno(rc == SOCKET_ERROR, "setsockopt TCP_NOTSENT_LOWAT"); + return rc; +} + +int getsock_tcp_notsent_low_watermark (int inSock) { + assert(inSock >= 0); + int watermark = 0; + int rc; + Socklen_t len; + + /* send buffer -- query for buffer size */ + len = sizeof(watermark); + rc = getsockopt(inSock, IPPROTO_TCP, TCP_NOTSENT_LOWAT, (char*)(&watermark), &len); + WARN_errno(rc == SOCKET_ERROR, "getsockopt TCP_NOTSENT_LOWAT"); + if (rc < 0) { + return rc; + } + return watermark; +} +#endif +#ifdef __cplusplus +} /* end extern "C" */ +#endif |