src/amule-remote-gui.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2005-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 //
   6 // Any parts of this program derived from the xMule, lMule or eMule project,
   7 // or contributed by third-party developers are copyrighted by their
   8 // respective authors.
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  23 //
  24
  25
  26 #define AMULE_REMOTE_GUI_CPP
  27
  28
  29 #include <wx/ipc.h>
  30 #include <wx/cmdline.h>                 // Needed for wxCmdLineParser
  31 #include <wx/config.h>                  // Do_not_auto_remove (win32)
  32 #include <wx/fileconf.h>                // Needed for wxFileConfig
  33
  34
  35 #include <common/Format.h>
  36 #include <common/StringFunctions.h>
  37 #include <common/MD5Sum.h>
  38
  39
  40 #include <include/common/EventIDs.h>
  41
  42
  43 #include "amule.h"                      // Interface declarations.
  44 #include "amuleDlg.h"                   // Needed for CamuleDlg
  45 #include "ClientCredits.h"
  46 #include "ClientListCtrl.h"
  47 #include "DataToText.h"                 // Needed for GetSoftName()
  48 #include "DownloadListCtrl.h"           // Needed for CDownloadListCtrl
  49 #include "GuiEvents.h"
  50 #ifdef ENABLE_IP2COUNTRY
  51         #include "IP2Country.h"         // Needed for IP2Country
  52 #endif
  53 #include "InternalEvents.h"     // Needed for wxEVT_CORE_FINISHED_HTTP_DOWNLOAD
  54 #include "Logger.h"
  55 #include "muuli_wdr.h"                  // Needed for IDs
  56 #include "PartFile.h"                   // Needed for CPartFile
  57 #include "SearchDlg.h"                  // Needed for CSearchDlg
  58 #include "Server.h"                     // Needed for GetListName
  59 #include "ServerWnd.h"                  // Needed for CServerWnd
  60 #include "SharedFilesCtrl.h"            // Needed for CSharedFilesCtrl
  61 #include "SharedFilesWnd.h"             // Needed for CSharedFilesWnd
  62 #include "TransferWnd.h"                // Needed for CTransferWnd
  63 #include "updownclient.h"
  64 #include "ServerListCtrl.h"             // Needed for CServerListCtrl
  65 #include "MagnetURI.h"                  // Needed for CMagnetURI
  66 #include "ScopedPtr.h"
  67
  68
  69 CEConnectDlg::CEConnectDlg()
  70 :
  71 wxDialog(theApp->amuledlg, -1, _("Connect to remote amule"), wxDefaultPosition)
  72 {
  73         CoreConnect(this, true);
  74
  75         wxString pref_host, pref_port;
  76         wxConfig::Get()->Read(wxT("/EC/Host"), &pref_host, wxT("localhost"));
  77         wxConfig::Get()->Read(wxT("/EC/Port"), &pref_port, wxT("4712"));
  78         wxConfig::Get()->Read(wxT("/EC/Password"), &pwd_hash);
  79
  80         CastChild(ID_REMOTE_HOST, wxTextCtrl)->SetValue(pref_host);
  81         CastChild(ID_REMOTE_PORT, wxTextCtrl)->SetValue(pref_port);
  82         CastChild(ID_EC_PASSWD, wxTextCtrl)->SetValue(pwd_hash);
  83
  84         CentreOnParent();
  85 }
  86
  87
  88 wxString CEConnectDlg::PassHash()
  89 {
  90         return pwd_hash;
  91 }
  92
  93
  94 BEGIN_EVENT_TABLE(CEConnectDlg, wxDialog)
  95   EVT_BUTTON(wxID_OK, CEConnectDlg::OnOK)
  96 END_EVENT_TABLE()
  97
  98
  99 void CEConnectDlg::OnOK(wxCommandEvent& evt)
 100 {
 101         wxString s_port = CastChild(ID_REMOTE_PORT, wxTextCtrl)->GetValue();
 102         port = StrToLong(s_port);
 103
 104         host = CastChild(ID_REMOTE_HOST, wxTextCtrl)->GetValue();
 105         passwd = CastChild(ID_EC_PASSWD, wxTextCtrl)->GetValue();
 106
 107         if (passwd != pwd_hash) {
 108                 pwd_hash = MD5Sum(passwd).GetHash();
 109         }
 110         m_save_user_pass = CastChild(ID_EC_SAVE, wxCheckBox)->IsChecked();
 111         evt.Skip();
 112 }
 113
 114
 115 DEFINE_LOCAL_EVENT_TYPE(wxEVT_EC_INIT_DONE)
 116
 117
 118 BEGIN_EVENT_TABLE(CamuleRemoteGuiApp, wxApp)
 119         // Core timer
 120         EVT_TIMER(ID_CORE_TIMER_EVENT, CamuleRemoteGuiApp::OnPollTimer)
 121
 122         EVT_CUSTOM(wxEVT_EC_CONNECTION, -1, CamuleRemoteGuiApp::OnECConnection)
 123         EVT_CUSTOM(wxEVT_EC_INIT_DONE, -1, CamuleRemoteGuiApp::OnECInitDone)
 124
 125         EVT_MULE_NOTIFY(CamuleRemoteGuiApp::OnNotifyEvent)
 126
 127 #ifdef ENABLE_IP2COUNTRY
 128         // HTTPDownload finished
 129         EVT_MULE_INTERNAL(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD, -1, CamuleRemoteGuiApp::OnFinishedHTTPDownload)
 130 #endif
 131 END_EVENT_TABLE()
 132
 133
 134 IMPLEMENT_APP(CamuleRemoteGuiApp)
 135
 136
 137 int CamuleRemoteGuiApp::OnExit()
 138 {
 139         StopTickTimer();
 140
 141         return wxApp::OnExit();
 142 }
 143
 144
 145 void CamuleRemoteGuiApp::OnPollTimer(wxTimerEvent&)
 146 {
 147         static int request_step = 0;
 148
 149         if (m_connect->RequestFifoFull()) {
 150                 return;
 151         }
 152
 153         switch (request_step) {
 154         case 0:
 155                 serverconnect->ReQuery();
 156                 serverlist->UpdateUserFileStatus(serverconnect->GetCurrentServer());
 157                 request_step++;
 158                 break;
 159         case 1: {
 160                 CECPacket stats_req(EC_OP_STAT_REQ);
 161                 m_connect->SendRequest(&m_stats_updater, &stats_req);
 162                 amuledlg->ShowTransferRate();
 163                 request_step++;
 164                 break;
 165         }
 166         case 2:
 167                 if (amuledlg->m_sharedfileswnd->IsShown()) {
 168                         sharedfiles->DoRequery(EC_OP_GET_SHARED_FILES, EC_TAG_KNOWNFILE);
 169                 } else if (amuledlg->m_serverwnd->IsShown()) {
 170                         //serverlist->FullReload(EC_OP_GET_SERVER_LIST);
 171                 } else if (amuledlg->m_transferwnd->IsShown()) {
 172                         downloadqueue->DoRequery(EC_OP_GET_DLOAD_QUEUE,
 173                                 EC_TAG_PARTFILE, EC_DETAIL_INC_UPDATE);
 174                         switch(amuledlg->m_transferwnd->clientlistctrl->GetListView()) {
 175                         case vtUploading:
 176                                 uploadqueue->ReQueryUp();
 177                                 break;
 178                         case vtQueued:
 179                                 uploadqueue->ReQueryWait();
 180                                 break;
 181                         case vtClients:
 182                                 break;
 183                         case vtNone:
 184                                 break;
 185                         }
 186                         amuledlg->m_transferwnd->ShowQueueCount(theStats::GetWaitingUserCount());
 187                 } else if (amuledlg->m_searchwnd->IsShown()) {
 188                         if (searchlist->m_curr_search != -1) {
 189                                 searchlist->DoRequery(EC_OP_SEARCH_RESULTS, EC_TAG_SEARCHFILE);
 190                         }
 191                 }
 192                 // Back to the roots
 193                 request_step = 0;
 194                 break;
 195         default:
 196                 AddLogLineCS(wxT("WTF?")); // should not happen. :-)
 197                 request_step = 0;
 198         }
 199 }
 200
 201
 202 void CamuleRemoteGuiApp::OnFinishedHTTPDownload(CMuleInternalEvent& event)
 203 {
 204 #ifdef ENABLE_IP2COUNTRY
 205         if (event.GetInt() == HTTP_GeoIP) {
 206                 amuledlg->IP2CountryDownloadFinished(event.GetExtraLong());
 207                 // If we updated, the dialog is already up. Redraw it to show the flags.
 208                 amuledlg->Refresh();
 209         }
 210 #endif
 211 }
 212
 213
 214 void CamuleRemoteGuiApp::ShutDown(wxCloseEvent &WXUNUSED(evt))
 215 {
 216         // Stop the Core Timer
 217         delete poll_timer;
 218         poll_timer = NULL;
 219
 220         // Destroy the EC socket
 221         m_connect->Destroy();
 222         m_connect = NULL;
 223
 224         //
 225         if (amuledlg) {
 226                 amuledlg->DlgShutDown();
 227                 amuledlg->Destroy();
 228                 amuledlg = NULL;
 229         }
 230 }
 231
 232
 233 bool CamuleRemoteGuiApp::OnInit()
 234 {
 235         StartTickTimer();
 236         amuledlg = NULL;
 237         if ( !wxApp::OnInit() ) {
 238                 return false;
 239         }
 240
 241         // Get theApp
 242         theApp = &wxGetApp();
 243
 244         // Handle uncaught exceptions
 245         InstallMuleExceptionHandler();
 246
 247         // Create the polling timer
 248         poll_timer = new wxTimer(this,ID_CORE_TIMER_EVENT);
 249         if (!poll_timer) {
 250                 AddLogLineCS(_("Fatal Error: Failed to create Poll Timer"));
 251                 OnExit();
 252         }
 253
 254         m_connect = new CRemoteConnect(this);
 255         SetAppName(wxT("aMule"));
 256
 257         // Load Preferences
 258         // This creates the CFG file we shall use
 259         ConfigDir = GetConfigDir();
 260         if (!wxDirExists(ConfigDir)) {
 261                 wxMkdir(ConfigDir);
 262         }
 263
 264         wxConfig::Set(new wxFileConfig(wxEmptyString, wxEmptyString,
 265                 ConfigDir + wxT("remote.conf")));
 266
 267         glob_prefs = new CPreferencesRem(m_connect);
 268
 269         InitCustomLanguages();
 270         InitLocale(m_locale, StrLang2wx(thePrefs::GetLanguageID()));
 271
 272         bool result = ShowConnectionDialog();
 273
 274         AddLogLineNS(_("Going to event loop..."));
 275
 276         return result;
 277 }
 278
 279
 280 bool CamuleRemoteGuiApp::CryptoAvailable() const
 281 {
 282         return thePrefs::IsSecureIdentEnabled(); // good enough
 283 }
 284
 285
 286 bool CamuleRemoteGuiApp::ShowConnectionDialog() {
 287
 288         dialog = new CEConnectDlg;
 289
 290         if (dialog->ShowModal() != wxID_OK) {
 291                 dialog->Destroy();
 292
 293                 return false;
 294         }
 295         AddLogLineNS(_("Connecting..."));
 296         if (!m_connect->ConnectToCore(dialog->Host(), dialog->Port(),
 297                 dialog->Login(), dialog->PassHash(),
 298                 wxT("amule-remote"), wxT("0x0001"))) {
 299                 wxMessageBox(_("Connection failed "),_("ERROR"),wxOK);
 300
 301                 return false;
 302         }
 303
 304         return true;
 305 }
 306
 307
 308 void CamuleRemoteGuiApp::OnECConnection(wxEvent& event) {
 309         wxECSocketEvent& evt = *((wxECSocketEvent*)&event);
 310         AddLogLineNS(_("Remote GUI EC event handler"));
 311         wxString reply = evt.GetServerReply();
 312         AddLogLineM(true, reply);
 313         if (evt.GetResult() == true) {
 314                 // Connected - go to next init step
 315                 glob_prefs->LoadRemote();
 316         } else {
 317                 AddLogLineNS(_("Going down"));
 318                 if (dialog) {   // connect failed
 319                         wxMessageBox(
 320                         (CFormat(_("Connection Failed. Unable to connect to %s:%d\n")) % dialog->Host() % dialog->Port()) + reply,
 321                         _("ERROR"), wxOK);
 322                 } else {                // server disconnected (probably terminated) later
 323                         wxMessageBox(_("Connection closed - aMule has terminated probably."), _("ERROR"), wxOK);
 324                 }
 325                 ExitMainLoop();
 326         }
 327 }
 328
 329
 330 void CamuleRemoteGuiApp::OnECInitDone(wxEvent& )
 331 {
 332         Startup();
 333 }
 334
 335
 336 void CamuleRemoteGuiApp::OnNotifyEvent(CMuleGUIEvent& evt)
 337 {
 338         evt.Notify();
 339 }
 340
 341
 342 void CamuleRemoteGuiApp::Startup() {
 343
 344         if (dialog->SaveUserPass()) {
 345                 wxConfig::Get()->Write(wxT("/EC/Host"), dialog->Host());
 346                 wxConfig::Get()->Write(wxT("/EC/Port"), dialog->Port());
 347                 wxConfig::Get()->Write(wxT("/EC/Password"), dialog->PassHash());
 348         }
 349         dialog->Destroy();
 350         dialog = NULL;
 351
 352         m_ConnState = 0;
 353         m_clientID  = 0;
 354
 355         serverconnect = new CServerConnectRem(m_connect);
 356         m_statistics = new CStatistics(*m_connect);
 357
 358         clientlist = new CClientListRem(m_connect);
 359         searchlist = new CSearchListRem(m_connect);
 360         serverlist = new CServerListRem(m_connect);
 361
 362         sharedfiles     = new CSharedFilesRem(m_connect);
 363         knownfiles = new CKnownFilesRem(sharedfiles);
 364
 365         // bugfix - do this before creating the uploadqueue
 366         downloadqueue = new CDownQueueRem(m_connect);
 367         uploadqueue = new CUpQueueRem(m_connect);
 368         ipfilter = new CIPFilterRem(m_connect);
 369
 370         // Parse cmdline arguments.
 371         wxCmdLineParser cmdline(wxApp::argc, wxApp::argv);
 372         cmdline.AddSwitch(wxT("v"), wxT("version"),
 373                 wxT("Displays the current version number."));
 374         cmdline.AddSwitch(wxT("h"), wxT("help"),
 375                 wxT("Displays this information."));
 376         cmdline.AddOption(wxT("geometry"), wxEmptyString, wxT("Sets the geometry of the app.\n\t\t\t<str> uses the same format as standard X11 apps:\n\t\t\t[=][<width>{xX}<height>][{+-}<xoffset>{+-}<yoffset>]"));
 377         cmdline.Parse();
 378
 379         bool geometry_enabled = false;
 380         wxString geom_string;
 381         if (cmdline.Found(wxT("geometry"), &geom_string)) {
 382                 geometry_enabled = true;
 383         }
 384
 385         // Create main dialog
 386         InitGui(0, geom_string);
 387
 388         // Forward wxLog events to CLogger
 389         wxLog::SetActiveTarget(new CLoggerTarget);
 390         serverlist->FullReload(EC_OP_GET_SERVER_LIST);
 391         sharedfiles->DoRequery(EC_OP_GET_SHARED_FILES, EC_TAG_KNOWNFILE);
 392
 393         // Start the Poll Timer
 394         poll_timer->Start(1000);
 395         amuledlg->StartGuiTimer();
 396
 397         // Now activate GeoIP, so that the download dialog doesn't get destroyed immediately
 398 #ifdef ENABLE_IP2COUNTRY
 399         if (thePrefs::IsGeoIPEnabled()) {
 400                 amuledlg->m_IP2Country->Enable();
 401         }
 402 #endif
 403 }
 404
 405
 406 int CamuleRemoteGuiApp::ShowAlert(wxString msg, wxString title, int flags)
 407 {
 408         return CamuleGuiBase::ShowAlert(msg, title, flags);
 409 }
 410
 411
 412 void CamuleRemoteGuiApp::AddRemoteLogLine(const wxString& line)
 413 {
 414         amuledlg->AddLogLine(line);
 415 }
 416
 417 int CamuleRemoteGuiApp::InitGui(bool geometry_enabled, wxString &geom_string)
 418 {
 419         CamuleGuiBase::InitGui(geometry_enabled, geom_string);
 420         SetTopWindow(amuledlg);
 421         AddLogLineN(_("Ready")); // The first log line after the window is up triggers output of all the ones before
 422         return 0;
 423 }
 424
 425
 426 bool CamuleRemoteGuiApp::CopyTextToClipboard(wxString strText)
 427 {
 428         return CamuleGuiBase::CopyTextToClipboard(strText);
 429 }
 430
 431
 432 uint32 CamuleRemoteGuiApp::GetPublicIP()
 433 {
 434         return 0;
 435 }
 436
 437
 438 wxString CamuleRemoteGuiApp::GetLog(bool)
 439 {
 440         return wxEmptyString;
 441 }
 442
 443
 444 wxString CamuleRemoteGuiApp::GetServerLog(bool)
 445 {
 446         return wxEmptyString;
 447 }
 448
 449
 450 wxString CamuleRemoteGuiApp::CreateMagnetLink(const CAbstractFile* f)
 451 {
 452         // TODO: Remove duplicate code (also in amule.cpp) ...
 453         CMagnetURI uri;
 454
 455         uri.AddField(wxT("dn"), f->GetFileName().Cleanup(false).GetPrintable());
 456         uri.AddField(wxT("xt"), wxString(wxT("urn:ed2k:")) + f->GetFileHash().Encode().Lower());
 457         uri.AddField(wxT("xt"), wxString(wxT("urn:ed2khash:")) + f->GetFileHash().Encode().Lower());
 458         uri.AddField(wxT("xl"), wxString::Format(wxT("%") wxLongLongFmtSpec wxT("u"), f->GetFileSize()));
 459
 460         return uri.GetLink();
 461 }
 462
 463 wxString CamuleRemoteGuiApp::CreateED2kLink(const CAbstractFile* f, bool add_source, bool use_hostname, bool addcryptoptions)
 464 {
 465         // TODO: Avoid duplicate code (also in amule.cpp) ...
 466         wxASSERT(!(!add_source && (use_hostname || addcryptoptions)));
 467         // Construct URL like this: ed2k://|file|<filename>|<size>|<hash>|/
 468         wxString strURL = CFormat(wxT("ed2k://|file|%s|%i|%s|/"))
 469                 % f->GetFileName().Cleanup(false)
 470                 % f->GetFileSize() % f->GetFileHash().Encode();
 471
 472         if (add_source && IsConnected() && !IsFirewalled()) {
 473                 // Create the first part of the URL
 474                 strURL << wxT("|sources,");
 475
 476                 if (use_hostname) {
 477                         strURL << thePrefs::GetYourHostname();
 478                 } else {
 479                         uint32 clientID = GetID();
 480                         strURL << (uint8) clientID << wxT(".") <<
 481                         (uint8)(clientID >> 8) << wxT(".") <<
 482                         (uint8)(clientID >> 16) << wxT(".") <<
 483                         (uint8)(clientID >> 24);
 484                 }
 485
 486                 strURL << wxT(":") <<
 487                         thePrefs::GetPort();
 488
 489                 if (addcryptoptions) {
 490                         const uint8 uSupportsCryptLayer = thePrefs::IsClientCryptLayerSupported() ? 1 : 0;
 491                         const uint8 uRequestsCryptLayer = thePrefs::IsClientCryptLayerRequested() ? 1 : 0;
 492                         const uint8 uRequiresCryptLayer = thePrefs::IsClientCryptLayerRequired() ? 1 : 0;
 493                         const uint8 byCryptOptions = (uRequiresCryptLayer << 2) | (uRequestsCryptLayer << 1) | (uSupportsCryptLayer << 0) | (uSupportsCryptLayer ? 0x80 : 0x00);
 494
 495                         strURL << wxT(":") << byCryptOptions;
 496
 497                         if (byCryptOptions & 0x80) {
 498                                 strURL << wxT(":") << thePrefs::GetUserHash().Encode();
 499                         }
 500
 501                 }
 502                 strURL << wxT("|/");
 503         } else if (add_source) {
 504                 AddLogLineM(true, _("WARNING: You can't add yourself as a source for an eD2k link while having a lowid."));
 505         }
 506
 507         // Result is "ed2k://|file|<filename>|<size>|<hash>|/|sources,[(<ip>|<hostname>):<port>[:cryptoptions[:hash]]]|/"
 508         return strURL;
 509 }
 510
 511
 512 wxString CamuleRemoteGuiApp::CreateED2kAICHLink(const CKnownFile* f)
 513 {
 514         // TODO: Avoid duplicate code (also in amule.cpp) ...
 515         // Create the first part of the URL
 516         wxString strURL = CreateED2kLink(f);
 517         // Append the AICH info
 518         if (f->HasProperAICHHashSet()) {
 519                 strURL.RemoveLast();            // remove trailing '/'
 520                 strURL << wxT("h=") << f->GetAICHMasterHash() << wxT("|/");
 521         }
 522
 523         // Result is "ed2k://|file|<filename>|<size>|<hash>|h=<AICH master hash>|/"
 524         return strURL;
 525 }
 526
 527
 528 bool CamuleRemoteGuiApp::AddServer(CServer *, bool)
 529 {
 530         // #warning TODO: Add remote command
 531         return true;
 532 }
 533
 534
 535 bool CamuleRemoteGuiApp::IsFirewalled() const
 536 {
 537         if (IsConnectedED2K() && !serverconnect->IsLowID()) {
 538                 return false;
 539         }
 540
 541         return IsFirewalledKad();
 542 }
 543
 544
 545 bool CamuleRemoteGuiApp::IsConnectedED2K() const {
 546         return serverconnect && serverconnect->IsConnected();
 547 }
 548
 549
 550 void CamuleRemoteGuiApp::StartKad() {
 551         m_connect->StartKad();
 552 }
 553
 554
 555 void CamuleRemoteGuiApp::StopKad() {
 556         m_connect->StopKad();
 557 }
 558
 559
 560 void CamuleRemoteGuiApp::BootstrapKad(uint32 ip, uint16 port)
 561 {
 562         CECPacket req(EC_OP_KAD_BOOTSTRAP_FROM_IP);
 563         req.AddTag(CECTag(EC_TAG_BOOTSTRAP_IP, ip));
 564         req.AddTag(CECTag(EC_TAG_BOOTSTRAP_PORT, port));
 565
 566         m_connect->SendPacket(&req);
 567 }
 568
 569
 570 void CamuleRemoteGuiApp::UpdateNotesDat(const wxString& url)
 571 {
 572         CECPacket req(EC_OP_KAD_UPDATE_FROM_URL);
 573         req.AddTag(CECTag(EC_TAG_KADEMLIA_UPDATE_URL, url));
 574
 575         m_connect->SendPacket(&req);
 576 }
 577
 578
 579 void CamuleRemoteGuiApp::DisconnectED2K() {
 580         if (IsConnectedED2K()) {
 581                 m_connect->DisconnectED2K();
 582         }
 583 }
 584
 585
 586 uint32 CamuleRemoteGuiApp::GetED2KID() const
 587 {
 588         return serverconnect ? serverconnect->GetClientID() : 0;
 589 }
 590
 591
 592 uint32 CamuleRemoteGuiApp::GetID() const
 593 {
 594         return m_clientID;
 595 }
 596
 597
 598 void CamuleRemoteGuiApp::ShowUserCount() {
 599         wxString buffer;
 600
 601         static const wxString s_singlenetstatusformat = _("Users: %s | Files: %s");
 602         static const wxString s_bothnetstatusformat = _("Users: E: %s K: %s | Files: E: %s K: %s");
 603
 604         if (thePrefs::GetNetworkED2K() && thePrefs::GetNetworkKademlia()) {
 605                 buffer = CFormat(s_bothnetstatusformat) % CastItoIShort(theStats::GetED2KUsers()) % CastItoIShort(theStats::GetKadUsers()) % CastItoIShort(theStats::GetED2KFiles()) % CastItoIShort(theStats::GetKadFiles());
 606         } else if (thePrefs::GetNetworkED2K()) {
 607                 buffer = CFormat(s_singlenetstatusformat) % CastItoIShort(theStats::GetED2KUsers()) % CastItoIShort(theStats::GetED2KFiles());
 608         } else if (thePrefs::GetNetworkKademlia()) {
 609                 buffer = CFormat(s_singlenetstatusformat) % CastItoIShort(theStats::GetKadUsers()) % CastItoIShort(theStats::GetKadFiles());
 610         } else {
 611                 buffer = _("No networks selected");
 612         }
 613
 614         Notify_ShowUserCount(buffer);
 615 }
 616
 617
 618 /*
 619  * Preferences: holds both local and remote settings.
 620  *
 621  * First, everything is loaded from local config file. Later, settings
 622  * that are relevant on remote side only are loaded thru EC
 623  */
 624 CPreferencesRem::CPreferencesRem(CRemoteConnect *conn)
 625 {
 626         m_conn = conn;
 627
 628         CPreferences::BuildItemList(theApp->ConfigDir);
 629         CPreferences::LoadAllItems(wxConfigBase::Get());
 630
 631         //
 632         // Settings queried from remote side
 633         //
 634         m_exchange_send_selected_prefs =
 635                 EC_PREFS_GENERAL |
 636                 EC_PREFS_CONNECTIONS |
 637                 EC_PREFS_MESSAGEFILTER |
 638                 EC_PREFS_ONLINESIG |
 639                 EC_PREFS_SERVERS |
 640                 EC_PREFS_FILES |
 641                 EC_PREFS_SRCDROP |
 642                 EC_PREFS_SECURITY |
 643                 EC_PREFS_CORETWEAKS |
 644                 EC_PREFS_REMOTECONTROLS |
 645                 EC_PREFS_KADEMLIA;
 646         m_exchange_recv_selected_prefs =
 647                 m_exchange_send_selected_prefs |
 648                 EC_PREFS_CATEGORIES;
 649 }
 650
 651
 652 void CPreferencesRem::HandlePacket(const CECPacket *packet)
 653 {
 654         ((CEC_Prefs_Packet *)packet)->Apply();
 655
 656         if ( packet->GetTagByName(EC_TAG_PREFS_CATEGORIES) != 0 ) {
 657                 for (size_t i = 0; i < packet->GetTagByName(EC_TAG_PREFS_CATEGORIES)->GetTagCount(); i++) {
 658                         const CECTag *cat_tag = packet->GetTagByName(EC_TAG_PREFS_CATEGORIES)->GetTagByIndex(i);
 659                         Category_Struct *cat = new Category_Struct;
 660                         cat->title = cat_tag->GetTagByName(EC_TAG_CATEGORY_TITLE)->GetStringData();
 661                         cat->path = CPath(cat_tag->GetTagByName(EC_TAG_CATEGORY_PATH)->GetStringData());
 662                         cat->comment = cat_tag->GetTagByName(EC_TAG_CATEGORY_COMMENT)->GetStringData();
 663                         cat->color =  cat_tag->GetTagByName(EC_TAG_CATEGORY_COLOR)->GetInt();
 664                         cat->prio = cat_tag->GetTagByName(EC_TAG_CATEGORY_PRIO)->GetInt();
 665                         theApp->glob_prefs->AddCat(cat);
 666                 }
 667         } else {
 668                 Category_Struct *cat = new Category_Struct;
 669                 cat->title = _("All");
 670                 cat->color =  0;
 671                 cat->prio = PR_NORMAL;
 672                 theApp->glob_prefs->AddCat(cat);
 673         }
 674         wxECInitDoneEvent event;
 675         theApp->AddPendingEvent(event);
 676
 677 }
 678
 679
 680 bool CPreferencesRem::LoadRemote()
 681 {
 682         //
 683         // override local settings with remote
 684         CECPacket req(EC_OP_GET_PREFERENCES, EC_DETAIL_UPDATE);
 685
 686         // bring categories too
 687         req.AddTag(CECTag(EC_TAG_SELECT_PREFS, m_exchange_recv_selected_prefs));
 688
 689         m_conn->SendRequest(this, &req);
 690
 691         return true;
 692 }
 693
 694
 695 void CPreferencesRem::SendToRemote()
 696 {
 697         CEC_Prefs_Packet pref_packet(m_exchange_send_selected_prefs, EC_DETAIL_UPDATE, EC_DETAIL_FULL);
 698         m_conn->SendPacket(&pref_packet);
 699 }
 700
 701
 702 Category_Struct *CPreferencesRem::CreateCategory(
 703         const wxString& name,
 704         const CPath& path,
 705         const wxString& comment,
 706         uint32 color,
 707         uint8 prio)
 708 {
 709         CECPacket req(EC_OP_CREATE_CATEGORY);
 710         CEC_Category_Tag tag(0xffffffff, name, path.GetRaw(), comment, color, prio);
 711         req.AddTag(tag);
 712         m_conn->SendPacket(&req);
 713
 714         Category_Struct *category = new Category_Struct();
 715         category->path          = path;
 716         category->title         = name;
 717         category->comment       = comment;
 718         category->color         = color;
 719         category->prio          = prio;
 720
 721         AddCat(category);
 722
 723         return category;
 724 }
 725
 726
 727 void CPreferencesRem::UpdateCategory(
 728         uint8 cat,
 729         const wxString& name,
 730         const CPath& path,
 731         const wxString& comment,
 732         uint32 color,
 733         uint8 prio)
 734 {
 735         CECPacket req(EC_OP_UPDATE_CATEGORY);
 736         CEC_Category_Tag tag(cat, name, path.GetRaw(), comment, color, prio);
 737         req.AddTag(tag);
 738         m_conn->SendPacket(&req);
 739
 740         Category_Struct *category = m_CatList[cat];
 741         category->path          = path;
 742         category->title         = name;
 743         category->comment       = comment;
 744         category->color         = color;
 745         category->prio          = prio;
 746 }
 747
 748
 749 void CPreferencesRem::RemoveCat(uint8 cat)
 750 {
 751         CECPacket req(EC_OP_DELETE_CATEGORY);
 752         CEC_Category_Tag tag(cat, EC_DETAIL_CMD);
 753         req.AddTag(tag);
 754         m_conn->SendPacket(&req);
 755         CPreferences::RemoveCat(cat);
 756 }
 757
 758
 759 //
 760 // Container implementation
 761 //
 762 CServerConnectRem::CServerConnectRem(CRemoteConnect *conn)
 763 {
 764         m_CurrServer = 0;
 765         m_Conn = conn;
 766 }
 767
 768
 769 void CServerConnectRem::ConnectToAnyServer()
 770 {
 771         CECPacket req(EC_OP_SERVER_CONNECT);
 772         m_Conn->SendPacket(&req);
 773 }
 774
 775
 776 void CServerConnectRem::StopConnectionTry()
 777 {
 778         // lfroen: isn't Disconnect the same ?
 779 }
 780
 781
 782 void CServerConnectRem::Disconnect()
 783 {
 784         CECPacket req(EC_OP_SERVER_DISCONNECT);
 785         m_Conn->SendPacket(&req);
 786 }
 787
 788
 789 void CServerConnectRem::ConnectToServer(CServer *server)
 790 {
 791         m_Conn->ConnectED2K(server->GetIP(), server->GetPort());
 792 }
 793
 794
 795 bool CServerConnectRem::ReQuery()
 796 {
 797         CECPacket stat_req(EC_OP_GET_CONNSTATE);
 798         m_Conn->SendRequest(this, &stat_req);
 799
 800         return true;
 801 }
 802
 803
 804 void CServerConnectRem::HandlePacket(const CECPacket *packet)
 805 {
 806         CEC_ConnState_Tag *tag =
 807                 (CEC_ConnState_Tag *)packet->GetTagByName(EC_TAG_CONNSTATE);
 808         if (!tag) {
 809                 return;
 810         }
 811
 812         theApp->m_ConnState = 0;
 813         CServer *server;
 814         m_ID = tag->GetEd2kId();
 815         theApp->m_clientID = tag->GetClientId();
 816
 817         if (tag->IsConnectedED2K()) {
 818                 CECTag *srvtag = tag->GetTagByName(EC_TAG_SERVER);
 819                 if (!srvtag) {
 820                         return;
 821                 }
 822                 server = theApp->serverlist->GetByID(srvtag->GetIPv4Data().IP());
 823                 if (m_CurrServer && (server != m_CurrServer)) {
 824                         theApp->amuledlg->m_serverwnd->serverlistctrl->
 825                                 HighlightServer(m_CurrServer, false);
 826                 }
 827                 theApp->amuledlg->m_serverwnd->serverlistctrl->
 828                         HighlightServer(server, true);
 829                 m_CurrServer = server;
 830                 theApp->m_ConnState |= CONNECTED_ED2K;
 831         } else {
 832                 if ( m_CurrServer ) {
 833                         theApp->amuledlg->m_serverwnd->serverlistctrl->
 834                                 HighlightServer(m_CurrServer, false);
 835                         m_CurrServer = 0;
 836                 }
 837         }
 838
 839         if (tag->IsConnectedKademlia()) {
 840                 if (tag->IsKadFirewalled()) {
 841                         theApp->m_ConnState |= CONNECTED_KAD_FIREWALLED;
 842                 } else {
 843                         theApp->m_ConnState |= CONNECTED_KAD_OK;
 844                 }
 845         } else {
 846                 if (tag->IsKadRunning()) {
 847                         theApp->m_ConnState |= CONNECTED_KAD_NOT;
 848                 }
 849         }
 850
 851         theApp->amuledlg->ShowConnectionState();
 852 }
 853
 854
 855 /*
 856  * Server list: host list of ed2k servers.
 857  */
 858 CServerListRem::CServerListRem(CRemoteConnect *conn)
 859 :
 860 CRemoteContainer<CServer, uint32, CEC_Server_Tag>(conn)
 861 {
 862 }
 863
 864
 865 void CServerListRem::HandlePacket(const CECPacket *packet)
 866 {
 867         CRemoteContainer<CServer, uint32, CEC_Server_Tag>::HandlePacket(packet);
 868         ReloadControl();
 869 }
 870
 871
 872 void CServerListRem::UpdateServerMetFromURL(wxString url)
 873 {
 874         CECPacket req(EC_OP_SERVER_UPDATE_FROM_URL);
 875         req.AddTag(CECTag(EC_TAG_SERVERS_UPDATE_URL, url));
 876
 877         m_conn->SendPacket(&req);
 878 }
 879
 880
 881 void CServerListRem::SaveServerMet()
 882 {
 883         // lfroen: stub, nothing to do
 884 }
 885
 886
 887 void CServerListRem::FilterServers()
 888 {
 889         // FIXME: add code
 890         //wxFAIL;
 891 }
 892
 893
 894 void CServerListRem::RemoveServer(CServer* server)
 895 {
 896         m_conn->RemoveServer(server->GetIP(),server->GetPort());
 897 }
 898
 899
 900 void CServerListRem::UpdateUserFileStatus(CServer *server)
 901 {
 902         if (server) {
 903                 m_TotalUser = server->GetUsers();
 904                 m_TotalFile = server->GetFiles();
 905
 906                 wxString buffer =
 907                         CFormat(_("Total Users: %s | Total Files: %s")) % CastItoIShort(m_TotalUser) % CastItoIShort(m_TotalFile);
 908
 909                 Notify_ShowUserCount(buffer);
 910         }
 911 }
 912
 913
 914 CServer *CServerListRem::GetServerByAddress(const wxString& WXUNUSED(address), uint16 WXUNUSED(port)) const
 915 {
 916         // It's ok to return 0 for context where this code is used in remote gui
 917         return 0;
 918 }
 919
 920 CServer *CServerListRem::GetServerByIPTCP(uint32 WXUNUSED(nIP), uint16 WXUNUSED(nPort)) const
 921 {
 922         // It's ok to return 0 for context where this code is used in remote gui
 923         return 0;
 924 }
 925
 926 CServer *CServerListRem::CreateItem(CEC_Server_Tag *tag)
 927 {
 928         return new CServer(tag);
 929 }
 930
 931
 932 void CServerListRem::DeleteItem(CServer *in_srv)
 933 {
 934         CScopedPtr<CServer> srv(in_srv);
 935         theApp->amuledlg->m_serverwnd->serverlistctrl->RemoveServer(srv.get());
 936 }
 937
 938
 939 uint32 CServerListRem::GetItemID(CServer *server)
 940 {
 941         return server->GetIP();
 942 }
 943
 944
 945 void CServerListRem::ProcessItemUpdate(CEC_Server_Tag *, CServer *)
 946 {
 947         // server list is always realoaded from scratch
 948         wxFAIL;
 949 }
 950
 951
 952 void CServerListRem::ReloadControl()
 953 {
 954         for(uint32 i = 0;i < GetCount(); i++) {
 955                 CServer *srv = GetByIndex(i);
 956                 theApp->amuledlg->m_serverwnd->serverlistctrl->RefreshServer(srv);
 957         }
 958 }
 959
 960
 961 CIPFilterRem::CIPFilterRem(CRemoteConnect* conn)
 962 {
 963         m_conn = conn;
 964 }
 965
 966
 967 void CIPFilterRem::Reload()
 968 {
 969         CECPacket req(EC_OP_IPFILTER_RELOAD);
 970         m_conn->SendPacket(&req);
 971 }
 972
 973
 974 void CIPFilterRem::Update(wxString WXUNUSED(url))
 975 {
 976         // FIXME: add command
 977         //wxFAIL;
 978 }
 979
 980
 981 /*
 982  * Shared files list
 983  */
 984 CSharedFilesRem::CSharedFilesRem(CRemoteConnect *conn) : CRemoteContainer<CKnownFile, CMD4Hash, CEC_SharedFile_Tag>(conn, true)
 985 {
 986         m_rename_file = NULL;
 987 }
 988
 989
 990 void CSharedFilesRem::Reload(bool, bool)
 991 {
 992         CECPacket req(EC_OP_SHAREDFILES_RELOAD);
 993
 994         m_conn->SendPacket(&req);
 995 }
 996
 997
 998 void CSharedFilesRem::AddFilesFromDirectory(const CPath& path)
 999 {
1000         CECPacket req(EC_OP_SHAREDFILES_ADD_DIRECTORY);
1001
1002         req.AddTag(CECTag(EC_TAG_PREFS_DIRECTORIES, path.GetRaw()));
1003
1004         m_conn->SendPacket(&req);
1005 }
1006
1007
1008 bool CSharedFilesRem::RenameFile(CKnownFile* file, const CPath& newName)
1009 {
1010         // We use the printable name, as the filename originated from user input,
1011         // and the filesystem name might not be valid on the remote host.
1012         const wxString strNewName = newName.GetPrintable();
1013
1014         CECPacket request(EC_OP_RENAME_FILE);
1015         request.AddTag(CECTag(EC_TAG_KNOWNFILE, file->GetFileHash()));
1016         request.AddTag(CECTag(EC_TAG_PARTFILE_NAME, strNewName));
1017
1018         m_conn->SendRequest(this, &request);
1019         m_rename_file = file;
1020         m_new_name = strNewName;
1021
1022         return true;
1023 }
1024
1025
1026 void CSharedFilesRem::HandlePacket(const CECPacket *packet)
1027 {
1028         if (m_rename_file && (packet->GetOpCode() == EC_OP_NOOP)) {
1029                 m_rename_file->SetFileName(CPath(m_new_name));
1030                 m_rename_file = NULL;
1031         } else if (packet->GetOpCode() != EC_OP_FAILED) {
1032                 CRemoteContainer<CKnownFile, CMD4Hash, CEC_SharedFile_Tag>::HandlePacket(packet);
1033         }
1034 }
1035
1036
1037 CKnownFile *CSharedFilesRem::CreateItem(CEC_SharedFile_Tag *tag)
1038 {
1039         CKnownFile *file = new CKnownFile(tag);
1040
1041         m_enc_map[file->GetFileHash()] = RLE_Data(file->GetPartCount(), true);
1042
1043         ProcessItemUpdate(tag, file);
1044
1045         theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->ShowFile(file);
1046
1047         return file;
1048 }
1049
1050
1051 void CSharedFilesRem::DeleteItem(CKnownFile *in_file)
1052 {
1053         CScopedPtr<CKnownFile> file(in_file);
1054
1055         m_enc_map.erase(file->GetFileHash());
1056
1057         theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->RemoveFile(file.get());
1058 }
1059
1060
1061 CMD4Hash CSharedFilesRem::GetItemID(CKnownFile *file)
1062 {
1063         return file->GetFileHash();
1064 }
1065
1066
1067 void CSharedFilesRem::ProcessItemUpdate(CEC_SharedFile_Tag *tag, CKnownFile *file)
1068 {
1069         CECTag *parttag = tag->GetTagByName(EC_TAG_PARTFILE_PART_STATUS);
1070         const unsigned char *data =
1071                 m_enc_map[file->GetFileHash()].Decode(
1072                         (unsigned char *)parttag->GetTagData(),
1073                         parttag->GetTagDataLen());
1074         for(int i = 0; i < file->GetPartCount(); ++i) {
1075                 file->m_AvailPartFrequency[i] = data[i];
1076         }
1077         if (m_inc_tags) {
1078                 tag->SetRequests(file->statistic.requested);
1079                 tag->SetAllRequests(file->statistic.alltimerequested);
1080                 tag->SetAccepts(file->statistic.accepted);
1081                 tag->SetAllAccepts(file->statistic.alltimeaccepted);
1082                 tag->SetXferred(file->statistic.transferred );
1083                 tag->SetAllXferred(file->statistic.alltimetransferred);
1084                 tag->SetPrio(file->m_iUpPriority);
1085         } else {
1086                 file->statistic.requested = tag->GetRequests();
1087                 file->statistic.alltimerequested = tag->GetAllRequests();
1088                 file->statistic.accepted = tag->GetAccepts();
1089                 file->statistic.alltimeaccepted = tag->GetAllAccepts();
1090                 file->statistic.transferred = tag->GetXferred();
1091                 file->statistic.alltimetransferred = tag->GetAllXferred();
1092                 file->m_iUpPriority = tag->Prio();
1093         }
1094         if (file->m_iUpPriority >= 10) {
1095                 file->m_iUpPriority -= 10;
1096                 file->m_bAutoUpPriority = true;
1097         } else {
1098                 file->m_bAutoUpPriority = false;
1099         }
1100
1101         theApp->knownfiles->requested += file->statistic.requested;
1102         theApp->knownfiles->transferred += file->statistic.transferred;
1103         theApp->knownfiles->accepted += file->statistic.transferred;
1104
1105         theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->UpdateItem(file);
1106 }
1107
1108 bool CSharedFilesRem::Phase1Done(const CECPacket *)
1109 {
1110         theApp->knownfiles->requested = 0;
1111         theApp->knownfiles->transferred = 0;
1112         theApp->knownfiles->accepted = 0;
1113
1114         return true;
1115 }
1116
1117 void CSharedFilesRem::SetFilePrio(CKnownFile *file, uint8 prio)
1118 {
1119         CECPacket req(EC_OP_SHARED_SET_PRIO);
1120
1121         CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
1122         hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, prio));
1123
1124         req.AddTag(hashtag);
1125
1126         m_conn->SendPacket(&req);
1127 }
1128
1129 /*
1130  * List of uploading and waiting clients.
1131  */
1132 CUpDownClientListRem::CUpDownClientListRem(CRemoteConnect *conn, int viewtype)
1133 :
1134 CRemoteContainer<CUpDownClient, uint32, CEC_UpDownClient_Tag>(conn)
1135 {
1136         m_viewtype = viewtype;
1137 }
1138
1139
1140 CUpDownClient::CUpDownClient(CEC_UpDownClient_Tag *tag)
1141 {
1142         m_bRemoteQueueFull = false;
1143         m_nUserIDHybrid = tag->ID();
1144         m_Username = tag->ClientName();
1145         m_score = tag->Score();
1146         m_clientSoft = tag->ClientSoftware();
1147         m_clientVersionString = GetSoftName(m_clientSoft);
1148         m_clientSoftString = m_clientVersionString;
1149         m_identState = tag->GetCurrentIdentState();
1150         m_hasbeenobfuscatinglately = tag->HasObfuscatedConnection();
1151
1152         // The functions to retrieve m_clientVerString information are
1153         // currently in BaseClient.cpp, which is not linked in remote-gui app.
1154         // So, in the meantime, we use a tag sent from core.
1155         m_clientVerString = tag->SoftVerStr();
1156         m_strModVersion = wxEmptyString;
1157         wxString clientModString;
1158         if (!clientModString.IsEmpty()) {
1159                 m_clientVerString += wxT(" - ") + clientModString;
1160         }
1161         m_fullClientVerString = m_clientSoftString + wxT(" ") + m_clientVerString;
1162
1163         // User hash
1164         m_UserHash = tag->UserID();
1165
1166         // User IP:Port
1167         m_nConnectIP = m_dwUserIP = tag->UserIP();
1168         m_nUserPort = tag->UserPort();
1169         m_FullUserIP = m_nConnectIP;
1170
1171         // Server IP:Port
1172         m_dwServerIP = tag->ServerIP();
1173         m_nServerPort = tag->ServerPort();
1174         m_ServerName = tag->ServerName();
1175
1176         m_waitingPosition = tag->WaitingPosition();
1177
1178         m_Friend = 0;
1179         if (tag->HaveFile()) {
1180                 CMD4Hash filehash = tag->FileID();
1181                 m_uploadingfile = theApp->sharedfiles->GetByID(filehash);
1182                 if (!m_uploadingfile) {
1183                         m_uploadingfile = theApp->downloadqueue->GetByID(filehash);
1184                 }
1185         } else {
1186                 m_uploadingfile = NULL;
1187         }
1188
1189         m_nCurSessionUp = 0;
1190
1191         credits = new CClientCredits(new CreditStruct());
1192 }
1193
1194 uint16 CUpQueueRem::GetWaitingPosition(const CUpDownClient *client) const
1195 {
1196         return client->GetWaitingPosition();
1197 }
1198
1199 /* Warning: do common base */
1200
1201
1202 bool CUpDownClient::IsIdentified() const
1203 {
1204         return m_identState == IS_IDENTIFIED;
1205 }
1206
1207
1208 bool CUpDownClient::IsBadGuy() const
1209 {
1210         return m_identState == IS_IDBADGUY;
1211 }
1212
1213
1214 bool CUpDownClient::SUIFailed() const
1215 {
1216         return m_identState == IS_IDFAILED;
1217 }
1218
1219
1220 bool CUpDownClient::SUINeeded() const
1221 {
1222         return m_identState == IS_IDNEEDED;
1223 }
1224
1225
1226 bool CUpDownClient::SUINotSupported() const
1227 {
1228         return m_identState == IS_NOTAVAILABLE;
1229 }
1230
1231
1232 uint64 CUpDownClient::GetDownloadedTotal() const
1233 {
1234         return credits->GetDownloadedTotal();
1235 }
1236
1237
1238 uint64 CUpDownClient::GetUploadedTotal() const
1239 {
1240         return credits->GetUploadedTotal();
1241 }
1242
1243
1244 double CUpDownClient::GetScoreRatio() const
1245 {
1246         return credits->GetScoreRatio(GetIP(), theApp->CryptoAvailable());
1247 }
1248
1249 /* End Warning */
1250
1251
1252 CUpDownClient::~CUpDownClient()
1253 {
1254         delete credits;
1255 }
1256
1257
1258 CUpDownClient *CUpDownClientListRem::CreateItem(CEC_UpDownClient_Tag *tag)
1259 {
1260         CUpDownClient *client = new CUpDownClient(tag);
1261         ProcessItemUpdate(tag, client);
1262
1263         theApp->amuledlg->m_transferwnd->clientlistctrl->InsertClient(client, (ViewType)m_viewtype);
1264
1265         return client;
1266 }
1267
1268
1269 void CUpDownClientListRem::DeleteItem(CUpDownClient *client)
1270 {
1271         theApp->amuledlg->m_transferwnd->clientlistctrl->
1272                 RemoveClient(client, (ViewType)m_viewtype);
1273         delete client;
1274 }
1275
1276
1277 uint32 CUpDownClientListRem::GetItemID(CUpDownClient *client)
1278 {
1279         return client->GetUserIDHybrid();
1280 }
1281
1282
1283 void CUpDownClientListRem::ProcessItemUpdate(
1284         CEC_UpDownClient_Tag *tag,
1285         CUpDownClient *client)
1286 {
1287         uint16 state = tag->ClientState();
1288
1289         client->m_nDownloadState = state & 0xff;
1290         client->m_nUploadState = (state >> 8) & 0xff;
1291
1292         client->m_nUpDatarate = tag->SpeedUp();
1293         if ( client->m_nDownloadState == DS_DOWNLOADING ) {
1294                 client->kBpsDown = tag->SpeedDown() / 1024.0;
1295         } else {
1296                 client->kBpsDown = 0;
1297         }
1298
1299         client->m_WaitTime = tag->WaitTime();
1300         client->m_UpStartTimeDelay = tag->XferTime();
1301         client->m_dwLastUpRequest = tag->LastReqTime();
1302         client->m_WaitStartTime = tag->QueueTime();
1303
1304         CreditStruct *credit_struct =
1305                 (CreditStruct *)client->credits->GetDataStruct();
1306         credit_struct->uploaded = tag->XferUp();
1307         client->m_nTransferredUp = tag->XferUpSession();
1308
1309         credit_struct->downloaded = tag->XferDown();
1310         client->m_nTransferredDown = tag->XferDownSession();
1311
1312         client->m_score = tag->Score();
1313         client->m_rating = tag->Rating();
1314 }
1315
1316
1317 CUpQueueRem::CUpQueueRem(CRemoteConnect *conn)
1318 :
1319 m_up_list(conn, vtUploading), m_wait_list(conn, vtQueued)
1320 {
1321 }
1322
1323
1324 /*
1325  * Download queue container: hold PartFiles with progress status
1326  *
1327  */
1328
1329
1330 CDownQueueRem::CDownQueueRem(CRemoteConnect *conn)
1331 :
1332 CRemoteContainer<CPartFile, CMD4Hash, CEC_PartFile_Tag>(conn, true)
1333 {
1334 }
1335
1336
1337 bool CDownQueueRem::AddLink(const wxString &link, int)
1338 {
1339         CECPacket req(EC_OP_ADD_LINK);
1340         req.AddTag(CECTag(EC_TAG_STRING, link));
1341
1342         m_conn->SendPacket(&req);
1343         return true;
1344 }
1345
1346
1347 void CDownQueueRem::StopUDPRequests()
1348 {
1349         // have no idea what is it about
1350 }
1351
1352
1353 void CDownQueueRem::ResetCatParts(int)
1354 {
1355         // called when category being deleted. Command will be performed on remote side
1356 }
1357
1358
1359 bool CDownQueueRem::IsPartFile(const CKnownFile *) const
1360 {
1361         // hope i understand it right
1362         return true;
1363 }
1364
1365
1366 void CDownQueueRem::OnConnectionState(bool)
1367 {
1368 }
1369
1370
1371 CPartFile *CDownQueueRem::CreateItem(CEC_PartFile_Tag *tag)
1372 {
1373         CPartFile *file = new CPartFile(tag);
1374         m_enc_map[file->GetFileHash()] = PartFileEncoderData(file->GetPartCount(), 10);
1375         ProcessItemUpdate(tag, file);
1376
1377         theApp->amuledlg->m_transferwnd->downloadlistctrl->AddFile(file);
1378         return file;
1379 }
1380
1381
1382 void CDownQueueRem::DeleteItem(CPartFile *in_file)
1383 {
1384         CScopedPtr<CPartFile> file(in_file);
1385
1386         theApp->amuledlg->m_transferwnd->downloadlistctrl->RemoveFile(file.get());
1387
1388         m_enc_map.erase(file->GetFileHash());
1389 }
1390
1391
1392 CMD4Hash CDownQueueRem::GetItemID(CPartFile *file)
1393 {
1394         return file->GetFileHash();
1395 }
1396
1397
1398 void CDownQueueRem::ProcessItemUpdate(CEC_PartFile_Tag *tag, CPartFile *file)
1399 {
1400         //
1401         // update status
1402         //
1403         tag->Speed(&file->m_kbpsDown);
1404         file->kBpsDown = file->m_kbpsDown / 1024.0;
1405
1406         tag->SizeXfer(&file->transferred);
1407         tag->SizeDone(&file->completedsize);
1408         tag->SourceXferCount(&file->transferingsrc);
1409         tag->SourceNotCurrCount(&file->m_notCurrentSources);
1410         tag->SourceCount(&file->m_source_count);
1411         tag->SourceCountA4AF(&file->m_a4af_source_count);
1412         tag->FileStatus(&file->status);
1413         tag->Stopped(&file->m_stopped);
1414
1415         tag->LastSeenComplete(&file->lastseencomplete);
1416         tag->LastDateChanged(&file->m_lastDateChanged);
1417         tag->DownloadActiveTime(&file->m_nDlActiveTime);
1418
1419         tag->GetLostDueToCorruption(&file->m_iLostDueToCorruption);
1420         tag->GetGainDueToCompression(&file->m_iGainDueToCompression);
1421         tag->TotalPacketsSavedDueToICH(&file->m_iTotalPacketsSavedDueToICH);
1422
1423         tag->FileCat(&file->m_category);
1424
1425         tag->Prio(&file->m_iDownPriorityEC);
1426         if ( file->m_iDownPriorityEC >= 10 ) {
1427                 file->m_iDownPriority = file->m_iDownPriorityEC - 10;
1428                 file->m_bAutoDownPriority = true;
1429         } else {
1430                 file->m_iDownPriority = file->m_iDownPriorityEC;
1431                 file->m_bAutoDownPriority = false;
1432         }
1433
1434         file->percentcompleted = (100.0*file->GetCompletedSize()) / file->GetFileSize();
1435
1436         //
1437         // Copy part/gap status
1438         //
1439         CECTag *gaptag = tag->GetTagByName(EC_TAG_PARTFILE_GAP_STATUS);
1440         CECTag *parttag = tag->GetTagByName(EC_TAG_PARTFILE_PART_STATUS);
1441         CECTag *reqtag = tag->GetTagByName(EC_TAG_PARTFILE_REQ_STATUS);
1442         if (gaptag && parttag && reqtag) {
1443                 wxASSERT(m_enc_map.count(file->GetFileHash()));
1444
1445                 PartFileEncoderData &encoder = m_enc_map[file->GetFileHash()];
1446                 encoder.Decode(
1447                         (unsigned char *)gaptag->GetTagData(), gaptag->GetTagDataLen(),
1448                         (unsigned char *)parttag->GetTagData(), parttag->GetTagDataLen());
1449
1450                 const uint64 *reqparts = (const uint64 *)reqtag->GetTagData();
1451                 unsigned reqcount = reqtag->GetTagDataLen() / (2 * sizeof(uint64));
1452
1453                 unsigned gap_size = encoder.m_gap_status.Size() / (2 * sizeof(uint64));
1454                 // clear gaplist
1455                 file->m_gaplist.Init(file->GetFileSize(), false);
1456
1457                 // and refill it
1458                 const uint64 *gap_info = (const uint64 *)encoder.m_gap_status.Buffer();
1459                 for (unsigned j = 0; j < gap_size;j++) {
1460                         file->m_gaplist.AddGap(ENDIAN_NTOHLL(gap_info[2*j]), ENDIAN_NTOHLL(gap_info[2*j+1]));
1461                 }
1462
1463                 // adjust size of requested block list
1464                 while ( file->m_requestedblocks_list.size() > reqcount ) {
1465                         delete file->m_requestedblocks_list.front();
1466                         file->m_requestedblocks_list.pop_front();
1467                 }
1468                 while ( file->m_requestedblocks_list.size() != reqcount ) {
1469                         file->m_requestedblocks_list.push_front(new Requested_Block_Struct);
1470                 }
1471
1472                 std::list<Requested_Block_Struct*>::iterator it2 = file->m_requestedblocks_list.begin();
1473                 for (unsigned i = 0; i < reqcount; ++i) {
1474                         Requested_Block_Struct* block = *it2++;
1475                         block->StartOffset = ENDIAN_NTOHLL(reqparts[2*i]);
1476                         block->EndOffset = ENDIAN_NTOHLL(reqparts[2*i+1]);
1477                 }
1478                 // copy parts frequency
1479                 const unsigned char *part_info = encoder.m_part_status.Buffer();
1480                 for(int i = 0; i < file->GetPartCount(); ++i) {
1481                         file->m_SrcpartFrequency[i] = part_info[i];
1482                 }
1483         } else {
1484                 AddLogLineNS(CFormat(wxT("ERROR: %X %X %X")) % (size_t)gaptag % (size_t)parttag % (size_t)reqtag);
1485         }
1486
1487         // Get source names
1488         CECTag *srcnametag = tag->GetTagByName(EC_TAG_PARTFILE_SOURCE_NAMES);
1489         if (srcnametag) {
1490                 file->ClearSourcenameItemList();
1491                 int max = srcnametag->GetTagCount();
1492                 for (int i = 0; i < max - 1; ) {
1493                         wxString name = srcnametag->GetTagByIndex(i++)->GetStringData();
1494                         long count = srcnametag->GetTagByIndex(i++)->GetInt();
1495                         file->AddSourcenameItemList(name, count);
1496                 }
1497         }
1498
1499         // Get comments
1500         CECTag *commenttag = tag->GetTagByName(EC_TAG_PARTFILE_COMMENTS);
1501         if (commenttag) {
1502                 file->ClearFileRatingList();
1503                 int max = commenttag->GetTagCount();
1504                 for (int i = 0; i < max - 3; ) {
1505                         wxString u = commenttag->GetTagByIndex(i++)->GetStringData();
1506                         wxString f = commenttag->GetTagByIndex(i++)->GetStringData();
1507                         int r = commenttag->GetTagByIndex(i++)->GetInt();
1508                         wxString c = commenttag->GetTagByIndex(i++)->GetStringData();
1509                         file->AddFileRatingList(u, f, r, c);
1510                 }
1511                 file->UpdateFileRatingCommentAvail();
1512         }
1513
1514         theApp->amuledlg->m_transferwnd->downloadlistctrl->UpdateItem(file);
1515 }
1516
1517
1518 bool CDownQueueRem::Phase1Done(const CECPacket *)
1519 {
1520         return true;
1521 }
1522
1523
1524 void CDownQueueRem::SendFileCommand(CPartFile *file, ec_tagname_t cmd)
1525 {
1526         CECPacket req(cmd);
1527         req.AddTag(CECTag(EC_TAG_PARTFILE, file->GetFileHash()));
1528
1529         m_conn->SendPacket(&req);
1530 }
1531
1532
1533 void CDownQueueRem::Prio(CPartFile *file, uint8 prio)
1534 {
1535         CECPacket req(EC_OP_PARTFILE_PRIO_SET);
1536
1537         CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
1538         hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, prio));
1539         req.AddTag(hashtag);
1540
1541         m_conn->SendPacket(&req);
1542 }
1543
1544
1545 void CDownQueueRem::AutoPrio(CPartFile *file, bool flag)
1546 {
1547         CECPacket req(EC_OP_PARTFILE_PRIO_SET);
1548
1549         CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
1550
1551         hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO,
1552                 (uint8)(flag ? PR_AUTO : file->GetDownPriority())));
1553         req.AddTag(hashtag);
1554
1555         m_conn->SendPacket(&req);
1556 }
1557
1558
1559 void CDownQueueRem::Category(CPartFile *file, uint8 cat)
1560 {
1561         CECPacket req(EC_OP_PARTFILE_SET_CAT);
1562         file->m_category = cat;
1563
1564         CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
1565         hashtag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, cat));
1566         req.AddTag(hashtag);
1567
1568         m_conn->SendPacket(&req);
1569 }
1570
1571
1572 void CDownQueueRem::AddSearchToDownload(CSearchFile* file, uint8 category)
1573 {
1574         CECPacket req(EC_OP_DOWNLOAD_SEARCH_RESULT);
1575         CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
1576         hashtag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, category));
1577         req.AddTag(hashtag);
1578
1579         m_conn->SendPacket(&req);
1580 }
1581
1582
1583 CClientListRem::CClientListRem(CRemoteConnect *conn)
1584 {
1585         m_conn = conn;
1586 }
1587
1588
1589 void CClientListRem::FilterQueues()
1590 {
1591         // FIXME: add code
1592         //wxFAIL;
1593 }
1594
1595
1596 CSearchListRem::CSearchListRem(CRemoteConnect *conn) : CRemoteContainer<CSearchFile, CMD4Hash, CEC_SearchFile_Tag>(conn)
1597 {
1598         m_curr_search = -1;
1599 }
1600
1601
1602 wxString CSearchListRem::StartNewSearch(
1603         uint32* nSearchID, SearchType search_type,
1604         const CSearchList::CSearchParams& params)
1605 {
1606         CECPacket search_req(EC_OP_SEARCH_START);
1607         EC_SEARCH_TYPE ec_search_type = EC_SEARCH_LOCAL;
1608         switch(search_type) {
1609                 case LocalSearch: ec_search_type = EC_SEARCH_LOCAL; break;
1610                 case GlobalSearch: ec_search_type =  EC_SEARCH_GLOBAL; break;
1611                 case KadSearch: ec_search_type =  EC_SEARCH_KAD; break;
1612         }
1613         search_req.AddTag(
1614                 CEC_Search_Tag(params.searchString, ec_search_type,
1615                 params.typeText, params.extension, params.availability,
1616                 params.minSize, params.maxSize));
1617
1618         m_conn->SendPacket(&search_req);
1619         m_curr_search = *(nSearchID); // No kad remote search yet.
1620
1621         Flush();
1622
1623         return wxEmptyString; // EC reply will have the error mesg is needed.
1624 }
1625
1626
1627 void CSearchListRem::StopGlobalSearch()
1628 {
1629         if (m_curr_search != -1) {
1630                 CECPacket search_req(EC_OP_SEARCH_STOP);
1631                 m_conn->SendPacket(&search_req);
1632         }
1633 }
1634
1635
1636 void CSearchListRem::HandlePacket(const CECPacket *packet)
1637 {
1638         if ( packet->GetOpCode() == EC_OP_SEARCH_PROGRESS ) {
1639                 CoreNotify_Search_Update_Progress(packet->GetTagByIndex(0)->GetInt());
1640         } else {
1641                 CRemoteContainer<CSearchFile, CMD4Hash, CEC_SearchFile_Tag>::HandlePacket(packet);
1642         }
1643 }
1644
1645
1646 CSearchFile::CSearchFile(CEC_SearchFile_Tag *tag)
1647 :
1648 m_parent(NULL),
1649 m_showChildren(false),
1650 m_sourceCount(0),
1651 m_completeSourceCount(0),
1652 m_kademlia(false),
1653 m_clientID(0),
1654 m_clientPort(0)
1655 {
1656         SetFileName(CPath(tag->FileName()));
1657         m_abyFileHash = tag->ID();
1658         SetFileSize(tag->SizeFull());
1659
1660         m_searchID = theApp->searchlist->m_curr_search;
1661
1662 }
1663
1664
1665 // dtor is virtual - must be implemented
1666 CSearchFile::~CSearchFile()
1667 {
1668 }
1669
1670
1671 CSearchFile *CSearchListRem::CreateItem(CEC_SearchFile_Tag *tag)
1672 {
1673         CSearchFile *file = new CSearchFile(tag);
1674         ProcessItemUpdate(tag, file);
1675
1676         theApp->amuledlg->m_searchwnd->AddResult(file);
1677
1678         return file;
1679 }
1680
1681
1682 void CSearchListRem::DeleteItem(CSearchFile *file)
1683 {
1684         delete file;
1685 }
1686
1687
1688 CMD4Hash CSearchListRem::GetItemID(CSearchFile *file)
1689 {
1690         return file->GetFileHash();
1691 }
1692
1693
1694 void CSearchListRem::ProcessItemUpdate(CEC_SearchFile_Tag *tag, CSearchFile *file)
1695 {
1696         file->m_sourceCount = tag->SourceCount();
1697         file->m_completeSourceCount = tag->CompleteSourceCount();
1698 }
1699
1700
1701 bool CSearchListRem::Phase1Done(const CECPacket *WXUNUSED(reply))
1702 {
1703         CECPacket progress_req(EC_OP_SEARCH_PROGRESS);
1704         m_conn->SendRequest(this, &progress_req);
1705
1706         return true;
1707 }
1708
1709
1710 void CSearchListRem::RemoveResults(long nSearchID)
1711 {
1712         ResultMap::iterator it = m_results.find(nSearchID);
1713         if (it != m_results.end()) {
1714                 CSearchResultList& list = it->second;
1715                 for (unsigned int i = 0; i < list.size(); ++i) {
1716                         delete list[i];
1717                 }
1718                 m_results.erase(it);
1719         }
1720 }
1721
1722
1723 const CSearchResultList& CSearchListRem::GetSearchResults(long nSearchID)
1724 {
1725         ResultMap::const_iterator it = m_results.find(nSearchID);
1726         if (it != m_results.end()) {
1727                 return it->second;
1728         }
1729
1730         // TODO: Should we assert in this case?
1731         static CSearchResultList list;
1732         return list;
1733 }
1734
1735
1736 void CStatsUpdaterRem::HandlePacket(const CECPacket *packet)
1737 {
1738         theStats::UpdateStats(packet);
1739   theApp->ShowUserCount(); // maybe there should be a check if a usercount changed ?
1740 }
1741
1742
1743 bool CUpDownClient::IsBanned() const
1744 {
1745         // FIXME: add code
1746         return false;
1747 }
1748
1749
1750 //
1751 // Those functions have different implementation in remote gui
1752 //
1753 void  CUpDownClient::Ban()
1754 {
1755         // FIXME: add code
1756         wxFAIL;
1757 }
1758
1759
1760 void  CUpDownClient::UnBan()
1761 {
1762         // FIXME: add code
1763         wxFAIL;
1764 }
1765
1766
1767 void CUpDownClient::RequestSharedFileList()
1768 {
1769         // FIXME: add code
1770         wxFAIL;
1771 }
1772
1773
1774 void CKnownFile::SetFileComment(const wxString &)
1775 {
1776         // FIXME: add code
1777         wxMessageBox(_("Comments and ratings are not supported on remote gui yet"), _("Information"), wxOK | wxICON_INFORMATION);
1778 }
1779
1780
1781 void CKnownFile::SetFileRating(unsigned char)
1782 {
1783         // FIXME: add code
1784 }
1785
1786
1787 // I don't think it will be implemented - too match data transfer. But who knows ?
1788 wxString CUpDownClient::ShowDownloadingParts() const
1789 {
1790         return wxEmptyString;
1791 }
1792
1793
1794 bool CUpDownClient::SwapToAnotherFile(
1795         bool WXUNUSED(bIgnoreNoNeeded),
1796         bool WXUNUSED(ignoreSuspensions),
1797         bool WXUNUSED(bRemoveCompletely),
1798         CPartFile* WXUNUSED(toFile))
1799 {
1800         // FIXME: add code
1801         wxFAIL;
1802         return false;
1803 }
1804
1805
1806 //
1807 // Those functions are virtual. So even they don't get called they must
1808 // be defined so linker will be happy
1809 //
1810 CPacket* CKnownFile::CreateSrcInfoPacket(const CUpDownClient *, uint8 /*byRequestedVersion*/, uint16 /*nRequestedOptions*/)
1811 {
1812         wxFAIL;
1813         return 0;
1814 }
1815
1816
1817 bool CKnownFile::LoadFromFile(const class CFileDataIO*)
1818 {
1819         wxFAIL;
1820         return false;
1821 }
1822
1823
1824 void CKnownFile::UpdatePartsInfo()
1825 {
1826         wxFAIL;
1827 }
1828
1829
1830 CPacket* CPartFile::CreateSrcInfoPacket(CUpDownClient const *, uint8 /*byRequestedVersion*/, uint16 /*nRequestedOptions*/)
1831 {
1832         wxFAIL;
1833         return 0;
1834 }
1835
1836
1837 void CPartFile::UpdatePartsInfo()
1838 {
1839         wxFAIL;
1840 }
1841
1842
1843 void CPartFile::UpdateFileRatingCommentAvail()
1844 {
1845         bool prevComment = m_hasComment;
1846         int prevRating = m_iUserRating;
1847
1848         m_hasComment = false;
1849         m_iUserRating = 0;
1850         int ratingCount = 0;
1851
1852         FileRatingList::iterator it = m_FileRatingList.begin();
1853         for (; it != m_FileRatingList.end(); ++it) {
1854                 SFileRating& cur_rat = *it;
1855
1856                 if (!cur_rat.Comment.IsEmpty()) {
1857                         m_hasComment = true;
1858                 }
1859
1860                 uint8 rating = cur_rat.Rating;
1861                 if (rating) {
1862                         wxASSERT(rating <= 5);
1863
1864                         ratingCount++;
1865                         m_iUserRating += rating;
1866                 }
1867         }
1868
1869         if (ratingCount) {
1870                 m_iUserRating /= ratingCount;
1871                 wxASSERT(m_iUserRating > 0 && m_iUserRating <= 5);
1872         }
1873
1874         if ((prevComment != m_hasComment) || (prevRating != m_iUserRating)) {
1875                 UpdateDisplayedInfo();
1876         }
1877 }
1878
1879 bool CPartFile::SavePartFile(bool)
1880 {
1881         wxFAIL;
1882         return false;
1883 }
1884
1885
1886 //
1887 // since gui is not linked with amule.cpp - define events here
1888 //
1889 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD)
1890 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_SOURCE_DNS_DONE)
1891 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_UDP_DNS_DONE)
1892 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_SERVER_DNS_DONE)
1893 // File_checked_for_headers