src/amule-remote-gui.cpp

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