src/Statistics.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 // Copyright (C) 2005-2008  Dévai Tamás ( gonosztopi@amule.org )
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27 #include "Statistics.h"         // Interface declarations
  28
  29 #include <protocol/ed2k/ClientSoftware.h>
  30
  31 #include <ec/cpp/ECTag.h>               // Needed for CECTag
  32
  33 #ifndef EC_REMOTE
  34         #ifndef AMULE_DAEMON
  35                 #include <common/Format.h>              // Needed for CFormat
  36         #endif
  37         #include "DataToText.h"         // Needed for GetSoftName()
  38         #include "Preferences.h"        // Needed for thePrefs
  39         #include "amule.h"              // Needed for theApp
  40         #include "ListenSocket.h"       // (tree, GetAverageConnections)
  41         #include "ServerList.h"         // Needed for CServerList (tree)
  42         #include <cmath>                // Needed for std::floor
  43         #include "updownclient.h"       // Needed for CUpDownClient
  44 #else
  45         #include "Preferences.h"
  46         #include <ec/cpp/RemoteConnect.h>               // Needed for CRemoteConnect
  47 #endif
  48
  49 #include <wx/intl.h>
  50
  51 #ifdef __BSD__
  52         // glibc -> bsd libc
  53         #define round rint
  54 #else
  55         #define round(x) floor(x+0.5)
  56 #endif /* __BSD__ */
  57
  58
  59 #ifndef EC_REMOTE
  60
  61 /*----- CPreciseRateCounter -----*/
  62
  63 void CPreciseRateCounter::CalculateRate(uint64_t now)
  64 {
  65         wxMutexLocker lock(m_mutex);
  66
  67         m_total += m_tmp_sum;
  68         m_byte_history.push_back(m_tmp_sum);
  69         m_tick_history.push_back(now);
  70         m_tmp_sum = 0;
  71
  72         uint64_t timespan = now - m_tick_history.front();
  73
  74         // Checking maximal timespan, but make sure not to remove
  75         // the extra node in m_tick_history.
  76         while (timespan > m_timespan && m_byte_history.size() > 0) {
  77                 m_total -= m_byte_history.front();
  78                 m_byte_history.pop_front();
  79                 m_tick_history.pop_front();
  80                 timespan = now - m_tick_history.front();
  81         }
  82
  83         // Count rate/average
  84         if (m_count_average) {
  85                 if (m_byte_history.size() > 0) {
  86                         m_rate = m_total / (double)m_byte_history.size();
  87                 }
  88         } else {
  89                 if (timespan > 0) {
  90                         m_rate = m_total / (timespan / 1000.0);
  91                 }
  92         }
  93
  94         if (m_rate > m_max_rate) {
  95                 m_max_rate = m_rate;
  96         }
  97 }
  98
  99
 100 /*----- CStatTreeItemRateCounter -----*/
 101
 102 #ifndef AMULE_DAEMON
 103 wxString CStatTreeItemRateCounter::GetDisplayString() const
 104 {
 105         return CFormat(wxGetTranslation(m_label)) % CastItoSpeed(m_show_maxrate ? (uint32)m_max_rate : (uint32)m_rate);
 106 }
 107 #endif
 108
 109 void CStatTreeItemRateCounter::AddECValues(CECTag* tag) const
 110 {
 111         CECTag value(EC_TAG_STAT_NODE_VALUE, m_show_maxrate ? (uint32)m_max_rate : (uint32)m_rate);
 112         value.AddTag(CECTag(EC_TAG_STAT_VALUE_TYPE, (uint8)EC_VALUE_SPEED));
 113         tag->AddTag(value);
 114 }
 115
 116
 117 /*----- CStatTreeItemPeakConnections -----*/
 118
 119 #ifndef AMULE_DAEMON
 120 wxString CStatTreeItemPeakConnections::GetDisplayString() const
 121 {
 122         return wxString::Format(wxGetTranslation(m_label), theStats::GetPeakConnections());
 123 }
 124 #endif
 125
 126 void CStatTreeItemPeakConnections::AddECValues(CECTag* tag) const
 127 {
 128         tag->AddTag(CECTag(EC_TAG_STAT_NODE_VALUE, (uint64)theStats::GetPeakConnections()));
 129 }
 130
 131
 132 /*----- CStatistics -----*/
 133
 134 // Static variables
 135
 136 // Rate counters
 137 CPreciseRateCounter*            CStatistics::s_upOverheadRate;
 138 CPreciseRateCounter*            CStatistics::s_downOverheadRate;
 139 CStatTreeItemRateCounter*       CStatistics::s_uploadrate;
 140 CStatTreeItemRateCounter*       CStatistics::s_downloadrate;
 141
 142 #else /* EC_REMOTE */
 143
 144 uint64  CStatistics::s_start_time;
 145 uint64  CStatistics::s_statData[sdTotalItems];
 146
 147 #endif /* !EC_REMOTE / EC_REMOTE */
 148
 149 // Tree root
 150 CStatTreeItemBase*              CStatistics::s_statTree;
 151
 152 #ifndef EC_REMOTE
 153 // Uptime
 154 CStatTreeItemTimer*             CStatistics::s_uptime;
 155
 156 // Upload
 157 CStatTreeItemUlDlCounter*       CStatistics::s_sessionUpload;
 158 CStatTreeItemPacketTotals*      CStatistics::s_totalUpOverhead;
 159 CStatTreeItemPackets*           CStatistics::s_fileReqUpOverhead;
 160 CStatTreeItemPackets*           CStatistics::s_sourceXchgUpOverhead;
 161 CStatTreeItemPackets*           CStatistics::s_serverUpOverhead;
 162 CStatTreeItemPackets*           CStatistics::s_kadUpOverhead;
 163 CStatTreeItemNativeCounter*     CStatistics::s_activeUploads;
 164 CStatTreeItemNativeCounter*     CStatistics::s_waitingUploads;
 165 CStatTreeItemCounter*           CStatistics::s_totalSuccUploads;
 166 CStatTreeItemCounter*           CStatistics::s_totalFailedUploads;
 167 CStatTreeItemCounter*           CStatistics::s_totalUploadTime;
 168
 169 // Download
 170 CStatTreeItemUlDlCounter*       CStatistics::s_sessionDownload;
 171 CStatTreeItemPacketTotals*      CStatistics::s_totalDownOverhead;
 172 CStatTreeItemPackets*           CStatistics::s_fileReqDownOverhead;
 173 CStatTreeItemPackets*           CStatistics::s_sourceXchgDownOverhead;
 174 CStatTreeItemPackets*           CStatistics::s_serverDownOverhead;
 175 CStatTreeItemPackets*           CStatistics::s_kadDownOverhead;
 176 CStatTreeItemNativeCounter*     CStatistics::s_foundSources;
 177 CStatTreeItemNativeCounter*     CStatistics::s_activeDownloads;
 178
 179 // Connection
 180 CStatTreeItemReconnects*        CStatistics::s_reconnects;
 181 CStatTreeItemTimer*             CStatistics::s_sinceFirstTransfer;
 182 CStatTreeItemTimer*             CStatistics::s_sinceConnected;
 183 CStatTreeItemCounterMax*        CStatistics::s_activeConnections;
 184 CStatTreeItemMaxConnLimitReached* CStatistics::s_limitReached;
 185 CStatTreeItemSimple*            CStatistics::s_avgConnections;
 186
 187 // Clients
 188 CStatTreeItemHiddenCounter*     CStatistics::s_clients;
 189 CStatTreeItemCounter*           CStatistics::s_unknown;
 190 //CStatTreeItem                 CStatistics::s_lowID;
 191 //CStatTreeItem                 CStatistics::s_secIdentOnOff;
 192 #ifdef __DEBUG__
 193 CStatTreeItemNativeCounter*     CStatistics::s_hasSocket;
 194 #endif
 195 CStatTreeItemNativeCounter*     CStatistics::s_filtered;
 196 CStatTreeItemNativeCounter*     CStatistics::s_banned;
 197
 198 // Servers
 199 CStatTreeItemSimple*            CStatistics::s_workingServers;
 200 CStatTreeItemSimple*            CStatistics::s_failedServers;
 201 CStatTreeItemNativeCounter*     CStatistics::s_totalServers;
 202 CStatTreeItemNativeCounter*     CStatistics::s_deletedServers;
 203 CStatTreeItemNativeCounter*     CStatistics::s_filteredServers;
 204 CStatTreeItemSimple*            CStatistics::s_usersOnWorking;
 205 CStatTreeItemSimple*            CStatistics::s_filesOnWorking;
 206 CStatTreeItemSimple*            CStatistics::s_totalUsers;
 207 CStatTreeItemSimple*            CStatistics::s_totalFiles;
 208 CStatTreeItemSimple*            CStatistics::s_serverOccupation;
 209
 210 // Shared files
 211 CStatTreeItemCounter*           CStatistics::s_numberOfShared;
 212 CStatTreeItemCounter*           CStatistics::s_sizeOfShare;
 213
 214 // Kad
 215 uint64                                          CStatistics::s_kadNodesTotal;
 216 uint16                                          CStatistics::s_kadNodesCur;
 217
 218
 219 CStatistics::CStatistics()
 220         : m_graphRunningAvgDown(thePrefs::GetStatsAverageMinutes() * 60 * 1000, true),
 221           m_graphRunningAvgUp(thePrefs::GetStatsAverageMinutes() * 60 * 1000, true),
 222           m_graphRunningAvgKad(thePrefs::GetStatsAverageMinutes() * 60 * 1000, true)
 223 {
 224         uint64 start_time = GetTickCount64();
 225
 226         // Init graphs
 227
 228         average_minutes = thePrefs::GetStatsAverageMinutes();
 229
 230         HR hr = {0.0, 0.0, 0.0, 0.0, 0.0, 0, 0, 0, 0, 0};
 231         hrInit = hr;
 232         nHistRanges = 7;        // =ceil(log(max_update_delay)/log(2))
 233         nPointsPerRange = GetPointsPerRange();
 234         bitsHistClockMask = (1 << (nHistRanges-1)) - 1;
 235         aposRecycle = new listPOS[nHistRanges];
 236         listPOS *ppos = aposRecycle+nHistRanges-1;
 237         for (int i=nHistRanges; i>0; --i) {  // permanently allocated history list
 238                 listHR.push_back(hr);
 239                 *ppos-- = --listHR.end();
 240                 for (int j=nPointsPerRange; j>1; --j)
 241                         listHR.push_back(hr);
 242         }
 243
 244         // Init rate counters outside the tree
 245
 246         s_upOverheadRate = new CPreciseRateCounter(5000);
 247         s_downOverheadRate = new CPreciseRateCounter(5000);
 248
 249         // Init Tree
 250
 251         InitStatsTree();
 252         s_uptime->SetStartTime(start_time);
 253 }
 254
 255
 256 CStatistics::~CStatistics()
 257 {
 258         // clearing listHR frees the memory occupied by the nodes
 259         listHR.clear();
 260         delete [] aposRecycle;
 261
 262         delete s_statTree;
 263
 264         // delete items not in the tree
 265         delete s_totalUploadTime;
 266
 267         // delete rate counters outside the tree
 268         delete s_upOverheadRate;
 269         delete s_downOverheadRate;
 270 }
 271
 272
 273 void CStatistics::CalculateRates()
 274 {
 275         uint64_t now = GetTickCount64();
 276         s_downOverheadRate->CalculateRate(now);
 277         s_upOverheadRate->CalculateRate(now);
 278         s_downloadrate->CalculateRate(now);
 279         s_uploadrate->CalculateRate(now);
 280 }
 281
 282
 283 /* ------------------------------- GRAPHS ---------------------------- */
 284
 285 /*
 286 History List
 287
 288   The basic idea here is that we want to keep as much history as we can without paying
 289 a high price in terms of memory space.  Because we keep the history for display purposes,
 290 we can take advantage of the fact that when the period shown in the graphs is long
 291 then each pixel represents a long period.  So as the most recent history we keep one
 292 window full of points at a resolution of 1 second, the next window full at 2 seconds,
 293 the next at 4 seconds and so on, up to the maximum desired.  This way there is always
 294 at least one sample point per pixel for any update delay set by the user, and the
 295 memory required grows with the *log* of the total time period covered.
 296   The history is kept in a doubly-linked list, with the most recent snapshot at the tail.
 297 The number of nodes in the list is fixed, and there are no calls to RemoveHead() and
 298 AddTail() which would add overhead and contribute to memory fragmentation.  Instead,
 299 every second when a new point gets recorded, one of the existing nodes is recycled;
 300 it is disjoined from its present place, put at the tail of the list, and then gets
 301 filled with new data.   [Emilio Sandoz]
 302   This unfortunately does not work with stl classes, as none of them supports moving
 303 a node to another place, so we have to erase and re-add nodes.
 304 */
 305
 306 void CStatistics::RecordHistory()
 307 {       // First we query and compute some values, then we store them in the history list
 308
 309         // A few comments about the use of double and float in computations:
 310         // Even on a hi-res screen our graphs will have 10 bits of resolution at most,
 311         // so the 24 bits resolution of a float on 32 bit Intel processors is more than
 312         // enough for all displayed values.  Rate computations however, and especially
 313         // running average computations, use differences (delta bytes/ delta time), and
 314         // for long uptimes the difference between two timestamps can lose too much
 315         // accuracy because the large mantissa causes less significant bits to be dropped
 316         // (same for the difference between two cumulative byte counts).  [We don't store
 317         // these values as integers because they will be used in floating point calculations,
 318         // and we want to perform the conversion only once).  Therefore timestamps and
 319         // Kbyte counts are stored in the history as doubles, while computed values use
 320         // float (to save space and execution time).
 321
 322 /*
 323         Store values; first determine the node to be recycled (using the bits in iClock)
 324
 325     oldest records ----------------- listHR ------------------ youngest records
 326
 327         O-[Range 2^n sec]-O- ... -O-[Range 4 sec]-O-[Range 2 sec]-O-[Range 1 sec]-O
 328         |                 |       |               |               > every 2 secs -^
 329         |                 |  ...  |                >--------------- every 4 secs -^
 330         |                 |       >------------------------ recycle every 8 secs -^
 331         |                 |                                                 ...
 332         |                 >-the node at this position is recycled every 2^n secs -^
 333         >-------------------(ditto for the oldest node at the head of the list) --^
 334         ^                                                         ^
 335     aposRecycle[nHistRanges-1]               ...              aposRecycle[0]  Tail
 336 */
 337         listPOS         *ppos;
 338         static int      iClock;
 339         int             iClockPrev = iClock++;
 340         int             bits = (iClockPrev^iClock) & iClock;  // identify the highest changed bit
 341         if (bits <= bitsHistClockMask) {
 342                 ppos = aposRecycle;
 343                 while ((bits /= 2) != 0)  // count to the highest bit that was just toggled to 1
 344                         ++ppos;
 345                 // recycle one node and jump over the next to move it to the next higher range
 346                 listHR.push_back(**ppos);
 347                 *ppos = ++listHR.erase(*ppos);
 348         } else {
 349                 ppos = aposRecycle+nHistRanges-1;
 350                 // recycle the node at the head; there is no higher range to move nodes into
 351                 listHR.push_back(**ppos);
 352                 *ppos = listHR.erase(*ppos);
 353         }
 354
 355         // now save the latest data point in this node
 356         listPOS phr = --listHR.end();
 357         phr->kBytesSent = GetSessionSentBytes() / 1024.0;
 358         phr->kBytesReceived = GetSessionReceivedBytes() / 1024.0;
 359         phr->kBpsUpCur = GetUploadRate() / 1024.0;
 360         phr->kBpsDownCur = GetDownloadRate() / 1024.0;
 361         phr->cntUploads = GetActiveUploadsCount();
 362         phr->cntConnections = GetActiveConnections();
 363         phr->cntDownloads = GetDownloadingSources();
 364         phr->sTimestamp = GetUptimeMillis() / 1000.0;
 365
 366         s_kadNodesTotal += s_kadNodesCur;
 367         phr->kadNodesTotal = s_kadNodesTotal;
 368         phr->kadNodesCur = s_kadNodesCur;
 369 }
 370
 371
 372 unsigned CStatistics::GetHistory(       // Assemble arrays of sample points for a graph
 373         unsigned cntPoints,             // number of sample points to assemble
 374         double sStep,                   // time difference between sample points
 375         double sFinal,                  // latest allowed timestamp
 376         const std::vector<float *> &ppf,// an array of pointers to arrays of floats for the result
 377         StatsGraphType which_graph)     // the graph which will receive the points
 378 {
 379         if (sStep==0.0 || cntPoints==0) {
 380                 return(0);
 381         }
 382
 383         float *pf1 = ppf[0];
 384         float *pf2 = ppf[1];
 385         float *pf3 = ppf[2];
 386         unsigned cntFilled = 0;
 387         listRPOS pos = listHR.rbegin();
 388
 389         // start of list should be an integer multiple of the sampling period for samples
 390         // to be consistent when the graphs are resized horizontally
 391         double  sTarget;
 392         if (sFinal >= 0.0) {
 393                 sTarget = sFinal;
 394         } else {
 395                 sTarget = sStep==1.0 ?
 396                         pos->sTimestamp :
 397                         std::floor(pos->sTimestamp/sStep) * sStep;
 398         }
 399
 400         HR **ahr = NULL, **pphr = NULL;
 401         bool bRateGraph = (which_graph != GRAPH_CONN);  // rate graph or connections graph?
 402         if (bRateGraph) {
 403                 ahr = new HR* [cntPoints];
 404                 pphr = ahr;
 405         }
 406
 407         while (pos != listHR.rend()) {
 408                 if (pos->sTimestamp > sTarget) {
 409                         ++pos;
 410                         continue;
 411                 }
 412                 if (bRateGraph) {               // assemble an array of pointers for ComputeAverages
 413                         *pphr++ = &(*pos);
 414                 } else {                        // or build the arrays if possible
 415                         *pf1++ = (float)pos->cntUploads;
 416                         *pf2++ = (float)pos->cntConnections;
 417                         *pf3++ = (float)pos->cntDownloads;
 418                 }
 419                 if (++cntFilled  == cntPoints) {        // enough points
 420                         break;
 421                 }
 422                 if (pos->sTimestamp == 0.0) {           // reached beginning of uptime
 423                         break;
 424                 }
 425                 if ((sTarget -= sStep) <= 0.0) {        // don't overshoot the beginning
 426                         if (bRateGraph) {
 427                                 *pphr++ = &hrInit;
 428                         } else {
 429                                 *pf1++ = *pf2++ = *pf3++ = 0.0;
 430                         }
 431                         ++cntFilled;
 432                         break;
 433                 }
 434         }
 435
 436         if (bRateGraph) {
 437                 if  (cntFilled > 0) {
 438                         ComputeAverages(pphr, pos, cntFilled, sStep, ppf, which_graph);
 439                 }
 440                 delete[] ahr;
 441         }
 442
 443         return cntFilled;
 444 }
 445
 446
 447 unsigned CStatistics::GetHistoryForWeb(  // Assemble arrays of sample points for the webserver
 448         unsigned cntPoints,             // maximum number of sample points to assemble
 449         double sStep,                   // time difference between sample points
 450         double *sStart,                 // earliest allowed timestamp
 451         uint32 **graphData)             // a pointer to a pointer that will point to the graph data array
 452 {
 453         if (*sStart < 0.0) {
 454                 *sStart = 0.0;
 455         }
 456         if (sStep==0.0 || cntPoints==0)
 457                 return(0);
 458         unsigned        cntFilled = 0;
 459         listRPOS        pos = listHR.rbegin();
 460         double          LastTimeStamp = pos->sTimestamp;
 461         double          sTarget = LastTimeStamp;
 462
 463         HR      **pphr = new HR *[cntPoints];
 464
 465         while (pos != listHR.rend()) {
 466                 if (pos->sTimestamp > sTarget) {
 467                         ++pos;  // find next history record
 468                         continue;
 469                 }
 470                 pphr[cntFilled] = &(*pos);
 471                 if (++cntFilled  == cntPoints)          // enough points
 472                         break;
 473                 if (pos->sTimestamp <= *sStart)         // reached beginning of requested time
 474                         break;
 475                 if ((sTarget -= sStep) <= 0.0) {        // don't overshoot the beginning
 476                         pphr[cntFilled++] = NULL;
 477                         break;
 478                 }
 479         }
 480
 481         if (cntFilled) {
 482                 *graphData = new uint32 [4 * cntFilled];
 483                 if (*graphData) {
 484                         for (unsigned int i = 0; i < cntFilled; i++) {
 485                                 HR *phr = pphr[cntFilled - i - 1];
 486                                 if (phr) {
 487                                         (*graphData)[4 * i    ] = ENDIAN_HTONL((uint32)(phr->kBpsDownCur * 1024.0));
 488                                         (*graphData)[4 * i + 1] = ENDIAN_HTONL((uint32)(phr->kBpsUpCur * 1024.0));
 489                                         (*graphData)[4 * i + 2] = ENDIAN_HTONL((uint32)phr->cntConnections);
 490                                         (*graphData)[4 * i + 3] = ENDIAN_HTONL((uint32)phr->kadNodesCur);
 491                                 } else {
 492                                         (*graphData)[4 * i] = (*graphData)[4 * i + 1] = 0;
 493                                         (*graphData)[4 * i + 2] = (*graphData)[4 * i + 3] = 0;
 494                                 }
 495                         }
 496                 }
 497         } else {
 498                 *graphData = NULL;
 499         }
 500
 501         delete [] pphr;
 502
 503         *sStart = LastTimeStamp;
 504
 505         return cntFilled;
 506 }
 507
 508
 509 void CStatistics::ComputeAverages(
 510         HR              **pphr,         // pointer to (end of) array of assembled history records
 511         listRPOS        pos,            // position in history list from which to backtrack
 512         unsigned        cntFilled,      // number of points in the sample data
 513         double          sStep,          // time difference between two samples
 514         const std::vector<float *> &ppf,// an array of pointers to arrays of floats with sample data
 515         StatsGraphType  which_graph)    // the graph which will receive the points
 516 {
 517         double          sTarget, kValueRun;
 518         uint64          avgTime = average_minutes * 60;
 519         unsigned        nBtPoints = (unsigned)(avgTime / sStep);
 520
 521         CPreciseRateCounter* runningAvg = NULL;
 522         switch (which_graph) {
 523                 case GRAPH_DOWN:        runningAvg = &m_graphRunningAvgDown;    break;
 524                 case GRAPH_UP:          runningAvg = &m_graphRunningAvgUp;              break;
 525                 case GRAPH_KAD:         runningAvg = &m_graphRunningAvgKad;             break;
 526                 default:
 527                         wxCHECK_RET(false, wxT("ComputeAverages called with unsupported graph type."));
 528         }
 529
 530         runningAvg->m_timespan = avgTime * 1000;
 531         runningAvg->m_tick_history.clear();
 532         runningAvg->m_byte_history.clear();
 533         runningAvg->m_total = 0;
 534         runningAvg->m_tmp_sum = 0;
 535
 536         if (pos == listHR.rend()) {
 537                 sTarget = 0.0;
 538         } else {
 539                 sTarget = std::max(0.0, pos->sTimestamp - sStep);
 540         }
 541
 542         while (nBtPoints--) {
 543                 while (pos != listHR.rend() && pos->sTimestamp > sTarget) ++pos;        // find next history record
 544                 if (pos != listHR.rend()) {
 545                         runningAvg->m_tick_history.push_front((uint64)(pos->sTimestamp * 1000.0));
 546
 547                         uint32 value = 0;
 548                         switch (which_graph) {
 549                         case GRAPH_DOWN:
 550                                 value = (uint32)(pos->kBpsDownCur * 1024.0);
 551                                 break;
 552                         case GRAPH_UP:
 553                                 value = (uint32)(pos->kBpsUpCur * 1024.0);
 554                                 break;
 555                         case GRAPH_KAD:
 556                                 value = (uint32)(pos->kadNodesCur * 1024.0);
 557                                 break;
 558                         default:
 559                                 wxCHECK_RET(false, wxT("ComputeAverages called with unsupported graph type."));
 560                         }
 561
 562                         runningAvg->m_byte_history.push_front(value);
 563                         runningAvg->m_total += value;
 564                 } else {
 565                         break;
 566                 }
 567                 if ((sTarget -= sStep) < 0.0) {
 568                         break;
 569                 }
 570         };
 571
 572         // now compute averages in returned arrays, starting with the earliest values
 573         float *pf1 = ppf[0] + cntFilled - 1;    // holds session avg
 574         float *pf2 = ppf[1] + cntFilled - 1;    // holds running avg
 575         float *pf3 = ppf[2] + cntFilled - 1;    // holds current rate
 576
 577         for (int cnt=cntFilled; cnt>0; cnt--, pf1--, pf2--, pf3--) {
 578                 HR *phr = *(--pphr);
 579                 if (which_graph == GRAPH_DOWN) {
 580                         kValueRun = phr->kBytesReceived;
 581                         *pf3 = phr->kBpsDownCur;
 582                 } else if (which_graph == GRAPH_UP) {
 583                         kValueRun = phr->kBytesSent;
 584                         *pf3 = phr->kBpsUpCur;
 585                 } else {
 586                         kValueRun = phr->kadNodesTotal;
 587                         *pf3 = phr->kadNodesCur;
 588                 }
 589
 590                 *pf1 = kValueRun / phr->sTimestamp;
 591                 (*runningAvg) += (uint32)(*pf3 * 1024.0);
 592                 runningAvg->CalculateRate((uint64)(phr->sTimestamp * 1000.0));
 593                 *pf2 = (float)(runningAvg->GetRate() / 1024.0);
 594         }
 595 }
 596
 597
 598 GraphUpdateInfo CStatistics::GetPointsForUpdate()
 599 {
 600         GraphUpdateInfo update;
 601         listPOS phr = --listHR.end();
 602         update.timestamp = (double) phr->sTimestamp;
 603
 604         m_graphRunningAvgDown += (uint32)(phr->kBpsDownCur * 1024.0);
 605         m_graphRunningAvgUp += (uint32)(phr->kBpsUpCur * 1024.0);
 606         // Note: kadNodesCur is multiplied by 1024 since the value is done
 607         // in other places, so we simply follow suit here to avoid trouble.
 608         m_graphRunningAvgKad += (uint32)(phr->kadNodesCur * 1024.0);
 609         m_graphRunningAvgDown.CalculateRate((uint64)(phr->sTimestamp * 1000.0));
 610         m_graphRunningAvgUp.CalculateRate((uint64)(phr->sTimestamp * 1000.0));
 611         m_graphRunningAvgKad.CalculateRate((uint64)(phr->sTimestamp * 1000.0));
 612
 613         update.downloads[0] = phr->kBytesReceived / phr->sTimestamp;
 614         update.downloads[1] = m_graphRunningAvgDown.GetRate() / 1024.0;
 615         update.downloads[2] = phr->kBpsDownCur;
 616
 617         update.uploads[0] = phr->kBytesSent / phr->sTimestamp;
 618         update.uploads[1] = m_graphRunningAvgUp.GetRate() / 1024.0;
 619         update.uploads[2] = phr->kBpsUpCur;
 620
 621         update.connections[0] = (float)phr->cntUploads;
 622         update.connections[1] = (float)phr->cntConnections;
 623         update.connections[2] = (float)phr->cntDownloads;
 624
 625         update.kadnodes[0] = phr->kadNodesTotal / phr->sTimestamp;
 626         update.kadnodes[1] = m_graphRunningAvgKad.GetRate() / 1024.0;
 627         update.kadnodes[2] = phr->kadNodesCur;
 628
 629         return update;
 630 }
 631
 632
 633 /* ------------------------------- TREE ---------------------------- */
 634
 635 void CStatistics::InitStatsTree()
 636 {
 637         s_statTree = new CStatTreeItemBase(wxTRANSLATE("Statistics"));
 638
 639         CStatTreeItemBase* tmpRoot1;
 640         CStatTreeItemBase* tmpRoot2;
 641
 642         s_uptime = (CStatTreeItemTimer*)s_statTree->AddChild(new CStatTreeItemTimer(wxTRANSLATE("Uptime: %s")));
 643
 644         tmpRoot1 = s_statTree->AddChild(new CStatTreeItemBase(wxTRANSLATE("Transfer"), stSortChildren));
 645
 646         tmpRoot2 = tmpRoot1->AddChild(new CStatTreeItemBase(wxTRANSLATE("Uploads")), 2);
 647         s_sessionUpload = (CStatTreeItemUlDlCounter*)tmpRoot2->AddChild(new CStatTreeItemUlDlCounter(wxTRANSLATE("Uploaded Data (Session (Total)): %s"), thePrefs::GetTotalUploaded, stSortChildren | stSortByValue));
 648         // Children will be added on-the-fly
 649         s_totalUpOverhead = (CStatTreeItemPacketTotals*)tmpRoot2->AddChild(new CStatTreeItemPacketTotals(wxTRANSLATE("Total Overhead (Packets): %s")));
 650         s_fileReqUpOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("File Request Overhead (Packets): %s")));
 651         s_totalUpOverhead->AddPacketCounter(s_fileReqUpOverhead);
 652         s_sourceXchgUpOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("Source Exchange Overhead (Packets): %s")));
 653         s_totalUpOverhead->AddPacketCounter(s_sourceXchgUpOverhead);
 654         s_serverUpOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("Server Overhead (Packets): %s")));
 655         s_totalUpOverhead->AddPacketCounter(s_serverUpOverhead);
 656         s_kadUpOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("Kad Overhead (Packets): %s")));
 657         s_totalUpOverhead->AddPacketCounter(s_kadUpOverhead);
 658         s_activeUploads = (CStatTreeItemNativeCounter*)tmpRoot2->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Active Uploads: %s")));
 659         s_waitingUploads = (CStatTreeItemNativeCounter*)tmpRoot2->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Waiting Uploads: %s")));
 660         s_totalSuccUploads = (CStatTreeItemCounter*)tmpRoot2->AddChild(new CStatTreeItemCounter(wxTRANSLATE("Total successful upload sessions: %s")));
 661         s_totalFailedUploads = (CStatTreeItemCounter*)tmpRoot2->AddChild(new CStatTreeItemCounter(wxTRANSLATE("Total failed upload sessions: %s")));
 662         s_totalUploadTime = new CStatTreeItemCounter(wxEmptyString);
 663         tmpRoot2->AddChild(new CStatTreeItemAverage(wxTRANSLATE("Average upload time: %s"), s_totalUploadTime, s_totalSuccUploads, dmTime));
 664
 665         tmpRoot2 = tmpRoot1->AddChild(new CStatTreeItemBase(wxTRANSLATE("Downloads")), 1);
 666         s_sessionDownload = (CStatTreeItemUlDlCounter*)tmpRoot2->AddChild(new CStatTreeItemUlDlCounter(wxTRANSLATE("Downloaded Data (Session (Total)): %s"), thePrefs::GetTotalDownloaded, stSortChildren | stSortByValue));
 667         // Children will be added on-the-fly
 668         s_totalDownOverhead = (CStatTreeItemPacketTotals*)tmpRoot2->AddChild(new CStatTreeItemPacketTotals(wxTRANSLATE("Total Overhead (Packets): %s")));
 669         s_fileReqDownOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("File Request Overhead (Packets): %s")));
 670         s_totalDownOverhead->AddPacketCounter(s_fileReqDownOverhead);
 671         s_sourceXchgDownOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("Source Exchange Overhead (Packets): %s")));
 672         s_totalDownOverhead->AddPacketCounter(s_sourceXchgDownOverhead);
 673         s_serverDownOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("Server Overhead (Packets): %s")));
 674         s_totalDownOverhead->AddPacketCounter(s_serverDownOverhead);
 675         s_kadDownOverhead = (CStatTreeItemPackets*)tmpRoot2->AddChild(new CStatTreeItemPackets(wxTRANSLATE("Kad Overhead (Packets): %s")));
 676         s_totalDownOverhead->AddPacketCounter(s_kadDownOverhead);
 677         s_foundSources = (CStatTreeItemNativeCounter*)tmpRoot2->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Found Sources: %s"), stSortChildren | stSortByValue));
 678         s_activeDownloads = (CStatTreeItemNativeCounter*)tmpRoot2->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Active Downloads (chunks): %s")));
 679
 680         tmpRoot1->AddChild(new CStatTreeItemRatio(wxTRANSLATE("Session UL:DL Ratio (Total): %s"), s_sessionUpload, s_sessionDownload), 3);
 681
 682         tmpRoot1 = s_statTree->AddChild(new CStatTreeItemBase(wxTRANSLATE("Connection")));
 683         tmpRoot1->AddChild(new CStatTreeItemAverageSpeed(wxTRANSLATE("Average Downloadrate (Session): %s"), s_sessionDownload, s_uptime));
 684         tmpRoot1->AddChild(new CStatTreeItemAverageSpeed(wxTRANSLATE("Average Uploadrate (Session): %s"), s_sessionUpload, s_uptime));
 685         s_downloadrate = (CStatTreeItemRateCounter*)tmpRoot1->AddChild(new CStatTreeItemRateCounter(wxTRANSLATE("Max Downloadrate (Session): %s"), true, 30000));
 686         s_uploadrate = (CStatTreeItemRateCounter*)tmpRoot1->AddChild(new CStatTreeItemRateCounter(wxTRANSLATE("Max Uploadrate (Session): %s"), true, 30000));
 687         s_reconnects = (CStatTreeItemReconnects*)tmpRoot1->AddChild(new CStatTreeItemReconnects(wxTRANSLATE("Reconnects: %i")));
 688         s_sinceFirstTransfer = (CStatTreeItemTimer*)tmpRoot1->AddChild(new CStatTreeItemTimer(wxTRANSLATE("Time Since First Transfer: %s"), stHideIfZero));
 689         s_sinceConnected = (CStatTreeItemTimer*)tmpRoot1->AddChild(new CStatTreeItemTimer(wxTRANSLATE("Connected To Server Since: %s")));
 690         s_activeConnections = (CStatTreeItemCounterMax*)tmpRoot1->AddChild(new CStatTreeItemCounterMax(wxTRANSLATE("Active Connections (estimate): %i")));
 691         s_limitReached = (CStatTreeItemMaxConnLimitReached*)tmpRoot1->AddChild(new CStatTreeItemMaxConnLimitReached(wxTRANSLATE("Max Connection Limit Reached: %s")));
 692         s_avgConnections = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Average Connections (estimate): %g")));
 693         s_avgConnections->SetValue(0.0);
 694         tmpRoot1->AddChild(new CStatTreeItemPeakConnections(wxTRANSLATE("Peak Connections (estimate): %i")));
 695
 696         s_clients = (CStatTreeItemHiddenCounter*)s_statTree->AddChild(new CStatTreeItemHiddenCounter(wxTRANSLATE("Clients"), stSortChildren | stSortByValue));
 697         s_unknown = (CStatTreeItemCounter*)s_clients->AddChild(new CStatTreeItemCounter(wxTRANSLATE("Unknown") wxT(": %s")), 6);
 698         //s_lowID = (CStatTreeItem*)s_clients->AddChild(new CStatTreeItem(wxTRANSLATE("LowID: %u (%.2f%% Total %.2f%% Known)")), 5);
 699         //s_secIdentOnOff = (CStatTreeItem*)s_clients->AddChild(new CStatTreeItem(wxTRANSLATE("SecIdent On/Off: %u (%.2f%%) : %u (%.2f%%)")), 4);
 700 #ifdef __DEBUG__
 701         s_hasSocket = (CStatTreeItemNativeCounter*)s_clients->AddChild(new CStatTreeItemNativeCounter(wxT("HasSocket: %s")), 3);
 702 #endif
 703         s_filtered = (CStatTreeItemNativeCounter*)s_clients->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Filtered") wxT(": %s")), 2);
 704         s_banned = (CStatTreeItemNativeCounter*)s_clients->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Banned") wxT(": %s")), 1);
 705         s_clients->AddChild(new CStatTreeItemTotalClients(wxTRANSLATE("Total: %i Known: %i"), s_clients, s_unknown), 0x80000000);
 706
 707         // TODO: Use counters?
 708         tmpRoot1 = s_statTree->AddChild(new CStatTreeItemBase(wxTRANSLATE("Servers")));
 709         s_workingServers = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Working Servers: %i")));
 710         s_failedServers = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Failed Servers: %i")));
 711         s_totalServers = (CStatTreeItemNativeCounter*)tmpRoot1->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Total: %s")));
 712         s_deletedServers = (CStatTreeItemNativeCounter*)tmpRoot1->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Deleted Servers: %s")));
 713         s_filteredServers = (CStatTreeItemNativeCounter*)tmpRoot1->AddChild(new CStatTreeItemNativeCounter(wxTRANSLATE("Filtered Servers: %s")));
 714         s_usersOnWorking = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Users on Working Servers: %llu")));
 715         s_filesOnWorking = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Files on Working Servers: %llu")));
 716         s_totalUsers = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Total Users: %llu")));
 717         s_totalFiles = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Total Files: %llu")));
 718         s_serverOccupation = (CStatTreeItemSimple*)tmpRoot1->AddChild(new CStatTreeItemSimple(wxTRANSLATE("Server Occupation: %.2f%%")));
 719         s_serverOccupation->SetValue(0.0);
 720
 721         tmpRoot1 = s_statTree->AddChild(new CStatTreeItemBase(wxTRANSLATE("Shared Files")));
 722         s_numberOfShared = (CStatTreeItemCounter*)tmpRoot1->AddChild(new CStatTreeItemCounter(wxTRANSLATE("Number of Shared Files: %s")));
 723         s_sizeOfShare = (CStatTreeItemCounter*)tmpRoot1->AddChild(new CStatTreeItemCounter(wxTRANSLATE("Total size of Shared Files: %s")));
 724         s_sizeOfShare->SetDisplayMode(dmBytes);
 725         tmpRoot1->AddChild(new CStatTreeItemAverage(wxTRANSLATE("Average filesize: %s"), s_sizeOfShare, s_numberOfShared, dmBytes));
 726 }
 727
 728
 729 void CStatistics::UpdateStatsTree()
 730 {
 731         // get sort orders right
 732         s_sessionUpload->ReSortChildren();
 733         s_sessionDownload->ReSortChildren();
 734         s_clients->ReSortChildren();
 735         s_foundSources->ReSortChildren();
 736         // TODO: sort OS_Info subtrees.
 737
 738         s_avgConnections->SetValue(theApp->listensocket->GetAverageConnections());
 739
 740 #if 0
 741         (*cli13) = wxString::Format(_("LowID: %u (%.2f%% Total %.2f%% Known)"),#lowid , (#total>0)?((double)100*#lowid/#total):0, (double)100*#knownLowID/#known);
 742         (*cli14) = wxString::Format(_("SecIdent On/Off: %u (%.2f%%) : %u (%.2f%%)"), #secOn , ((#eMule+#aMule)>0)?((double)100*#secOn / (#eMule+#aMule)):0, #secOff, ((#eMule+#aMule)>0)?((double)100*#secOff /(#eMule+#aMule) ):0);
 743 #endif
 744
 745         // get serverstats
 746         // TODO: make these realtime, too
 747         uint32 servfail;
 748         uint32 servuser;
 749         uint32 servfile;
 750         uint32 servtuser;
 751         uint32 servtfile;
 752         float servocc;
 753         theApp->serverlist->GetStatus(servfail, servuser, servfile, servtuser, servtfile, servocc);
 754         s_workingServers->SetValue((uint64)((*s_totalServers)-servfail));
 755         s_failedServers->SetValue((uint64)servfail);
 756         s_usersOnWorking->SetValue((uint64)servuser);
 757         s_filesOnWorking->SetValue((uint64)servfile);
 758         s_totalUsers->SetValue((uint64)servtuser);
 759         s_totalFiles->SetValue((uint64)servtfile);
 760         s_serverOccupation->SetValue(servocc);
 761 }
 762
 763
 764 void CStatistics::AddSourceOrigin(unsigned origin)
 765 {
 766         CStatTreeItemNativeCounter* counter = (CStatTreeItemNativeCounter*)s_foundSources->GetChildById(0x0100 + origin);
 767         if (counter) {
 768                 ++(*counter);
 769         } else {
 770                 counter = new CStatTreeItemNativeCounter(OriginToText(origin) + wxT(": %s"), stHideIfZero | stShowPercent);
 771                 ++(*counter);
 772                 s_foundSources->AddChild(counter, 0x0100 + origin);
 773         }
 774 }
 775
 776 void CStatistics::RemoveSourceOrigin(unsigned origin)
 777 {
 778         CStatTreeItemNativeCounter* counter = (CStatTreeItemNativeCounter*)s_foundSources->GetChildById(0x0100 + origin);
 779         wxASSERT(counter);
 780         --(*counter);
 781 }
 782
 783 uint32 GetSoftID(uint8 SoftType)
 784 {
 785         // prevent appearing multiple tree entries with the same name
 786         // this should be kept in sync with GetSoftName().
 787         switch (SoftType) {
 788                 case SO_OLDEMULE:
 789                         return 0x0100 + SO_EMULE;
 790                 case SO_NEW_SHAREAZA:
 791                 case SO_NEW2_SHAREAZA:
 792                         return 0x0100 + SO_SHAREAZA;
 793                 case SO_NEW2_MLDONKEY:
 794                         return 0x0100 + SO_NEW_MLDONKEY;
 795                 default:
 796                         return 0x0100 + SoftType;
 797         }
 798 }
 799
 800 void CStatistics::AddDownloadFromSoft(uint8 SoftType, uint32 bytes)
 801 {
 802         AddReceivedBytes(bytes);
 803
 804         uint32 id = GetSoftID(SoftType);
 805
 806         if (s_sessionDownload->HasChildWithId(id)) {
 807                 (*((CStatTreeItemCounter*)s_sessionDownload->GetChildById(id))) += bytes;
 808         } else {
 809                 CStatTreeItemCounter* tmp = new CStatTreeItemCounter(GetSoftName(SoftType) + wxT(": %s"));
 810                 tmp->SetDisplayMode(dmBytes);
 811                 (*tmp) += bytes;
 812                 s_sessionDownload->AddChild(tmp, id);
 813         }
 814 }
 815
 816 void CStatistics::AddUploadToSoft(uint8 SoftType, uint32 bytes)
 817 {
 818         uint32 id = GetSoftID(SoftType);
 819
 820         if (s_sessionUpload->HasChildWithId(id)) {
 821                 (*((CStatTreeItemCounter*)s_sessionUpload->GetChildById(id))) += bytes;
 822         } else {
 823                 CStatTreeItemCounter* tmp = new CStatTreeItemCounter(GetSoftName(SoftType) + wxT(": %s"));
 824                 tmp->SetDisplayMode(dmBytes);
 825                 (*tmp) += bytes;
 826                 s_sessionUpload->AddChild(tmp, id);
 827         }
 828 }
 829
 830 inline bool SupportsOSInfo(unsigned clientSoft)
 831 {
 832         return (clientSoft == SO_AMULE) || (clientSoft == SO_HYDRANODE) || (clientSoft == SO_NEW2_MLDONKEY);
 833 }
 834
 835 // Do some random black magic to strings to get a relatively unique number for them.
 836 uint32 GetIdFromString(const wxString& str)
 837 {
 838         uint32 id = 0;
 839         for (unsigned i = 0; i < str.Length(); ++i) {
 840                 unsigned old_id = id;
 841                 id += (uint32)str.GetChar(i);
 842                 id <<= 2;
 843                 id ^= old_id;
 844                 id -= old_id;
 845         }
 846         return ((id >> 1) + id | 0x00000100) & 0x7fffffff;
 847 }
 848
 849 void CStatistics::AddKnownClient(CUpDownClient *pClient)
 850 {
 851         ++(*s_clients);
 852
 853         uint32 clientSoft = pClient->GetClientSoft();
 854         uint32 id = GetSoftID(clientSoft);
 855
 856         CStatTreeItemCounter *client;
 857
 858         if (s_clients->HasChildWithId(id)) {
 859                 client = (CStatTreeItemCounter*)s_clients->GetChildById(id);
 860                 ++(*client);
 861         } else {
 862                 uint32 flags = stSortChildren | stShowPercent | stHideIfZero;
 863                 if (!SupportsOSInfo(clientSoft)) {
 864                         flags |= stCapChildren;
 865                 }
 866                 client = new CStatTreeItemCounter(GetSoftName(clientSoft) + wxT(": %s"), flags);
 867                 ++(*client);
 868                 s_clients->AddChild(client, id);
 869                 if (SupportsOSInfo(clientSoft)) {
 870                         client->AddChild(new CStatTreeItemBase(wxTRANSLATE("Version"), stSortChildren | stCapChildren), 2);
 871                         client->AddChild(new CStatTreeItemBase(wxTRANSLATE("Operating System"), stSortChildren | stSortByValue), 1);
 872                 }
 873         }
 874
 875         CStatTreeItemBase *versionRoot = SupportsOSInfo(clientSoft) ? client->GetChildById(2) : client;
 876         uint32 clientVersion = pClient->GetVersion();
 877
 878         if (versionRoot->HasChildWithId(clientVersion)) {
 879                 CStatTreeItemCounter *version = (CStatTreeItemCounter*)versionRoot->GetChildById(clientVersion);
 880                 ++(*version);
 881         } else {
 882                 const wxString& versionStr = pClient->GetVersionString();
 883                 CStatTreeItemCounter *version = new CStatTreeItemCounter((versionStr.IsEmpty() ? wxString(wxTRANSLATE("Unknown")) : versionStr) + wxT(": %s"), stShowPercent | stHideIfZero);
 884                 ++(*version);
 885                 versionRoot->AddChild(version, clientVersion, SupportsOSInfo(clientSoft));
 886         }
 887
 888         if (SupportsOSInfo(clientSoft)) {
 889                 const wxString& OSInfo = pClient->GetClientOSInfo();
 890                 uint32 OS_ID = OSInfo.IsEmpty() ? 0 : GetIdFromString(OSInfo);
 891                 CStatTreeItemBase* OSRoot = client->GetChildById(1);
 892                 CStatTreeItemCounter* OSNode = (CStatTreeItemCounter*)OSRoot->GetChildById(OS_ID);
 893                 if (OSNode) {
 894                         ++(*OSNode);
 895                 } else {
 896                         OSNode = new CStatTreeItemCounter((OS_ID ? OSInfo : wxString(wxTRANSLATE("Not Received"))) + wxT(": %s"), stShowPercent | stHideIfZero);
 897                         ++(*OSNode);
 898                         OSRoot->AddChild(OSNode, OS_ID, true);
 899                 }
 900         }
 901 }
 902
 903 void CStatistics::RemoveKnownClient(uint32 clientSoft, uint32 clientVersion, const wxString& OSInfo)
 904 {
 905         --(*s_clients);
 906
 907         uint32 id = GetSoftID(clientSoft);
 908
 909         CStatTreeItemCounter *client = (CStatTreeItemCounter*)s_clients->GetChildById(id);
 910         wxASSERT(client);
 911         --(*client);
 912
 913         CStatTreeItemBase *versionRoot = SupportsOSInfo(clientSoft) ? client->GetChildById(2) : client;
 914
 915         CStatTreeItemCounter *version = (CStatTreeItemCounter*)versionRoot->GetChildById(clientVersion);
 916         wxASSERT(version);
 917         --(*version);
 918
 919         if (SupportsOSInfo(clientSoft)) {
 920                 uint32 OS_ID = OSInfo.IsEmpty() ? 0 : GetIdFromString(OSInfo);
 921                 CStatTreeItemCounter* OSNode = (CStatTreeItemCounter*)client->GetChildById(1)->GetChildById(OS_ID);
 922                 wxASSERT(OSNode);
 923                 --(*OSNode);
 924         }
 925 }
 926
 927 #else /* EC_REMOTE (CLIENT_GUI) */
 928
 929 CStatistics::CStatistics(CRemoteConnect &conn)
 930 :
 931 m_conn(conn)
 932 {
 933         s_start_time = GetTickCount64();
 934
 935         // Init Tree
 936         s_statTree = new CStatTreeItemBase(_("Statistics"), 0);
 937
 938         // Clear stat data container
 939         for (int i = 0; i < sdTotalItems; ++i) {
 940                 s_statData[i] = 0;
 941         }
 942 }
 943
 944
 945 CStatistics::~CStatistics()
 946 {
 947         delete s_statTree;
 948 }
 949
 950
 951 void CStatistics::UpdateStats(const CECPacket* stats)
 952 {
 953         s_statData[sdUpload] = stats->GetTagByNameSafe(EC_TAG_STATS_UL_SPEED)->GetInt();
 954         s_statData[sdUpOverhead] = stats->GetTagByNameSafe(EC_TAG_STATS_UP_OVERHEAD)->GetInt();
 955         s_statData[sdDownload] = stats->GetTagByNameSafe(EC_TAG_STATS_DL_SPEED)->GetInt();
 956         s_statData[sdDownOverhead] = stats->GetTagByNameSafe(EC_TAG_STATS_DOWN_OVERHEAD)->GetInt();
 957         s_statData[sdWaitingClients] = stats->GetTagByNameSafe(EC_TAG_STATS_UL_QUEUE_LEN)->GetInt();
 958         s_statData[sdBannedClients] = stats->GetTagByNameSafe(EC_TAG_STATS_BANNED_COUNT)->GetInt();
 959         s_statData[sdED2KUsers] = stats->GetTagByNameSafe(EC_TAG_STATS_ED2K_USERS)->GetInt();
 960         s_statData[sdKadUsers] = stats->GetTagByNameSafe(EC_TAG_STATS_KAD_USERS)->GetInt();
 961         s_statData[sdED2KFiles] = stats->GetTagByNameSafe(EC_TAG_STATS_ED2K_FILES)->GetInt();
 962         s_statData[sdKadFiles] = stats->GetTagByNameSafe(EC_TAG_STATS_KAD_FILES)->GetInt();
 963 }
 964
 965
 966 void CStatistics::UpdateStatsTree()
 967 {
 968         CECPacket request(EC_OP_GET_STATSTREE);
 969         if (thePrefs::GetMaxClientVersions() != 0) {
 970                 request.AddTag(CECTag(EC_TAG_STATTREE_CAPPING, (uint8)thePrefs::GetMaxClientVersions()));
 971         }
 972         const CECPacket* reply = m_conn.SendRecvPacket(&request);
 973         if (reply) {
 974                 const CECTag* treeRoot = reply->GetTagByName(EC_TAG_STATTREE_NODE);
 975                 if (treeRoot) {
 976                         delete s_statTree;
 977                         s_statTree = new CStatTreeItemBase(treeRoot);
 978                 }
 979         }
 980         delete reply;
 981 }
 982
 983 #endif /* !EC_REMOTE */
 984
 985 // File_checked_for_headers