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