src/amule.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26
  27 #include "amule.h"                      // Interface declarations.
  28
  29 #include <csignal>
  30 #include <cstring>
  31 #include <wx/process.h>
  32 #include <wx/sstream.h>
  33
  34 #ifdef HAVE_CONFIG_H
  35         #include "config.h"             // Needed for HAVE_GETRLIMIT, HAVE_SETRLIMIT,
  36                                         //   HAVE_SYS_RESOURCE_H, HAVE_SYS_STATVFS_H, VERSION
  37                                         //   and ENABLE_NLS
  38 #endif
  39
  40 #include <common/ClientVersion.h>
  41
  42 #include <wx/cmdline.h>                 // Needed for wxCmdLineParser
  43 #include <wx/config.h>                  // Do_not_auto_remove (win32)
  44 #include <wx/fileconf.h>
  45 #include <wx/tokenzr.h>
  46 #include <wx/wfstream.h>
  47
  48
  49 #include <common/Format.h>              // Needed for CFormat
  50 #include "kademlia/kademlia/Kademlia.h"
  51 #include "kademlia/kademlia/Prefs.h"
  52 #include "kademlia/kademlia/UDPFirewallTester.h"
  53 #include "CanceledFileList.h"
  54 #include "ClientCreditsList.h"          // Needed for CClientCreditsList
  55 #include "ClientList.h"                 // Needed for CClientList
  56 #include "ClientUDPSocket.h"            // Needed for CClientUDPSocket & CMuleUDPSocket
  57 #include "ExternalConn.h"               // Needed for ExternalConn & MuleConnection
  58 #include <common/FileFunctions.h>       // Needed for CDirIterator
  59 #include "FriendList.h"                 // Needed for CFriendList
  60 #include "HTTPDownload.h"               // Needed for CHTTPDownloadThread
  61 #include "InternalEvents.h"             // Needed for CMuleInternalEvent
  62 #include "IPFilter.h"                   // Needed for CIPFilter
  63 #include "KnownFileList.h"              // Needed for CKnownFileList
  64 #include "ListenSocket.h"               // Needed for CListenSocket
  65 #include "Logger.h"                     // Needed for CLogger // Do_not_auto_remove
  66 #include "MagnetURI.h"                  // Needed for CMagnetURI
  67 #include "OtherFunctions.h"
  68 #include "PartFile.h"                   // Needed for CPartFile
  69 #include "PlatformSpecific.h"   // Needed for PlatformSpecific::AllowSleepMode();
  70 #include "Preferences.h"                // Needed for CPreferences
  71 #include "SearchList.h"                 // Needed for CSearchList
  72 #include "Server.h"                     // Needed for GetListName
  73 #include "ServerList.h"                 // Needed for CServerList
  74 #include "ServerConnect.h"              // Needed for CServerConnect
  75 #include "ServerUDPSocket.h"            // Needed for CServerUDPSocket
  76 #include "Statistics.h"                 // Needed for CStatistics
  77 #include "TerminationProcessAmuleweb.h" // Needed for CTerminationProcessAmuleweb
  78 #include "ThreadTasks.h"
  79 #include "UploadQueue.h"                // Needed for CUploadQueue
  80 #include "UploadBandwidthThrottler.h"
  81 #include "UserEvents.h"
  82 #include "ScopedPtr.h"
  83
  84 #ifdef ENABLE_UPNP
  85 #include "UPnPBase.h"                   // Needed for UPnP
  86 #endif
  87
  88 #ifdef __WXMAC__
  89 #include <wx/sysopt.h>                  // Do_not_auto_remove
  90 #endif
  91
  92 #ifndef AMULE_DAEMON
  93         #ifdef __WXMAC__
  94                 #include <CoreFoundation/CFBundle.h>  // Do_not_auto_remove
  95                 #if wxCHECK_VERSION(2, 9, 0)
  96                         #include <wx/osx/core/cfstring.h>  // Do_not_auto_remove
  97                 #else
  98                         #include <wx/mac/corefoundation/cfstring.h>  // Do_not_auto_remove
  99                 #endif
 100         #endif
 101         #include <wx/msgdlg.h>
 102
 103         #include "amuleDlg.h"
 104 #endif
 105
 106
 107 #ifdef HAVE_SYS_RESOURCE_H
 108         #include <sys/resource.h>
 109 #endif
 110
 111 #ifdef HAVE_SYS_STATVFS_H
 112         #include <sys/statvfs.h>  // Do_not_auto_remove
 113 #endif
 114
 115
 116 #ifdef __GLIBC__
 117 # define RLIMIT_RESOURCE __rlimit_resource
 118 #else
 119 # define RLIMIT_RESOURCE int
 120 #endif
 121
 122 #ifdef AMULE_DAEMON
 123 CamuleDaemonApp *theApp;
 124 #else
 125 CamuleGuiApp *theApp;
 126 #endif
 127
 128 static void UnlimitResource(RLIMIT_RESOURCE resType)
 129 {
 130 #if defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT)
 131         struct rlimit rl;
 132         getrlimit(resType, &rl);
 133         rl.rlim_cur = rl.rlim_max;
 134         setrlimit(resType, &rl);
 135 #endif
 136 }
 137
 138
 139 static void SetResourceLimits()
 140 {
 141 #ifdef HAVE_SYS_RESOURCE_H
 142         UnlimitResource(RLIMIT_DATA);
 143 #ifndef __UCLIBC__
 144         UnlimitResource(RLIMIT_FSIZE);
 145 #endif
 146         UnlimitResource(RLIMIT_NOFILE);
 147 #ifdef RLIMIT_RSS
 148         UnlimitResource(RLIMIT_RSS);
 149 #endif
 150 #endif
 151 }
 152
 153 // We store the received signal in order to avoid race-conditions
 154 // in the signal handler.
 155 bool g_shutdownSignal = false;
 156
 157 void OnShutdownSignal( int /* sig */ )
 158 {
 159         signal(SIGINT, SIG_DFL);
 160         signal(SIGTERM, SIG_DFL);
 161
 162         g_shutdownSignal = true;
 163
 164 #ifdef AMULE_DAEMON
 165         theApp->ExitMainLoop();
 166 #endif
 167 }
 168
 169
 170 CamuleApp::CamuleApp()
 171 {
 172         // Madcat - Initialize timer as the VERY FIRST thing to avoid any issues later.
 173         // Kry - I love to init the vars on init, even before timer.
 174         StartTickTimer();
 175
 176         // Initialization
 177         m_app_state = APP_STATE_STARTING;
 178
 179         theApp = &wxGetApp();
 180
 181         clientlist      = NULL;
 182         searchlist      = NULL;
 183         knownfiles      = NULL;
 184         canceledfiles   = NULL;
 185         serverlist      = NULL;
 186         serverconnect   = NULL;
 187         sharedfiles     = NULL;
 188         listensocket    = NULL;
 189         clientudp       = NULL;
 190         clientcredits   = NULL;
 191         friendlist      = NULL;
 192         downloadqueue   = NULL;
 193         uploadqueue     = NULL;
 194         ipfilter        = NULL;
 195         ECServerHandler = NULL;
 196         glob_prefs      = NULL;
 197         m_statistics    = NULL;
 198         uploadBandwidthThrottler = NULL;
 199 #ifdef ENABLE_UPNP
 200         m_upnp          = NULL;
 201         m_upnpMappings.resize(4);
 202 #endif
 203         core_timer      = NULL;
 204
 205         m_localip       = 0;
 206         m_dwPublicIP    = 0;
 207         webserver_pid   = 0;
 208
 209         enable_daemon_fork = false;
 210
 211         // Apprently needed for *BSD
 212         SetResourceLimits();
 213
 214 #ifdef _MSC_VER
 215         _CrtSetDbgFlag(0);              // Disable useless memleak debugging
 216 #endif
 217 }
 218
 219 CamuleApp::~CamuleApp()
 220 {
 221         // Closing the log-file as the very last thing, since
 222         // wxWidgets log-events are saved in it as well.
 223         theLogger.CloseLogfile();
 224 }
 225
 226 int CamuleApp::OnExit()
 227 {
 228         if (m_app_state!=APP_STATE_STARTING) {
 229                 AddLogLineNS(_("Now, exiting main app..."));
 230         }
 231
 232         // From wxWidgets docs, wxConfigBase:
 233         // ...
 234         // Note that you must delete this object (usually in wxApp::OnExit)
 235         // in order to avoid memory leaks, wxWidgets won't do it automatically.
 236         //
 237         // As it happens, you may even further simplify the procedure described
 238         // above: you may forget about calling Set(). When Get() is called and
 239         // there is no current object, it will create one using Create() function.
 240         // To disable this behaviour DontCreateOnDemand() is provided.
 241         delete wxConfigBase::Set((wxConfigBase *)NULL);
 242
 243         // Save credits
 244         clientcredits->SaveList();
 245
 246         // Kill amuleweb if running
 247         if (webserver_pid) {
 248                 AddLogLineNS(CFormat(_("Terminating amuleweb instance with pid '%ld' ... ")) % webserver_pid);
 249                 wxKillError rc;
 250                 if (wxKill(webserver_pid, wxSIGTERM, &rc) == -1) {
 251                         AddLogLineNS(CFormat(_("Killing amuleweb instance with pid '%ld' ... ")) % webserver_pid);
 252                         if (wxKill(webserver_pid, wxSIGKILL, &rc) == -1) {
 253                                 AddLogLineNS(_("Failed"));
 254                         }
 255                 }
 256         }
 257
 258         if (m_app_state!=APP_STATE_STARTING) {
 259                 AddLogLineNS(_("aMule OnExit: Terminating core."));
 260         }
 261
 262         delete serverlist;
 263         serverlist = NULL;
 264
 265         delete searchlist;
 266         searchlist = NULL;
 267
 268         delete clientcredits;
 269         clientcredits = NULL;
 270
 271         delete friendlist;
 272         friendlist = NULL;
 273
 274         // Destroying CDownloadQueue calls destructor for CPartFile
 275         // calling CSharedFileList::SafeAddKFile occasionally.
 276         delete sharedfiles;
 277         sharedfiles = NULL;
 278
 279         delete serverconnect;
 280         serverconnect = NULL;
 281
 282         delete listensocket;
 283         listensocket = NULL;
 284
 285         delete clientudp;
 286         clientudp = NULL;
 287
 288         delete knownfiles;
 289         knownfiles = NULL;
 290
 291         delete canceledfiles;
 292         canceledfiles = NULL;
 293
 294         delete clientlist;
 295         clientlist = NULL;
 296
 297         delete uploadqueue;
 298         uploadqueue = NULL;
 299
 300         delete downloadqueue;
 301         downloadqueue = NULL;
 302
 303         delete ipfilter;
 304         ipfilter = NULL;
 305
 306 #ifdef ENABLE_UPNP
 307         delete m_upnp;
 308         m_upnp = NULL;
 309 #endif
 310
 311         delete ECServerHandler;
 312         ECServerHandler = NULL;
 313
 314         delete m_statistics;
 315         m_statistics = NULL;
 316
 317         delete glob_prefs;
 318         glob_prefs = NULL;
 319         CPreferences::EraseItemList();
 320
 321         delete uploadBandwidthThrottler;
 322         uploadBandwidthThrottler = NULL;
 323
 324         delete m_AsioService;
 325         m_AsioService = NULL;
 326
 327         wxSocketBase::Shutdown();       // needed because we also called Initialize() manually
 328
 329         if (m_app_state!=APP_STATE_STARTING) {
 330                 AddLogLineNS(_("aMule shutdown completed."));
 331         }
 332
 333 #if wxUSE_MEMORY_TRACING
 334         AddLogLineNS(_("Memory debug results for aMule exit:"));
 335         // Log mem debug mesages to wxLogStderr
 336         wxLog* oldLog = wxLog::SetActiveTarget(new wxLogStderr);
 337         //AddLogLineNS(wxT("**************Classes**************");
 338         //wxDebugContext::PrintClasses();
 339         //AddLogLineNS(wxT("***************Dump***************");
 340         //wxDebugContext::Dump();
 341         AddLogLineNS(wxT("***************Stats**************"));
 342         wxDebugContext::PrintStatistics(true);
 343
 344         // Set back to wxLogGui
 345         delete wxLog::SetActiveTarget(oldLog);
 346 #endif
 347
 348         StopTickTimer();
 349
 350         // Return 0 for succesful program termination
 351         return AMULE_APP_BASE::OnExit();
 352 }
 353
 354
 355 int CamuleApp::InitGui(bool, wxString &)
 356 {
 357         return 0;
 358 }
 359
 360
 361 //
 362 // Application initialization
 363 //
 364 bool CamuleApp::OnInit()
 365 {
 366 #if wxUSE_MEMORY_TRACING
 367         // any text before call of Localize_mule needs not to be translated.
 368         AddLogLineNS(wxT("Checkpoint set on app init for memory debug"));       // debug output
 369         wxDebugContext::SetCheckpoint();
 370 #endif
 371
 372         // Forward wxLog events to CLogger
 373         wxLog::SetActiveTarget(new CLoggerTarget);
 374
 375         m_localip = StringHosttoUint32(::wxGetFullHostName());
 376
 377 #ifndef __WXMSW__
 378         // get rid of sigpipe
 379         signal(SIGPIPE, SIG_IGN);
 380 #else
 381         // Handle CTRL-Break
 382         signal(SIGBREAK, OnShutdownSignal);
 383 #endif
 384         // Handle sigint and sigterm
 385         signal(SIGINT, OnShutdownSignal);
 386         signal(SIGTERM, OnShutdownSignal);
 387
 388 #ifdef __WXMAC__
 389         // For listctrl's to behave on Mac
 390         wxSystemOptions::SetOption(wxT("mac.listctrl.always_use_generic"), 1);
 391 #endif
 392
 393         // Handle uncaught exceptions
 394         InstallMuleExceptionHandler();
 395
 396         if (!InitCommon(AMULE_APP_BASE::argc, AMULE_APP_BASE::argv)) {
 397                 return false;
 398         }
 399
 400         glob_prefs = new CPreferences();
 401
 402         CPath outDir;
 403         if (CheckMuleDirectory(wxT("temp"), thePrefs::GetTempDir(), ConfigDir + wxT("Temp"), outDir)) {
 404                 thePrefs::SetTempDir(outDir);
 405         } else {
 406                 return false;
 407         }
 408
 409         if (CheckMuleDirectory(wxT("incoming"), thePrefs::GetIncomingDir(), ConfigDir + wxT("Incoming"), outDir)) {
 410                 thePrefs::SetIncomingDir(outDir);
 411         } else {
 412                 return false;
 413         }
 414
 415         // Initialize wx sockets (needed for http download in background with Asio sockets)
 416         wxSocketBase::Initialize();
 417
 418         // Some sanity check
 419         if (!thePrefs::UseTrayIcon()) {
 420                 thePrefs::SetMinToTray(false);
 421         }
 422
 423         // Build the filenames for the two OS files
 424         SetOSFiles(thePrefs::GetOSDir().GetRaw());
 425
 426 #ifdef ENABLE_NLS
 427         // Load localization settings
 428         Localize_mule();
 429 #endif
 430
 431         // Configure EC for amuled when invoked with ec-config
 432         if (ec_config) {
 433                 AddLogLineNS(_("\nEC configuration"));
 434                 thePrefs::SetECPass(GetPassword(false).Encode());
 435                 thePrefs::EnableExternalConnections(true);
 436                 AddLogLineNS(_("Password set and external connections enabled."));
 437         }
 438
 439 #ifndef __WXMSW__
 440         if (getuid() == 0) {
 441                 wxString msg =
 442                         wxT("Warning! You are running aMule as root.\n")
 443                         wxT("Doing so is not recommended for security reasons,\n")
 444                         wxT("and you are advised to run aMule as an normal\n")
 445                         wxT("user instead.");
 446
 447                 ShowAlert(msg, _("WARNING"), wxCENTRE | wxOK | wxICON_ERROR);
 448
 449                 fprintf(stderr, "\n--------------------------------------------------\n");
 450                 fprintf(stderr, "%s", (const char*)unicode2UTF8(msg));
 451                 fprintf(stderr, "\n--------------------------------------------------\n\n");
 452         }
 453 #endif
 454
 455         // Display notification on new version or first run
 456         wxTextFile vfile( ConfigDir + wxT("lastversion") );
 457         wxString newMule(wxT( VERSION ));
 458
 459         if ( !wxFileExists( vfile.GetName() ) ) {
 460                 vfile.Create();
 461         }
 462
 463         if ( vfile.Open() ) {
 464                 // Check if this version has been run before
 465                 bool found = false;
 466                 for ( size_t i = 0; i < vfile.GetLineCount(); i++ ) {
 467                         // Check if this version has been run before
 468                         if ( vfile.GetLine(i) == newMule ) {
 469                                 found = true;
 470                                 break;
 471                         }
 472                 }
 473
 474                 // We havent run this version before?
 475                 if ( !found ) {
 476                         // Insert new at top to provide faster searches
 477                         vfile.InsertLine( newMule, 0 );
 478
 479                         Trigger_New_version( newMule );
 480                 }
 481
 482                 // Keep at most 10 entires
 483                 while ( vfile.GetLineCount() > 10 )
 484                         vfile.RemoveLine( vfile.GetLineCount() - 1 );
 485
 486                 vfile.Write();
 487                 vfile.Close();
 488         }
 489
 490         // Check if we have the old style locale config
 491         wxString langId = thePrefs::GetLanguageID();
 492         if (!langId.IsEmpty() && (langId.GetChar(0) >= '0' && langId.GetChar(0) <= '9')) {
 493                 wxString info(_("Your locale has been changed to System Default due to a configuration change. Sorry."));
 494                 thePrefs::SetLanguageID(wxLang2Str(wxLANGUAGE_DEFAULT));
 495                 ShowAlert(info, _("Info"), wxCENTRE | wxOK | wxICON_ERROR);
 496         }
 497
 498         m_statistics = new CStatistics();
 499
 500         clientlist      = new CClientList();
 501         friendlist      = new CFriendList();
 502         searchlist      = new CSearchList();
 503         knownfiles      = new CKnownFileList();
 504         canceledfiles   = new CCanceledFileList;
 505         serverlist      = new CServerList();
 506
 507         sharedfiles     = new CSharedFileList(knownfiles);
 508         clientcredits   = new CClientCreditsList();
 509
 510         // bugfix - do this before creating the uploadqueue
 511         downloadqueue   = new CDownloadQueue();
 512         uploadqueue     = new CUploadQueue();
 513         ipfilter        = new CIPFilter();
 514
 515         // Creates all needed listening sockets
 516         wxString msg;
 517         if (!ReinitializeNetwork(&msg)) {
 518                 AddLogLineNS(wxT("\n"));
 519                 AddLogLineNS(msg);
 520         }
 521
 522         // Test if there's any new version
 523         if (thePrefs::GetCheckNewVersion()) {
 524                 // We use the thread base because I don't want a dialog to pop up.
 525                 CHTTPDownloadThread* version_check =
 526                         new CHTTPDownloadThread(wxT("http://amule.sourceforge.net/lastversion"),
 527                                 theApp->ConfigDir + wxT("last_version_check"), theApp->ConfigDir + wxT("last_version"), HTTP_VersionCheck, false, false);
 528                 version_check->Create();
 529                 version_check->Run();
 530         }
 531
 532         // Create main dialog, or fork to background (daemon).
 533         InitGui(m_geometryEnabled, m_geometryString);
 534
 535 #ifdef AMULE_DAEMON
 536         // Need to refresh wxSingleInstanceChecker after the daemon fork() !
 537         if (enable_daemon_fork) {
 538                 RefreshSingleInstanceChecker();
 539                 // No need to check IsAnotherRunning() - we've done it before.
 540         }
 541 #endif
 542
 543         // Has to be created after the call to InitGui, as fork
 544         // (when using posix threads) only replicates the mainthread,
 545         // and the UBT constructor creates a thread.
 546         uploadBandwidthThrottler = new UploadBandwidthThrottler();
 547
 548         m_AsioService = new CAsioService;
 549
 550
 551         // Start performing background tasks
 552         // This will start loading the IP filter. It will start right away.
 553         // Log is confusing, because log entries from background will only be printed
 554         // once foreground becomes idle, and that will only be after loading
 555         // of the partfiles has finished.
 556         CThreadScheduler::Start();
 557
 558         // These must be initialized after the gui is loaded.
 559         if (thePrefs::GetNetworkED2K()) {
 560                 serverlist->Init();
 561         }
 562         downloadqueue->LoadMetFiles(thePrefs::GetTempDir());
 563         sharedfiles->Reload();
 564
 565         // Ensure that the up/down ratio is used
 566         CPreferences::CheckUlDlRatio();
 567
 568         // Load saved friendlist (now, so it can update in GUI right away)
 569         friendlist->LoadList();
 570
 571         // The user can start pressing buttons like mad if he feels like it.
 572         m_app_state = APP_STATE_RUNNING;
 573
 574         if (!serverlist->GetServerCount() && thePrefs::GetNetworkED2K()) {
 575                 // There are no servers and ED2K active -> ask for download.
 576                 // As we cannot ask in amuled, we just update there
 577                 // Kry TODO: Store server.met URL on preferences and use it here and in GUI.
 578 #ifndef AMULE_DAEMON
 579                 if (wxYES == wxMessageBox(
 580                         wxString(
 581                                 _("You don't have any server in the server list.\nDo you want aMule to download a new list now?")),
 582                         wxString(_("Server list download")),
 583                         wxYES_NO,
 584                         static_cast<wxWindow*>(theApp->amuledlg)))
 585 #endif
 586                 {
 587                 // workaround amuled crash
 588 #ifndef AMULE_DAEMON
 589                         serverlist->UpdateServerMetFromURL(
 590                                 wxT("http://gruk.org/server.met.gz"));
 591 #endif
 592                 }
 593         }
 594
 595
 596         // Autoconnect if that option is enabled
 597         if (thePrefs::DoAutoConnect()) {
 598                 // IP filter is still loading and will be finished on event.
 599                 // Tell it to autoconnect.
 600                 if (thePrefs::GetNetworkED2K()) {
 601                         ipfilter->ConnectToAnyServerWhenReady();
 602                 }
 603                 if (thePrefs::GetNetworkKademlia()) {
 604                         ipfilter->StartKADWhenReady();
 605                 }
 606         }
 607
 608         // Enable GeoIP
 609 #ifdef ENABLE_IP2COUNTRY
 610         theApp->amuledlg->EnableIP2Country();
 611 #endif
 612
 613         // Run webserver?
 614         if (thePrefs::GetWSIsEnabled()) {
 615                 wxString aMuleConfigFile = ConfigDir + m_configFile;
 616                 wxString amulewebPath = thePrefs::GetWSPath();
 617
 618 #if defined(__WXMAC__) && !defined(AMULE_DAEMON)
 619                 // For the Mac GUI application, look for amuleweb in the bundle
 620                 CFURLRef amulewebUrl = CFBundleCopyAuxiliaryExecutableURL(
 621                         CFBundleGetMainBundle(), CFSTR("amuleweb"));
 622
 623                 if (amulewebUrl) {
 624                         CFURLRef absoluteUrl = CFURLCopyAbsoluteURL(amulewebUrl);
 625                         CFRelease(amulewebUrl);
 626
 627                         if (absoluteUrl) {
 628                                 CFStringRef amulewebCfstr = CFURLCopyFileSystemPath(absoluteUrl, kCFURLPOSIXPathStyle);
 629                                 CFRelease(absoluteUrl);
 630         #if wxCHECK_VERSION(2, 9, 0)
 631                                 amulewebPath = wxCFStringRef(amulewebCfstr).AsString(wxLocale::GetSystemEncoding());
 632         #else
 633                                 amulewebPath = wxMacCFStringHolder(amulewebCfstr).AsString(wxLocale::GetSystemEncoding());
 634         #endif
 635                         }
 636                 }
 637 #endif
 638
 639 #ifdef __WXMSW__
 640 #       define QUOTE    wxT("\"")
 641 #else
 642 #       define QUOTE    wxT("\'")
 643 #endif
 644
 645                 wxString cmd =
 646                         QUOTE +
 647                         amulewebPath +
 648                         QUOTE wxT(" ") QUOTE wxT("--amule-config-file=") +
 649                         aMuleConfigFile +
 650                         QUOTE;
 651                 CTerminationProcessAmuleweb *p = new CTerminationProcessAmuleweb(cmd, &webserver_pid);
 652                 webserver_pid = wxExecute(cmd, wxEXEC_ASYNC, p);
 653                 bool webserver_ok = webserver_pid > 0;
 654                 if (webserver_ok) {
 655                         AddLogLineC(CFormat(_("web server running on pid %d")) % webserver_pid);
 656                 } else {
 657                         delete p;
 658                         ShowAlert(_(
 659                                 "You requested to run web server on startup, but the amuleweb binary cannot be run. Please install the package containing aMule web server, or compile aMule using --enable-webserver and run make install"),
 660                                 _("ERROR"), wxOK | wxICON_ERROR);
 661                 }
 662         }
 663
 664         return true;
 665 }
 666
 667 bool CamuleApp::ReinitializeNetwork(wxString* msg)
 668 {
 669         bool ok = true;
 670         static bool firstTime = true;
 671
 672         if (!firstTime) {
 673                 // TODO: Destroy previously created sockets
 674         }
 675         firstTime = false;
 676
 677         // Some sanity checks first
 678         if (thePrefs::ECPort() == thePrefs::GetPort()) {
 679                 // Select a random usable port in the range 1025 ... 2^16 - 1
 680                 uint16 port = thePrefs::ECPort();
 681                 while ( port < 1024 || port  == thePrefs::GetPort() ) {
 682                         port = (uint16)rand();
 683                 }
 684                 thePrefs::SetECPort( port );
 685
 686                 wxString err =
 687                         wxT("Network configuration failed! You cannot use the same port\n")
 688                         wxT("for the main TCP port and the External Connections port.\n")
 689                         wxT("The EC port has been changed to avoid conflict, see the\n")
 690                         wxT("preferences for the new value.\n");
 691                 *msg << err;
 692
 693                 AddLogLineN(wxEmptyString );
 694                 AddLogLineC(err );
 695                 AddLogLineN(wxEmptyString );
 696
 697                 ok = false;
 698         }
 699
 700         if (thePrefs::GetUDPPort() == thePrefs::GetPort() + 3) {
 701                 // Select a random usable value in the range 1025 ... 2^16 - 1
 702                 uint16 port = thePrefs::GetUDPPort();
 703                 while ( port < 1024 || port == thePrefs::GetPort() + 3 ) {
 704                         port = (uint16)rand();
 705                 }
 706                 thePrefs::SetUDPPort( port );
 707
 708                 wxString err =
 709                         wxT("Network configuration failed! You set your UDP port to\n")
 710                         wxT("the value of the main TCP port plus 3.\n")
 711                         wxT("This port has been reserved for the Server-UDP port. The\n")
 712                         wxT("port value has been changed to avoid conflict, see the\n")
 713                         wxT("preferences for the new value\n");
 714                 *msg << err;
 715
 716                 AddLogLineN(wxEmptyString );
 717                 AddLogLineC(err );
 718                 AddLogLineN(wxEmptyString );
 719
 720                 ok = false;
 721         }
 722
 723         // Create the address where we are going to listen
 724         // TODO: read this from configuration file
 725         amuleIPV4Address myaddr[4];
 726
 727         // Create the External Connections Socket.
 728         // Default is 4712.
 729         // Get ready to handle connections from apps like amulecmd
 730         if (thePrefs::GetECAddress().IsEmpty() || !myaddr[0].Hostname(thePrefs::GetECAddress())) {
 731                 myaddr[0].AnyAddress();
 732         }
 733         myaddr[0].Service(thePrefs::ECPort());
 734         ECServerHandler = new ExternalConn(myaddr[0], msg);
 735
 736         // Create the UDP socket TCP+3.
 737         // Used for source asking on servers.
 738         if (thePrefs::GetAddress().IsEmpty()) {
 739                 myaddr[1].AnyAddress();
 740         } else if (!myaddr[1].Hostname(thePrefs::GetAddress())) {
 741                 myaddr[1].AnyAddress();
 742                 AddLogLineC(CFormat(_("Could not bind ports to the specified address: %s"))
 743                         % thePrefs::GetAddress());
 744         }
 745
 746         wxString ip = myaddr[1].IPAddress();
 747         myaddr[1].Service(thePrefs::GetPort()+3);
 748         serverconnect = new CServerConnect(serverlist, myaddr[1]);
 749         *msg << CFormat( wxT("*** Server UDP socket (TCP+3) at %s:%u\n") )
 750                 % ip % ((unsigned int)thePrefs::GetPort() + 3u);
 751
 752         // Create the ListenSocket (aMule TCP socket).
 753         // Used for Client Port / Connections from other clients,
 754         // Client to Client Source Exchange.
 755         // Default is 4662.
 756         myaddr[2] = myaddr[1];
 757         myaddr[2].Service(thePrefs::GetPort());
 758         listensocket = new CListenSocket(myaddr[2]);
 759         *msg << CFormat( wxT("*** TCP socket (TCP) listening on %s:%u\n") )
 760                 % ip % (unsigned int)(thePrefs::GetPort());
 761         // Notify(true) has already been called to the ListenSocket, so events may
 762         // be already comming in.
 763         if (!listensocket->IsOk()) {
 764                 // If we wern't able to start listening, we need to warn the user
 765                 wxString err;
 766                 err = CFormat(_("Port %u is not available. You will be LOWID\n")) %
 767                         (unsigned int)(thePrefs::GetPort());
 768                 *msg << err;
 769                 AddLogLineC(err);
 770                 err.Clear();
 771                 err = CFormat(
 772                         _("Port %u is not available!\n\nThis means that you will be LOWID.\n\nCheck your network to make sure the port is open for output and input.")) %
 773                         (unsigned int)(thePrefs::GetPort());
 774                 ShowAlert(err, _("ERROR"), wxOK | wxICON_ERROR);
 775         }
 776
 777         // Create the UDP socket.
 778         // Used for extended eMule protocol, Queue Rating, File Reask Ping.
 779         // Also used for Kademlia.
 780         // Default is port 4672.
 781         myaddr[3] = myaddr[1];
 782         myaddr[3].Service(thePrefs::GetUDPPort());
 783         clientudp = new CClientUDPSocket(myaddr[3], thePrefs::GetProxyData());
 784         if (!thePrefs::IsUDPDisabled()) {
 785                 *msg << CFormat( wxT("*** Client UDP socket (extended eMule) at %s:%u") )
 786                         % ip % thePrefs::GetUDPPort();
 787         } else {
 788                 *msg << wxT("*** Client UDP socket (extended eMule) disabled on preferences");
 789         }
 790
 791 #ifdef ENABLE_UPNP
 792         if (thePrefs::GetUPnPEnabled()) {
 793                 try {
 794                         m_upnpMappings[0] = CUPnPPortMapping(
 795                                 myaddr[0].Service(),
 796                                 "TCP",
 797                                 thePrefs::GetUPnPECEnabled(),
 798                                 "aMule TCP External Connections Socket");
 799                         m_upnpMappings[1] = CUPnPPortMapping(
 800                                 myaddr[1].Service(),
 801                                 "UDP",
 802                                 thePrefs::GetUPnPEnabled(),
 803                                 "aMule UDP socket (TCP+3)");
 804                         m_upnpMappings[2] = CUPnPPortMapping(
 805                                 myaddr[2].Service(),
 806                                 "TCP",
 807                                 thePrefs::GetUPnPEnabled(),
 808                                 "aMule TCP Listen Socket");
 809                         m_upnpMappings[3] = CUPnPPortMapping(
 810                                 myaddr[3].Service(),
 811                                 "UDP",
 812                                 thePrefs::GetUPnPEnabled(),
 813                                 "aMule UDP Extended eMule Socket");
 814                         m_upnp = new CUPnPControlPoint(thePrefs::GetUPnPTCPPort());
 815                         m_upnp->AddPortMappings(m_upnpMappings);
 816                 } catch(CUPnPException &e) {
 817                         wxString error_msg;
 818                         error_msg << e.what();
 819                         AddLogLineC(error_msg);
 820                         fprintf(stderr, "%s\n", (const char *)unicode2char(error_msg));
 821                 }
 822         }
 823 #endif
 824
 825         return ok;
 826 }
 827
 828 /* Original implementation by Bouc7 of the eMule Project.
 829    aMule Signature idea was designed by BigBob and implemented
 830    by Un-Thesis, with design inputs and suggestions from bothie.
 831 */
 832 void CamuleApp::OnlineSig(bool zero /* reset stats (used on shutdown) */)
 833 {
 834         // Do not do anything if online signature is disabled in Preferences
 835         if (!thePrefs::IsOnlineSignatureEnabled() || m_emulesig_path.IsEmpty()) {
 836                 // We do not need to check m_amulesig_path because if m_emulesig_path is empty,
 837                 // that means m_amulesig_path is empty too.
 838                 return;
 839         }
 840
 841         // Remove old signature files
 842         if ( wxFileExists( m_emulesig_path ) ) { wxRemoveFile( m_emulesig_path ); }
 843         if ( wxFileExists( m_amulesig_path ) ) { wxRemoveFile( m_amulesig_path ); }
 844
 845
 846         wxTextFile amulesig_out;
 847         wxTextFile emulesig_out;
 848
 849         // Open both files if needed
 850         if ( !emulesig_out.Create( m_emulesig_path) ) {
 851                 AddLogLineC(_("Failed to create OnlineSig File"));
 852                 // Will never try again.
 853                 m_amulesig_path.Clear();
 854                 m_emulesig_path.Clear();
 855                 return;
 856         }
 857
 858         if ( !amulesig_out.Create(m_amulesig_path) ) {
 859                 AddLogLineC(_("Failed to create aMule OnlineSig File"));
 860                 // Will never try again.
 861                 m_amulesig_path.Clear();
 862                 m_emulesig_path.Clear();
 863                 return;
 864         }
 865
 866         wxString emulesig_string;
 867         wxString temp;
 868
 869         if (zero) {
 870                 emulesig_string = wxT("0\xA0.0|0.0|0");
 871                 amulesig_out.AddLine(wxT("0\n0\n0\n0\n0\n0\n0.0\n0.0\n0\n0"));
 872         } else {
 873                 if (IsConnectedED2K()) {
 874
 875                         temp = CFormat(wxT("%d")) % serverconnect->GetCurrentServer()->GetPort();
 876
 877                         // We are online
 878                         emulesig_string =
 879                                 // Connected
 880                                 wxT("1|")
 881                                 //Server name
 882                                 + serverconnect->GetCurrentServer()->GetListName()
 883                                 + wxT("|")
 884                                 // IP and port of the server
 885                                 + serverconnect->GetCurrentServer()->GetFullIP()
 886                                 + wxT("|")
 887                                 + temp;
 888
 889
 890                         // Now for amule sig
 891
 892                         // Connected. State 1, full info
 893                         amulesig_out.AddLine(wxT("1"));
 894                         // Server Name
 895                         amulesig_out.AddLine(serverconnect->GetCurrentServer()->GetListName());
 896                         // Server IP
 897                         amulesig_out.AddLine(serverconnect->GetCurrentServer()->GetFullIP());
 898                         // Server Port
 899                         amulesig_out.AddLine(temp);
 900
 901                         if (serverconnect->IsLowID()) {
 902                                 amulesig_out.AddLine(wxT("L"));
 903                         } else {
 904                                 amulesig_out.AddLine(wxT("H"));
 905                         }
 906
 907                 } else if (serverconnect->IsConnecting()) {
 908                         emulesig_string = wxT("0");
 909
 910                         // Connecting. State 2, No info.
 911                         amulesig_out.AddLine(wxT("2\n0\n0\n0\n0"));
 912                 } else {
 913                         // Not connected to a server
 914                         emulesig_string = wxT("0");
 915
 916                         // Not connected, state 0, no info
 917                         amulesig_out.AddLine(wxT("0\n0\n0\n0\n0"));
 918                 }
 919                 if (IsConnectedKad()) {
 920                         if(Kademlia::CKademlia::IsFirewalled()) {
 921                                 // Connected. Firewalled. State 1.
 922                                 amulesig_out.AddLine(wxT("1"));
 923                         } else {
 924                                 // Connected. State 2.
 925                                 amulesig_out.AddLine(wxT("2"));
 926                         }
 927                 } else {
 928                         // Not connected.State 0.
 929                         amulesig_out.AddLine(wxT("0"));
 930                 }
 931                 emulesig_string += wxT("\xA");
 932
 933                 // Datarate for downloads
 934                 temp = CFormat(wxT("%.1f")) % (theStats::GetDownloadRate() / 1024.0);
 935
 936                 emulesig_string += temp + wxT("|");
 937                 amulesig_out.AddLine(temp);
 938
 939                 // Datarate for uploads
 940                 temp = CFormat(wxT("%.1f")) % (theStats::GetUploadRate() / 1024.0);
 941
 942                 emulesig_string += temp + wxT("|");
 943                 amulesig_out.AddLine(temp);
 944
 945                 // Number of users waiting for upload
 946                 temp = CFormat(wxT("%d")) % theStats::GetWaitingUserCount();
 947
 948                 emulesig_string += temp;
 949                 amulesig_out.AddLine(temp);
 950
 951                 // Number of shared files (not on eMule)
 952                 amulesig_out.AddLine(CFormat(wxT("%d")) % theStats::GetSharedFileCount());
 953         }
 954
 955         // eMule signature finished here. Write the line to the wxTextFile.
 956         emulesig_out.AddLine(emulesig_string);
 957
 958         // Now for aMule signature extras
 959
 960         // Nick on the network
 961         amulesig_out.AddLine(thePrefs::GetUserNick());
 962
 963         // Total received in bytes
 964         amulesig_out.AddLine(CFormat(wxT("%llu")) % theStats::GetTotalReceivedBytes());
 965
 966         // Total sent in bytes
 967         amulesig_out.AddLine(CFormat(wxT("%llu")) % theStats::GetTotalSentBytes());
 968
 969         // amule version
 970 #ifdef SVNDATE
 971         amulesig_out.AddLine(wxT(VERSION) wxT(" ") wxT(SVNDATE));
 972 #else
 973         amulesig_out.AddLine(wxT(VERSION));
 974 #endif
 975
 976         if (zero) {
 977                 amulesig_out.AddLine(wxT("0"));
 978                 amulesig_out.AddLine(wxT("0"));
 979                 amulesig_out.AddLine(wxT("0"));
 980         } else {
 981         // Total received bytes in session
 982                 amulesig_out.AddLine( CFormat( wxT("%llu") ) %
 983                         theStats::GetSessionReceivedBytes() );
 984
 985         // Total sent bytes in session
 986                 amulesig_out.AddLine( CFormat( wxT("%llu") ) %
 987                         theStats::GetSessionSentBytes() );
 988
 989                 // Uptime
 990                 amulesig_out.AddLine(CFormat(wxT("%llu")) % theStats::GetUptimeSeconds());
 991         }
 992
 993         // Flush the files
 994         emulesig_out.Write();
 995         amulesig_out.Write();
 996 } //End Added By Bouc7
 997
 998
 999 #if wxUSE_ON_FATAL_EXCEPTION
1000 // Gracefully handle fatal exceptions and print backtrace if possible
1001 void CamuleApp::OnFatalException()
1002 {
1003         /* Print the backtrace */
1004         wxString msg;
1005         msg     << wxT("\n--------------------------------------------------------------------------------\n")
1006                 << wxT("A fatal error has occurred and aMule has crashed.\n")
1007                 << wxT("Please assist us in fixing this problem by posting the backtrace below in our\n")
1008                 << wxT("'aMule Crashes' forum and include as much information as possible regarding the\n")
1009                 << wxT("circumstances of this crash. The forum is located here:\n")
1010                 << wxT("    http://forum.amule.org/index.php?board=67.0\n")
1011                 << wxT("If possible, please try to generate a real backtrace of this crash:\n")
1012                 << wxT("    http://wiki.amule.org/index.php/Backtraces\n\n")
1013                 << wxT("----------------------------=| BACKTRACE FOLLOWS: |=----------------------------\n")
1014                 << wxT("Current version is: ") << FullMuleVersion
1015                 << wxT("\nRunning on: ") << OSDescription
1016                 << wxT("\n\n")
1017                 << get_backtrace(1) // 1 == skip this function.
1018                 << wxT("\n--------------------------------------------------------------------------------\n");
1019
1020         theLogger.EmergencyLog(msg, true);
1021 }
1022 #endif
1023
1024
1025 // Sets the localization of aMule
1026 void CamuleApp::Localize_mule()
1027 {
1028         InitCustomLanguages();
1029         InitLocale(m_locale, StrLang2wx(thePrefs::GetLanguageID()));
1030         if (!m_locale.IsOk()) {
1031                 AddLogLineN(_("The selected locale seems not to be installed on your box. (Note: I'll try to set it anyway)"));
1032         }
1033 }
1034
1035
1036 // Displays information related to important changes in aMule.
1037 // Is called when the user runs a new version of aMule
1038 void CamuleApp::Trigger_New_version(wxString new_version)
1039 {
1040         wxString info = wxT(" --- ") + CFormat(_("This is the first time you run aMule %s")) % new_version + wxT(" ---\n\n");
1041         if (new_version == wxT("SVN")) {
1042                 info += _("This version is a testing version, updated daily, and\n");
1043                 info += _("we give no warranty it won't break anything, burn your house,\n");
1044                 info += _("or kill your dog. But it *should* be safe to use anyway.\n");
1045         }
1046
1047         // General info
1048         info += wxT("\n");
1049         info += _("More information, support and new releases can found at our homepage,\n");
1050         info += _("at www.aMule.org, or in our IRC channel #aMule at irc.freenode.net.\n");
1051         info += wxT("\n");
1052         info += _("Feel free to report any bugs to http://forum.amule.org");
1053
1054         ShowAlert(info, _("Info"), wxCENTRE | wxOK | wxICON_ERROR);
1055 }
1056
1057
1058 void CamuleApp::SetOSFiles(const wxString new_path)
1059 {
1060         if ( thePrefs::IsOnlineSignatureEnabled() ) {
1061                 if ( ::wxDirExists(new_path) ) {
1062                         m_emulesig_path = JoinPaths(new_path, wxT("onlinesig.dat"));
1063                         m_amulesig_path = JoinPaths(new_path, wxT("amulesig.dat"));
1064                 } else {
1065                         ShowAlert(_("The folder for Online Signature files you specified is INVALID!\n OnlineSignature will be DISABLED until you fix it on preferences."), _("ERROR"), wxOK | wxICON_ERROR);
1066                         m_emulesig_path.Clear();
1067                         m_amulesig_path.Clear();
1068                 }
1069         } else {
1070                 m_emulesig_path.Clear();
1071                 m_amulesig_path.Clear();
1072         }
1073 }
1074
1075
1076 #ifdef __WXDEBUG__
1077 #ifndef wxUSE_STACKWALKER
1078 #define wxUSE_STACKWALKER 0
1079 #endif
1080 void CamuleApp::OnAssertFailure(const wxChar* file, int line,
1081                                 const wxChar* func, const wxChar* cond, const wxChar* msg)
1082 {
1083         wxString errmsg = CFormat( wxT("Assertion failed: %s:%s:%d: Assertion '%s' failed. %s\nBacktrace follows:\n%s\n") )
1084                 % file % func % line % cond % ( msg ? msg : wxT("") )
1085                 % get_backtrace(2);             // Skip the function-calls directly related to the assert call.
1086         theLogger.EmergencyLog(errmsg, false);
1087
1088         if (wxThread::IsMain() && IsRunning()) {
1089                 AMULE_APP_BASE::OnAssertFailure(file, line, func, cond, msg);
1090         } else {
1091 #ifdef _MSC_VER
1092                 wxString s = CFormat(wxT("%s in %s")) % cond % func;
1093                 if (msg) {
1094                         s << wxT(" : ") << msg;
1095                 }
1096                 _wassert(s, file, line);
1097 #else
1098                 // Abort, allows gdb to catch the assertion
1099                 raise( SIGABRT );
1100 #endif
1101         }
1102 }
1103 #endif
1104
1105
1106 void CamuleApp::OnUDPDnsDone(CMuleInternalEvent& evt)
1107 {
1108         CServerUDPSocket* socket =(CServerUDPSocket*)evt.GetClientData();
1109         socket->OnHostnameResolved(evt.GetExtraLong());
1110 }
1111
1112
1113 void CamuleApp::OnSourceDnsDone(CMuleInternalEvent& evt)
1114 {
1115         downloadqueue->OnHostnameResolved(evt.GetExtraLong());
1116 }
1117
1118
1119 void CamuleApp::OnServerDnsDone(CMuleInternalEvent& evt)
1120 {
1121         AddLogLineNS(_("Server hostname notified"));
1122         serverconnect->OnServerHostnameResolved(evt.GetClientData(), evt.GetExtraLong());
1123 }
1124
1125
1126 void CamuleApp::OnTCPTimer(CTimerEvent& WXUNUSED(evt))
1127 {
1128         if(!IsRunning()) {
1129                 return;
1130         }
1131         serverconnect->StopConnectionTry();
1132         if (IsConnectedED2K() ) {
1133                 return;
1134         }
1135         serverconnect->ConnectToAnyServer();
1136 }
1137
1138
1139 void CamuleApp::OnCoreTimer(CTimerEvent& WXUNUSED(evt))
1140 {
1141         // Former TimerProc section
1142         static uint64 msPrev1, msPrev5, msPrevSave, msPrevHist, msPrevOS, msPrevKnownMet;
1143         uint64 msCur = theStats::GetUptimeMillis();
1144         TheTime = msCur / 1000;
1145
1146         if (!IsRunning()) {
1147                 return;
1148         }
1149
1150 #ifndef AMULE_DAEMON
1151         // Check if we should terminate the app
1152         if ( g_shutdownSignal ) {
1153                 wxWindow* top = GetTopWindow();
1154
1155                 if ( top ) {
1156                         top->Close(true);
1157                 } else {
1158                         // No top-window, have to force termination.
1159                         wxExit();
1160                 }
1161         }
1162 #endif
1163
1164         // There is a theoretical chance that the core time function can recurse:
1165         // if an event function gets blocked on a mutex (communicating with the
1166         // UploadBandwidthThrottler) wx spawns a new event loop and processes more events.
1167         // If CPU load gets high a new core timer event could be generated before the last
1168         // one was finished and so recursion could occur, which would be bad.
1169         // Detect this and do an early return then.
1170         static bool recurse = false;
1171         if (recurse) {
1172                 return;
1173         }
1174         recurse = true;
1175
1176         uploadqueue->Process();
1177         downloadqueue->Process();
1178         //theApp->clientcredits->Process();
1179         theStats::CalculateRates();
1180
1181         if (msCur-msPrevHist > 1000) {
1182                 // unlike the other loop counters in this function this one will sometimes
1183                 // produce two calls in quick succession (if there was a gap of more than one
1184                 // second between calls to TimerProc) - this is intentional!  This way the
1185                 // history list keeps an average of one node per second and gets thinned out
1186                 // correctly as time progresses.
1187                 msPrevHist += 1000;
1188
1189                 m_statistics->RecordHistory();
1190
1191         }
1192
1193
1194         if (msCur-msPrev1 > 1000) {  // approximately every second
1195                 msPrev1 = msCur;
1196                 clientcredits->Process();
1197                 clientlist->Process();
1198
1199                 // Publish files to server if needed.
1200                 sharedfiles->Process();
1201
1202                 if( Kademlia::CKademlia::IsRunning() ) {
1203                         Kademlia::CKademlia::Process();
1204                         if(Kademlia::CKademlia::GetPrefs()->HasLostConnection()) {
1205                                 StopKad();
1206                                 clientudp->Close();
1207                                 clientudp->Open();
1208                                 if (thePrefs::Reconnect()) {
1209                                         StartKad();
1210                                 }
1211                         }
1212                 }
1213
1214                 if( serverconnect->IsConnecting() && !serverconnect->IsSingleConnect() ) {
1215                         serverconnect->TryAnotherConnectionrequest();
1216                 }
1217                 if (serverconnect->IsConnecting()) {
1218                         serverconnect->CheckForTimeout();
1219                 }
1220                 listensocket->UpdateConnectionsStatus();
1221
1222         }
1223
1224
1225         if (msCur-msPrev5 > 5000) {  // every 5 seconds
1226                 msPrev5 = msCur;
1227                 listensocket->Process();
1228         }
1229
1230         if (msCur-msPrevSave >= 60000) {
1231                 msPrevSave = msCur;
1232                 theStats::Save();
1233         }
1234
1235         // Special
1236         if (msCur - msPrevOS >= thePrefs::GetOSUpdate() * 1000ull) {
1237                 OnlineSig(); // Added By Bouc7
1238                 msPrevOS = msCur;
1239         }
1240
1241         if (msCur - msPrevKnownMet >= 30*60*1000/*There must be a prefs option for this*/) {
1242                 // Save Shared Files data
1243                 knownfiles->Save();
1244                 msPrevKnownMet = msCur;
1245         }
1246
1247
1248         // Recomended by lugdunummaster himself - from emule 0.30c
1249         serverconnect->KeepConnectionAlive();
1250
1251         // Disarm recursion protection
1252         recurse = false;
1253 }
1254
1255
1256 void CamuleApp::OnFinishedHashing(CHashingEvent& evt)
1257 {
1258         wxCHECK_RET(evt.GetResult(), wxT("No result of hashing"));
1259
1260         CKnownFile* owner = const_cast<CKnownFile*>(evt.GetOwner());
1261         CKnownFile* result = evt.GetResult();
1262
1263         if (owner) {
1264                 // Check if the partfile still exists, as it might have
1265                 // been deleted in the mean time.
1266                 if (downloadqueue->IsPartFile(owner)) {
1267                         // This cast must not be done before the IsPartFile
1268                         // call, as dynamic_cast will barf on dangling pointers.
1269                         dynamic_cast<CPartFile*>(owner)->PartFileHashFinished(result);
1270                 }
1271         } else {
1272                 static uint64 bytecount = 0;
1273
1274                 if (knownfiles->SafeAddKFile(result, true)) {
1275                         AddDebugLogLineN(logKnownFiles,
1276                                 CFormat(wxT("Safe adding file to sharedlist: %s")) % result->GetFileName());
1277                         sharedfiles->SafeAddKFile(result);
1278
1279                         bytecount += result->GetFileSize();
1280                         // If we have added files with a total size of ~300mb
1281                         if (bytecount >= 314572800) {
1282                                 AddDebugLogLineN(logKnownFiles, wxT("Failsafe for crash on file hashing creation"));
1283                                 if ( m_app_state != APP_STATE_SHUTTINGDOWN ) {
1284                                         knownfiles->Save();
1285                                         bytecount = 0;
1286                                 }
1287                         }
1288                 } else {
1289                         AddDebugLogLineN(logKnownFiles,
1290                                 CFormat(wxT("File not added to sharedlist: %s")) % result->GetFileName());
1291                         delete result;
1292                 }
1293         }
1294 }
1295
1296
1297 void CamuleApp::OnFinishedAICHHashing(CHashingEvent& evt)
1298 {
1299         wxCHECK_RET(evt.GetResult(), wxT("No result of AICH-hashing"));
1300
1301         CKnownFile* owner = const_cast<CKnownFile*>(evt.GetOwner());
1302         CScopedPtr<CKnownFile> result(evt.GetResult());
1303
1304         if (result->GetAICHHashset()->GetStatus() == AICH_HASHSETCOMPLETE) {
1305                 CAICHHashSet* oldSet = owner->GetAICHHashset();
1306                 CAICHHashSet* newSet = result->GetAICHHashset();
1307
1308                 owner->SetAICHHashset(newSet);
1309                 newSet->SetOwner(owner);
1310
1311                 result->SetAICHHashset(oldSet);
1312                 oldSet->SetOwner(result.get());
1313         }
1314 }
1315
1316
1317 void CamuleApp::OnFinishedCompletion(CCompletionEvent& evt)
1318 {
1319         CPartFile* completed = const_cast<CPartFile*>(evt.GetOwner());
1320         wxCHECK_RET(completed, wxT("Completion event sent for unspecified file"));
1321         wxASSERT_MSG(downloadqueue->IsPartFile(completed), wxT("CCompletionEvent for unknown partfile."));
1322
1323         completed->CompleteFileEnded(evt.ErrorOccured(), evt.GetFullPath());
1324         if (evt.ErrorOccured()) {
1325                 CUserEvents::ProcessEvent(CUserEvents::ErrorOnCompletion, completed);
1326         }
1327
1328         // Check if we should execute an script/app/whatever.
1329         CUserEvents::ProcessEvent(CUserEvents::DownloadCompleted, completed);
1330 }
1331
1332 void CamuleApp::OnFinishedAllocation(CAllocFinishedEvent& evt)
1333 {
1334         CPartFile *file = evt.GetFile();
1335         wxCHECK_RET(file, wxT("Allocation finished event sent for unspecified file"));
1336         wxASSERT_MSG(downloadqueue->IsPartFile(file), wxT("CAllocFinishedEvent for unknown partfile"));
1337
1338         file->SetStatus(PS_EMPTY);
1339
1340         if (evt.Succeeded()) {
1341                 if (evt.IsPaused()) {
1342                         file->StopFile();
1343                 } else {
1344                         file->ResumeFile();
1345                 }
1346         } else {
1347                 AddLogLineN(CFormat(_("Disk space preallocation for file '%s' failed: %s")) % file->GetFileName() % wxString(UTF82unicode(std::strerror(evt.GetResult()))));
1348                 file->StopFile();
1349         }
1350
1351         file->AllocationFinished();
1352 };
1353
1354 void CamuleApp::OnNotifyEvent(CMuleGUIEvent& evt)
1355 {
1356 #ifdef AMULE_DAEMON
1357         evt.Notify();
1358 #else
1359         if (theApp->amuledlg) {
1360                 evt.Notify();
1361         }
1362 #endif
1363 }
1364
1365
1366 void CamuleApp::ShutDown()
1367 {
1368         // Just in case
1369         PlatformSpecific::AllowSleepMode();
1370
1371         // Log
1372         AddDebugLogLineN(logGeneral, wxT("CamuleApp::ShutDown() has started."));
1373
1374         // Signal the hashing thread to terminate
1375         m_app_state = APP_STATE_SHUTTINGDOWN;
1376
1377         // Stop ASIO thread
1378 #ifdef ASIO_SOCKETS                     // only needed to suppress the log message in non-Asio build
1379         AddDebugLogLineN(logGeneral, wxT("Terminate ASIO thread."));
1380         m_AsioService->Stop();
1381 #endif
1382
1383         StopKad();
1384
1385         // Kry - Save the sources seeds on app exit
1386         if (thePrefs::GetSrcSeedsOn()) {
1387                 downloadqueue->SaveSourceSeeds();
1388         }
1389
1390         OnlineSig(true); // Added By Bouc7
1391
1392         // Exit HTTP downloads
1393         CHTTPDownloadThread::StopAll();
1394
1395         // Exit thread scheduler and upload thread
1396         CThreadScheduler::Terminate();
1397
1398         AddDebugLogLineN(logGeneral, wxT("Terminate upload thread."));
1399         uploadBandwidthThrottler->EndThread();
1400
1401         // Close sockets to avoid new clients coming in
1402         if (listensocket) {
1403                 listensocket->Close();
1404                 listensocket->KillAllSockets();
1405         }
1406
1407         if (serverconnect) {
1408                 serverconnect->Disconnect();
1409         }
1410
1411         ECServerHandler->KillAllSockets();
1412
1413 #ifdef ENABLE_UPNP
1414         if (thePrefs::GetUPnPEnabled()) {
1415                 if (m_upnp) {
1416                         m_upnp->DeletePortMappings(m_upnpMappings);
1417                 }
1418         }
1419 #endif
1420
1421         // saving data & stuff
1422         if (knownfiles) {
1423                 knownfiles->Save();
1424         }
1425
1426         theStats::Save();
1427
1428         CPath configFileName = CPath(ConfigDir + m_configFile);
1429         CPath::BackupFile(configFileName, wxT(".bak"));
1430
1431         if (clientlist) {
1432                 clientlist->DeleteAll();
1433         }
1434
1435         // Log
1436         AddDebugLogLineN(logGeneral, wxT("CamuleApp::ShutDown() has ended."));
1437 }
1438
1439
1440 bool CamuleApp::AddServer(CServer *srv, bool fromUser)
1441 {
1442         if ( serverlist->AddServer(srv, fromUser) ) {
1443                 Notify_ServerAdd(srv);
1444                 return true;
1445         }
1446         return false;
1447 }
1448
1449
1450 uint32 CamuleApp::GetPublicIP(bool ignorelocal) const
1451 {
1452         if (m_dwPublicIP == 0) {
1453                 if (Kademlia::CKademlia::IsConnected() && Kademlia::CKademlia::GetIPAddress() ) {
1454                         return wxUINT32_SWAP_ALWAYS(Kademlia::CKademlia::GetIPAddress());
1455                 } else {
1456                         return ignorelocal ? 0 : m_localip;
1457                 }
1458         }
1459
1460         return m_dwPublicIP;
1461 }
1462
1463
1464 void CamuleApp::SetPublicIP(const uint32 dwIP)
1465 {
1466         wxASSERT((dwIP == 0) || !IsLowID(dwIP));
1467
1468         if (dwIP != 0 && dwIP != m_dwPublicIP && serverlist != NULL) {
1469                 m_dwPublicIP = dwIP;
1470                 serverlist->CheckForExpiredUDPKeys();
1471         } else {
1472                 m_dwPublicIP = dwIP;
1473         }
1474 }
1475
1476
1477 wxString CamuleApp::GetLog(bool reset)
1478 {
1479         wxFile logfile;
1480         logfile.Open(ConfigDir + wxT("logfile"));
1481         if ( !logfile.IsOpened() ) {
1482                 return _("ERROR: can't open logfile");
1483         }
1484         int len = logfile.Length();
1485         if ( len == 0 ) {
1486                 return _("WARNING: logfile is empty. Something is wrong.");
1487         }
1488         char *tmp_buffer = new char[len + sizeof(wxChar)];
1489         logfile.Read(tmp_buffer, len);
1490         memset(tmp_buffer + len, 0, sizeof(wxChar));
1491
1492         // try to guess file format
1493         wxString str;
1494         if (tmp_buffer[0] && tmp_buffer[1]) {
1495                 str = wxString(UTF82unicode(tmp_buffer));
1496         } else {
1497                 str = wxWCharBuffer((wchar_t *)tmp_buffer);
1498         }
1499
1500         delete [] tmp_buffer;
1501         if ( reset ) {
1502                 theLogger.CloseLogfile();
1503                 if (theLogger.OpenLogfile(ConfigDir + wxT("logfile"))) {
1504                         AddLogLineN(_("Log has been reset"));
1505                 }
1506                 ECServerHandler->ResetAllLogs();
1507         }
1508         return str;
1509 }
1510
1511
1512 wxString CamuleApp::GetServerLog(bool reset)
1513 {
1514         wxString ret = server_msg;
1515         if ( reset ) {
1516                 server_msg.Clear();
1517         }
1518         return ret;
1519 }
1520
1521 wxString CamuleApp::GetDebugLog(bool reset)
1522 {
1523         return GetLog(reset);
1524 }
1525
1526
1527 void CamuleApp::AddServerMessageLine(wxString &msg)
1528 {
1529         server_msg += msg + wxT("\n");
1530         AddLogLineN(CFormat(_("ServerMessage: %s")) % msg);
1531 }
1532
1533
1534
1535 void CamuleApp::OnFinishedHTTPDownload(CMuleInternalEvent& event)
1536 {
1537         switch (event.GetInt()) {
1538                 case HTTP_IPFilter:
1539                         ipfilter->DownloadFinished(event.GetExtraLong());
1540                         break;
1541                 case HTTP_ServerMet:
1542                         serverlist->DownloadFinished(event.GetExtraLong());
1543                         break;
1544                 case HTTP_ServerMetAuto:
1545                         serverlist->AutoDownloadFinished(event.GetExtraLong());
1546                         break;
1547                 case HTTP_VersionCheck:
1548                         CheckNewVersion(event.GetExtraLong());
1549                         break;
1550                 case HTTP_NodesDat:
1551                         if (event.GetExtraLong() == HTTP_Success) {
1552
1553                                 wxString file = ConfigDir + wxT("nodes.dat");
1554                                 if (wxFileExists(file)) {
1555                                         wxRemoveFile(file);
1556                                 }
1557
1558                                 if ( Kademlia::CKademlia::IsRunning() ) {
1559                                         Kademlia::CKademlia::Stop();
1560                                 }
1561
1562                                 wxRenameFile(file + wxT(".download"),file);
1563
1564                                 Kademlia::CKademlia::Start();
1565                                 theApp->ShowConnectionState();
1566
1567                         } else if (event.GetExtraLong() == HTTP_Skipped) {
1568                                 AddLogLineN(CFormat(_("Skipped download of %s, because requested file is not newer.")) % wxT("nodes.dat"));
1569                         } else {
1570                                 AddLogLineC(_("Failed to download the nodes list."));
1571                         }
1572                         break;
1573 #ifdef ENABLE_IP2COUNTRY
1574                 case HTTP_GeoIP:
1575                         theApp->amuledlg->IP2CountryDownloadFinished(event.GetExtraLong());
1576                         // If we updated, the dialog is already up. Redraw it to show the flags.
1577                         theApp->amuledlg->Refresh();
1578                         break;
1579 #endif
1580         }
1581 }
1582
1583 void CamuleApp::CheckNewVersion(uint32 result)
1584 {
1585         if (result == HTTP_Success) {
1586                 wxString filename = ConfigDir + wxT("last_version_check");
1587                 wxTextFile file;
1588
1589                 if (!file.Open(filename)) {
1590                         AddLogLineC(_("Failed to open the downloaded version check file") );
1591                         return;
1592                 } else if (!file.GetLineCount()) {
1593                         AddLogLineC(_("Corrupted version check file"));
1594                 } else {
1595                         wxString versionLine = file.GetFirstLine();
1596                         wxStringTokenizer tkz(versionLine, wxT("."));
1597
1598                         AddDebugLogLineN(logGeneral, wxString(wxT("Running: ")) + wxT(VERSION) + wxT(", Version check: ") + versionLine);
1599
1600                         long fields[] = {0, 0, 0};
1601                         for (int i = 0; i < 3; ++i) {
1602                                 if (!tkz.HasMoreTokens()) {
1603                                         AddLogLineC(_("Corrupted version check file"));
1604                                         return;
1605                                 } else {
1606                                         wxString token = tkz.GetNextToken();
1607
1608                                         if (!token.ToLong(&fields[i])) {
1609                                                 AddLogLineC(_("Corrupted version check file"));
1610                                                 return;
1611                                         }
1612                                 }
1613                         }
1614
1615                         long curVer = make_full_ed2k_version(VERSION_MJR, VERSION_MIN, VERSION_UPDATE);
1616                         long newVer = make_full_ed2k_version(fields[0], fields[1], fields[2]);
1617
1618                         if (curVer < newVer) {
1619                                 AddLogLineC(_("You are using an outdated version of aMule!"));
1620                                 // cppcheck-suppress zerodiv
1621                                 AddLogLineN(CFormat(_("Your aMule version is %i.%i.%i and the latest version is %li.%li.%li")) % VERSION_MJR % VERSION_MIN % VERSION_UPDATE % fields[0] % fields[1] % fields[2]);
1622                                 AddLogLineN(_("The latest version can always be found at http://www.amule.org"));
1623                                 #ifdef AMULE_DAEMON
1624                                 AddLogLineCS(CFormat(_("WARNING: Your aMuled version is outdated: %i.%i.%i < %li.%li.%li"))
1625                                         % VERSION_MJR % VERSION_MIN % VERSION_UPDATE % fields[0] % fields[1] % fields[2]);
1626                                 #endif
1627                         } else {
1628                                 AddLogLineN(_("Your copy of aMule is up to date."));
1629                         }
1630                 }
1631
1632                 file.Close();
1633                 wxRemoveFile(filename);
1634         } else {
1635                 AddLogLineC(_("Failed to download the version check file"));
1636         }
1637
1638 }
1639
1640
1641 bool CamuleApp::IsConnected() const
1642 {
1643         return (IsConnectedED2K() || IsConnectedKad());
1644 }
1645
1646
1647 bool CamuleApp::IsConnectedED2K() const
1648 {
1649         return serverconnect && serverconnect->IsConnected();
1650 }
1651
1652
1653 bool CamuleApp::IsConnectedKad() const
1654 {
1655         return Kademlia::CKademlia::IsConnected();
1656 }
1657
1658
1659 bool CamuleApp::IsFirewalled() const
1660 {
1661         if (theApp->IsConnectedED2K() && !theApp->serverconnect->IsLowID()) {
1662                 return false; // we have an eD2K HighID -> not firewalled
1663         }
1664
1665         return IsFirewalledKad(); // If kad says ok, it's ok.
1666 }
1667
1668 bool CamuleApp::IsFirewalledKad() const
1669 {
1670         return !Kademlia::CKademlia::IsConnected()              // not connected counts as firewalled
1671                         || Kademlia::CKademlia::IsFirewalled();
1672 }
1673
1674 bool CamuleApp::IsFirewalledKadUDP() const
1675 {
1676         return !Kademlia::CKademlia::IsConnected()              // not connected counts as firewalled
1677                         || Kademlia::CUDPFirewallTester::IsFirewalledUDP(true);
1678 }
1679
1680 bool CamuleApp::IsKadRunning() const
1681 {
1682         return Kademlia::CKademlia::IsRunning();
1683 }
1684
1685 bool CamuleApp::IsKadRunningInLanMode() const
1686 {
1687         return Kademlia::CKademlia::IsRunningInLANMode();
1688 }
1689
1690 // Kad stats
1691 uint32 CamuleApp::GetKadUsers() const
1692 {
1693         return Kademlia::CKademlia::GetKademliaUsers();
1694 }
1695
1696 uint32 CamuleApp::GetKadFiles() const
1697 {
1698         return Kademlia::CKademlia::GetKademliaFiles();
1699 }
1700
1701 uint32 CamuleApp::GetKadIndexedSources() const
1702 {
1703         return Kademlia::CKademlia::GetIndexed()->m_totalIndexSource;
1704 }
1705
1706 uint32 CamuleApp::GetKadIndexedKeywords() const
1707 {
1708         return Kademlia::CKademlia::GetIndexed()->m_totalIndexKeyword;
1709 }
1710
1711 uint32 CamuleApp::GetKadIndexedNotes() const
1712 {
1713         return Kademlia::CKademlia::GetIndexed()->m_totalIndexNotes;
1714 }
1715
1716 uint32 CamuleApp::GetKadIndexedLoad() const
1717 {
1718         return Kademlia::CKademlia::GetIndexed()->m_totalIndexLoad;
1719 }
1720
1721
1722 // True IP of machine
1723 uint32 CamuleApp::GetKadIPAdress() const
1724 {
1725         return wxUINT32_SWAP_ALWAYS(Kademlia::CKademlia::GetPrefs()->GetIPAddress());
1726 }
1727
1728 // Buddy status
1729 uint8   CamuleApp::GetBuddyStatus() const
1730 {
1731         return clientlist->GetBuddyStatus();
1732 }
1733
1734 uint32  CamuleApp::GetBuddyIP() const
1735 {
1736         return clientlist->GetBuddyIP();
1737 }
1738
1739 uint32  CamuleApp::GetBuddyPort() const
1740 {
1741         return clientlist->GetBuddyPort();
1742 }
1743
1744 bool CamuleApp::CanDoCallback(uint32 clientServerIP, uint16 clientServerPort)
1745 {
1746         if (Kademlia::CKademlia::IsConnected()) {
1747                 if (IsConnectedED2K()) {
1748                         if (serverconnect->IsLowID()) {
1749                                 if (Kademlia::CKademlia::IsFirewalled()) {
1750                                         //Both Connected - Both Firewalled
1751                                         return false;
1752                                 } else {
1753                                         if (clientServerIP == theApp->serverconnect->GetCurrentServer()->GetIP() &&
1754                                            clientServerPort == theApp->serverconnect->GetCurrentServer()->GetPort()) {
1755                                                 // Both Connected - Server lowID, Kad Open - Client on same server
1756                                                 // We prevent a callback to the server as this breaks the protocol
1757                                                 // and will get you banned.
1758                                                 return false;
1759                                         } else {
1760                                                 // Both Connected - Server lowID, Kad Open - Client on remote server
1761                                                 return true;
1762                                         }
1763                                 }
1764                         } else {
1765                                 //Both Connected - Server HighID, Kad don't care
1766                                 return true;
1767                         }
1768                 } else {
1769                         if (Kademlia::CKademlia::IsFirewalled()) {
1770                                 //Only Kad Connected - Kad Firewalled
1771                                 return false;
1772                         } else {
1773                                 //Only Kad Conected - Kad Open
1774                                 return true;
1775                         }
1776                 }
1777         } else {
1778                 if (IsConnectedED2K()) {
1779                         if (serverconnect->IsLowID()) {
1780                                 //Only Server Connected - Server LowID
1781                                 return false;
1782                         } else {
1783                                 //Only Server Connected - Server HighID
1784                                 return true;
1785                         }
1786                 } else {
1787                         //We are not connected at all!
1788                         return false;
1789                 }
1790         }
1791 }
1792
1793 void CamuleApp::ShowUserCount() {
1794         uint32 totaluser = 0, totalfile = 0;
1795
1796         theApp->serverlist->GetUserFileStatus( totaluser, totalfile );
1797
1798         wxString buffer;
1799
1800         static const wxString s_singlenetstatusformat = _("Users: %s | Files: %s");
1801         static const wxString s_bothnetstatusformat = _("Users: E: %s K: %s | Files: E: %s K: %s");
1802
1803         if (thePrefs::GetNetworkED2K() && thePrefs::GetNetworkKademlia()) {
1804                 buffer = CFormat(s_bothnetstatusformat) % CastItoIShort(totaluser) % CastItoIShort(Kademlia::CKademlia::GetKademliaUsers()) % CastItoIShort(totalfile) % CastItoIShort(Kademlia::CKademlia::GetKademliaFiles());
1805         } else if (thePrefs::GetNetworkED2K()) {
1806                 buffer = CFormat(s_singlenetstatusformat) % CastItoIShort(totaluser) % CastItoIShort(totalfile);
1807         } else if (thePrefs::GetNetworkKademlia()) {
1808                 buffer = CFormat(s_singlenetstatusformat) % CastItoIShort(Kademlia::CKademlia::GetKademliaUsers()) % CastItoIShort(Kademlia::CKademlia::GetKademliaFiles());
1809         } else {
1810                 buffer = _("No networks selected");
1811         }
1812
1813         Notify_ShowUserCount(buffer);
1814 }
1815
1816
1817 void CamuleApp::ListenSocketHandler(wxSocketEvent& event)
1818 {
1819         { wxCHECK_RET(listensocket, wxT("Connection-event for NULL'd listen-socket")); }
1820         { wxCHECK_RET(event.GetSocketEvent() == wxSOCKET_CONNECTION,
1821                 wxT("Invalid event received for listen-socket")); }
1822
1823         if (m_app_state == APP_STATE_RUNNING) {
1824                 listensocket->OnAccept();
1825         } else if (m_app_state == APP_STATE_STARTING) {
1826                 // When starting up, connection may be made before we are able
1827                 // to handle them. However, if these are ignored, no futher
1828                 // connection-events will be triggered, so we have to accept it.
1829                 CLibSocket* socket = listensocket->Accept(false);
1830
1831                 wxCHECK_RET(socket, wxT("NULL returned by Accept() during startup"));
1832
1833                 socket->Destroy();
1834         }
1835 }
1836
1837
1838 void CamuleApp::ShowConnectionState(bool forceUpdate)
1839 {
1840         static uint8 old_state = (1<<7); // This flag doesn't exist
1841
1842         uint8 state = 0;
1843
1844         if (theApp->serverconnect->IsConnected()) {
1845                 state |= CONNECTED_ED2K;
1846         }
1847
1848         if (Kademlia::CKademlia::IsRunning()) {
1849                 if (Kademlia::CKademlia::IsConnected()) {
1850                         if (!Kademlia::CKademlia::IsFirewalled()) {
1851                                 state |= CONNECTED_KAD_OK;
1852                         } else {
1853                                 state |= CONNECTED_KAD_FIREWALLED;
1854                         }
1855                 } else {
1856                         state |= CONNECTED_KAD_NOT;
1857                 }
1858         }
1859
1860         if (old_state != state) {
1861                 // Get the changed value
1862                 int changed_flags = old_state ^ state;
1863
1864                 if (changed_flags & CONNECTED_ED2K) {
1865                         // ED2K status changed
1866                         wxString connected_server;
1867                         CServer* ed2k_server = theApp->serverconnect->GetCurrentServer();
1868                         if (ed2k_server) {
1869                                 connected_server = ed2k_server->GetListName();
1870                         }
1871                         if (state & CONNECTED_ED2K) {
1872                                 // We connected to some server
1873                                 const wxString id = theApp->serverconnect->IsLowID() ? _("with LowID") : _("with HighID");
1874
1875                                 AddLogLineC(CFormat(_("Connected to %s %s")) % connected_server % id);
1876                         } else {
1877                                 if ( theApp->serverconnect->IsConnecting() ) {
1878                                         AddLogLineC(CFormat(_("Connecting to %s")) % connected_server);
1879                                 } else {
1880                                         AddLogLineC(_("Disconnected from eD2k"));
1881                                 }
1882                         }
1883                 }
1884
1885                 if (changed_flags & CONNECTED_KAD_NOT) {
1886                         if (state & CONNECTED_KAD_NOT) {
1887                                 AddLogLineC(_("Kad started."));
1888                         } else {
1889                                 AddLogLineC(_("Kad stopped."));
1890                         }
1891                 }
1892
1893                 if (changed_flags & (CONNECTED_KAD_OK | CONNECTED_KAD_FIREWALLED)) {
1894                         if (state & (CONNECTED_KAD_OK | CONNECTED_KAD_FIREWALLED)) {
1895                                 if (state & CONNECTED_KAD_OK) {
1896                                         AddLogLineC(_("Connected to Kad (ok)"));
1897                                 } else {
1898                                         AddLogLineC(_("Connected to Kad (firewalled)"));
1899                                 }
1900                         } else {
1901                                 AddLogLineC(_("Disconnected from Kad"));
1902                         }
1903                 }
1904
1905                 old_state = state;
1906
1907                 theApp->downloadqueue->OnConnectionState(IsConnected());
1908         }
1909
1910         ShowUserCount();
1911         Notify_ShowConnState(forceUpdate);
1912 }
1913
1914
1915 void CamuleApp::UDPSocketHandler(wxSocketEvent& event)
1916 {
1917         CMuleUDPSocket* socket = (CMuleUDPSocket*)(event.GetClientData());
1918         wxCHECK_RET(socket, wxT("No socket owner specified."));
1919
1920         if (IsOnShutDown() || thePrefs::IsUDPDisabled()) return;
1921
1922         if (!IsRunning()) {
1923                 if (event.GetSocketEvent() == wxSOCKET_INPUT) {
1924                         // Back to the queue!
1925                         theApp->AddPendingEvent(event);
1926                         return;
1927                 }
1928         }
1929
1930         switch (event.GetSocketEvent()) {
1931                 case wxSOCKET_INPUT:
1932                         socket->OnReceive(0);
1933                         break;
1934
1935                 case wxSOCKET_OUTPUT:
1936                         socket->OnSend(0);
1937                         break;
1938
1939                 case wxSOCKET_LOST:
1940                         socket->OnDisconnected(0);
1941                         break;
1942
1943                 default:
1944                         wxFAIL;
1945                         break;
1946         }
1947 }
1948
1949
1950 void CamuleApp::OnUnhandledException()
1951 {
1952         // Call the generic exception-handler.
1953         fprintf(stderr, "\taMule Version: %s\n", (const char*)unicode2char(GetFullMuleVersion()));
1954         ::OnUnhandledException();
1955 }
1956
1957 void CamuleApp::StartKad()
1958 {
1959         if (!Kademlia::CKademlia::IsRunning() && thePrefs::GetNetworkKademlia()) {
1960                 // Kad makes no sense without the Client-UDP socket.
1961                 if (!thePrefs::IsUDPDisabled()) {
1962                         if (ipfilter->IsReady()) {
1963                                 Kademlia::CKademlia::Start();
1964                         } else {
1965                                 ipfilter->StartKADWhenReady();
1966                         }
1967                 } else {
1968                         AddLogLineC(_("Kad network cannot be used if UDP port is disabled on preferences, not starting."));
1969                 }
1970         } else if (!thePrefs::GetNetworkKademlia()) {
1971                 AddLogLineC(_("Kad network disabled on preferences, not connecting."));
1972         }
1973 }
1974
1975 void CamuleApp::StopKad()
1976 {
1977         // Stop Kad if it's running
1978         if (Kademlia::CKademlia::IsRunning()) {
1979                 Kademlia::CKademlia::Stop();
1980         }
1981 }
1982
1983
1984 void CamuleApp::BootstrapKad(uint32 ip, uint16 port)
1985 {
1986         if (!Kademlia::CKademlia::IsRunning()) {
1987                 Kademlia::CKademlia::Start();
1988                 theApp->ShowConnectionState();
1989         }
1990
1991         Kademlia::CKademlia::Bootstrap(ip, port);
1992 }
1993
1994
1995 void CamuleApp::UpdateNotesDat(const wxString& url)
1996 {
1997         wxString strTempFilename(theApp->ConfigDir + wxT("nodes.dat.download"));
1998
1999         CHTTPDownloadThread *downloader = new CHTTPDownloadThread(url, strTempFilename, theApp->ConfigDir + wxT("nodes.dat"), HTTP_NodesDat, true, false);
2000         downloader->Create();
2001         downloader->Run();
2002 }
2003
2004
2005 void CamuleApp::DisconnectED2K()
2006 {
2007         // Stop ED2K if it's running
2008         if (IsConnectedED2K()) {
2009                 serverconnect->Disconnect();
2010         }
2011 }
2012
2013 bool CamuleApp::CryptoAvailable() const
2014 {
2015         return clientcredits && clientcredits->CryptoAvailable();
2016 }
2017
2018 uint32 CamuleApp::GetED2KID() const {
2019         return serverconnect ? serverconnect->GetClientID() : 0;
2020 }
2021
2022 uint32 CamuleApp::GetID() const {
2023         uint32 ID;
2024
2025         if( Kademlia::CKademlia::IsConnected() && !Kademlia::CKademlia::IsFirewalled() ) {
2026                 // We trust Kad above ED2K
2027                 ID = ENDIAN_NTOHL(Kademlia::CKademlia::GetIPAddress());
2028         } else if( theApp->serverconnect->IsConnected() ) {
2029                 ID = theApp->serverconnect->GetClientID();
2030         } else if ( Kademlia::CKademlia::IsConnected() && Kademlia::CKademlia::IsFirewalled() ) {
2031                 // A firewalled Kad client get's a "1"
2032                 ID = 1;
2033         } else {
2034                 ID = 0;
2035         }
2036
2037         return ID;
2038 }
2039
2040 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD)
2041 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_SOURCE_DNS_DONE)
2042 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_UDP_DNS_DONE)
2043 DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_SERVER_DNS_DONE)
2044 // File_checked_for_headers