diff options
Diffstat (limited to 'src/Settings.cpp')
| -rw-r--r-- | src/Settings.cpp | 2577 |
1 files changed, 2577 insertions, 0 deletions
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; +} |