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