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