src/amule.cpp

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