src/Statistics.cpp

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