From 7c720bec5600a9e607c875c670ca30ed351fa4ba Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 20:20:54 +0200 Subject: Adding upstream version 2.1.9+dfsg. Signed-off-by: Daniel Baumann --- src/Reports.c | 1091 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1091 insertions(+) create mode 100644 src/Reports.c (limited to 'src/Reports.c') 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 +#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 -- cgit v1.2.3