//

// This file is part of the aMule Project.

//

// Copyright (c) 2003-2026 aMule Team ( https://amule-org.github.io )

//

// Any parts of this program derived from the xMule, lMule or eMule project,

// or contributed by third-party developers are copyrighted by their

// respective authors.

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

//

#include <wx/ipc.h>

#include <wx/cmdline.h> // Needed for wxCmdLineParser

#include <wx/config.h> // Do_not_auto_remove (win32)

#include <wx/fileconf.h> // Needed for wxFileConfig

#include <wx/socket.h> // Needed for wxSocketBase

#if defined(__WXGTK__) && !defined(__APPLE__)

#include <glib.h> // g_set_prgname() — wl_app_id / WM_CLASS binding

#endif

#include <common/Format.h>

#include <common/StringFunctions.h>

#include <common/MD5Sum.h>

#include <include/common/EventIDs.h>

#include "amule.h" // Interface declarations.

#include "CamuleArtProvider.h" // Needed for wxArtProvider::Push() in OnInit

#include "amuleDlg.h" // Needed for CamuleDlg

#include "ClientCredits.h"

#include "SourceListCtrl.h"

#include "ChatWnd.h"

#include "DataToText.h" // Needed for GetSoftName()

#include "DownloadListCtrl.h" // Needed for CDownloadListCtrl

#include "Friend.h"

#include "GetTickCount.h" // Needed for GetTickCount64

#include "GuiEvents.h"

#ifdef ENABLE_IP2COUNTRY

#include "IP2Country.h" // Needed for IP2Country

#endif

#include "InternalEvents.h" // Needed for wxEVT_CORE_FINISHED_HTTP_DOWNLOAD

#include "Logger.h"

#include "muuli_wdr.h" // Needed for IDs

#include "PartFile.h" // Needed for CPartFile

#include "SearchDlg.h" // Needed for CSearchDlg

#include "Server.h" // Needed for GetListName

#include "ServerWnd.h" // Needed for CServerWnd

#include "SharedFilesCtrl.h" // Needed for CSharedFilesCtrl

#include "SharedFilesWnd.h" // Needed for CSharedFilesWnd

#include "TransferWnd.h" // Needed for CTransferWnd

#include "UpDownClientEC.h" // Needed for CUpDownClient

#include "ServerListCtrl.h" // Needed for CServerListCtrl

#include "ScopedPtr.h"

#include "StatisticsDlg.h" // Needed for CStatisticsDlg

#include "KadDlg.h" // Needed for CKadDlg::UpdateGraph

#include "ArchSpecific.h" // Needed for ENDIAN_NTOHL

CEConnectDlg::CEConnectDlg()

:

wxDialog(theApp->amuledlg, -1, _("Connect to remote amule"), wxDefaultPosition)

{

CoreConnect(this, true);

wxString pref_host, pref_port;

// Use the literal loopback address rather than "localhost":

// on Windows, "localhost" lookups can fail intermittently

// (IPv4 vs IPv6 stack ordering, hosts-file shape, ...).

// 127.0.0.1 is portable across every supported OS. Same default

// as amulecmd / amuleweb (CaMuleExternalConnector). (#822)

wxConfig::Get()->Read("/EC/Host", &pref_host, "127.0.0.1");

wxConfig::Get()->Read("/EC/Port", &pref_port, "4712");

wxConfig::Get()->Read("/EC/Password", &pwd_hash);

long pref_force_zlib;

wxConfig::Get()->Read("/EC/ForceZLIB", &pref_force_zlib, 0);

CastChild(ID_REMOTE_HOST, wxTextCtrl)->SetValue(pref_host);

CastChild(ID_REMOTE_PORT, wxTextCtrl)->SetValue(pref_port);

CastChild(ID_EC_PASSWD, wxTextCtrl)->SetValue(pwd_hash);

CastChild(ID_EC_FORCE_ZLIB, wxCheckBox)->SetValue(pref_force_zlib != 0);

CentreOnParent();

}

wxString CEConnectDlg::PassHash()

{

return pwd_hash;

}

wxBEGIN_EVENT_TABLE(CEConnectDlg, wxDialog)

EVT_BUTTON(wxID_OK, CEConnectDlg::OnOK)

wxEND_EVENT_TABLE()

void CEConnectDlg::OnOK(wxCommandEvent& evt)

{

wxString s_port = CastChild(ID_REMOTE_PORT, wxTextCtrl)->GetValue();

port = StrToLong(s_port);

host = CastChild(ID_REMOTE_HOST, wxTextCtrl)->GetValue();

passwd = CastChild(ID_EC_PASSWD, wxTextCtrl)->GetValue();

if (passwd != pwd_hash) {

pwd_hash = MD5Sum(passwd).GetHash();

}

m_save_user_pass = CastChild(ID_EC_SAVE, wxCheckBox)->IsChecked();

m_force_zlib = CastChild(ID_EC_FORCE_ZLIB, wxCheckBox)->IsChecked();

evt.Skip();

}

wxDEFINE_EVENT(wxEVT_EC_INIT_DONE, wxEvent);

wxBEGIN_EVENT_TABLE(CamuleRemoteGuiApp, wxApp)

// Core timer

EVT_TIMER(ID_CORE_TIMER_EVENT, CamuleRemoteGuiApp::OnPollTimer)

// Watchdog on the initial EC connect attempt

EVT_TIMER(ID_REMOTE_CONNECT_TIMEOUT_TIMER, CamuleRemoteGuiApp::OnConnectTimeout)

EVT_CUSTOM(wxEVT_EC_CONNECTION, -1, CamuleRemoteGuiApp::OnECConnection)

EVT_CUSTOM(wxEVT_EC_INIT_DONE, -1, CamuleRemoteGuiApp::OnECInitDone)

EVT_MULE_NOTIFY(CamuleRemoteGuiApp::OnNotifyEvent)

#ifdef ENABLE_IP2COUNTRY

// HTTPDownload finished

EVT_MULE_INTERNAL(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD, -1, CamuleRemoteGuiApp::OnFinishedHTTPDownload)

#endif

wxEND_EVENT_TABLE()

IMPLEMENT_APP(CamuleRemoteGuiApp)

int CamuleRemoteGuiApp::OnExit()

{

StopTickTimer();

wxSocketBase::Shutdown(); // needed because we also called Initialize() manually

return wxApp::OnExit();

}

#if wxUSE_ON_FATAL_EXCEPTION

// Gracefully handle fatal exceptions and print backtrace if possible.

// Mirrors CamuleApp::OnFatalException (amule.cpp) -- without this

// override amulegui crashes produce no symbolicated amule frames,

// which makes diagnosing GTK-callback-into-stale-widget bugs like

// #692 a guessing game.

void CamuleRemoteGuiApp::OnFatalException()

{

/* Print the backtrace */

wxString msg;

msg << "\n--------------------------------------------------------------------------------\n"

<< "A fatal error has occurred and amulegui has crashed.\n"

<< "Please assist us in fixing this problem by reporting the backtrace below as a\n"

<< "GitHub issue, including as much information as possible regarding the\n"

<< "circumstances of this crash. Issue tracker:\n"

<< " https://github.com/amule-org/amule/issues\n"

<< "If possible, please try to generate a real backtrace of this crash:\n"

<< " https://amule-org.github.io/docs/contributing/bug-report\n\n"

<< "----------------------------=| BACKTRACE FOLLOWS: |=----------------------------\n"

<< "Current version is: " << FullMuleVersion

<< "\nRunning on: " << OSDescription

<< "\n\n"

<< get_backtrace(1) // 1 == skip this function.

<< "\n--------------------------------------------------------------------------------\n";

theLogger.EmergencyLog(msg, true);

}

#endif

void CamuleRemoteGuiApp::OnPollTimer(wxTimerEvent&)

{

static int request_step = 0;

static uint32 msPrevStats = 0;

if (m_connect->RequestFifoFull()) {

return;

}

switch (request_step) {

case 0:

// We used to update the connection state here, but that's done with the stats in the next step now.

request_step++;

break;

case 1: {

CECPacket stats_req(EC_OP_STAT_REQ, EC_DETAIL_INC_UPDATE);

m_connect->SendRequest(&m_stats_updater, &stats_req);

request_step++;

break;

}

case 2:

if (amuledlg->m_sharedfileswnd->IsShown()

|| amuledlg->m_chatwnd->IsShown()

|| amuledlg->m_serverwnd->IsShown()) {

// update downloads, shared files and servers

knownfiles->DoRequery(EC_OP_GET_UPDATE, EC_TAG_KNOWNFILE);

} else if (amuledlg->m_transferwnd->IsShown()) {

// update both downloads and shared files

knownfiles->DoRequery(EC_OP_GET_UPDATE, EC_TAG_KNOWNFILE);

} else if (amuledlg->m_searchwnd->IsShown()) {

if (searchlist->m_curr_search != -1) {

searchlist->DoRequery(EC_OP_SEARCH_RESULTS, EC_TAG_SEARCHFILE);

}

} else if (amuledlg->m_statisticswnd->IsShown()) {

int sStatsUpdate = thePrefs::GetStatsInterval();

uint32 msCur = theStats::GetUptimeMillis();

if ((sStatsUpdate > 0) && ((int)(msCur - msPrevStats) > sStatsUpdate*1000)) {

msPrevStats = msCur;

stattree->DoRequery();

}

// Pull graph history every poll cycle while the dialog is

// visible. The handler asks only for points newer than the

// last timestamp the daemon reported, so the EC pipe carries

// just the delta even on a 1 Hz timer.

statgraphs->DoRequery();

}

// Back to the roots

request_step = 0;

break;

default:

wxFAIL;

request_step = 0;

}

// Check for new links once per second.

static uint64 lastED2KLinkCheck = 0;

uint64 now = GetTickCount64();

if (now - lastED2KLinkCheck >= 1000) {

AddLinksFromFile();

lastED2KLinkCheck = now;

}

}

void CamuleRemoteGuiApp::OnFinishedHTTPDownload(CMuleInternalEvent& event)

{

if (event.GetInt() == HTTP_GeoIP) {

amuledlg->IP2CountryDownloadFinished(event.GetExtraLong());

// If we updated, the dialog is already up. Redraw it to show the flags.

amuledlg->Refresh();

}

}

void CamuleRemoteGuiApp::ShutDown(wxCloseEvent &WXUNUSED(evt))

{

// Stop the Core Timer

delete poll_timer;

poll_timer = NULL;

delete connect_timeout_timer;

connect_timeout_timer = NULL;

m_AsioService->Stop();

delete m_AsioService;

m_AsioService = NULL;

// Destroy the EC socket

m_connect->Destroy();

m_connect = NULL;

//

if (amuledlg) {

amuledlg->DlgShutDown();

amuledlg->Destroy();

amuledlg = NULL;

}

delete m_allUploadingKnownFile;

delete stattree;

}

bool CamuleRemoteGuiApp::OnInit()

{

StartTickTimer();

amuledlg = NULL;

connect_timeout_timer = NULL;

// ShutDown() unconditionally deletes these, but Startup() — where they

// are allocated — only runs after a successful EC connect. Null them so

// a connect-timeout teardown doesn't delete an indeterminate pointer.

stattree = NULL;

m_allUploadingKnownFile = NULL;

#if defined(__WXGTK__) && !defined(__APPLE__)

// Set the GTK program name to the canonical app id. On Wayland,

// GTK derives wl_app_id (xdg_toplevel.set_app_id) from

// g_get_prgname(); compositors match wl_app_id against the

// .desktop filename to bind windows to launcher icons. Without

// this the binding falls back to argv[0], which differs across

// packaging formats (AppImage's argv[0] is "aMuleGUI", distro

// installs use "amulegui", Flatpak renames the .desktop entirely).

// On X11 the same value also feeds into WM_CLASS, matching

// StartupWMClass=org.amule.aMule.gui in the .desktop file. Must run

// before any GTK window is created — same fix the monolithic amule

// has in CamuleApp::OnInit; amulegui shipped without it, so on

// GNOME / wlroots the taskbar icon never bound to the launcher

// and showed the generic fallback. (#562 follow-up.)

// Skipped on macOS even under wxGTK (MacPorts): no Wayland or

// .desktop binding exists, and app identity is set via Info.plist

// in the .app bundle. Dropping the call lets that build skip the

// glib2 dep entirely (#641).

g_set_prgname("org.amule.aMule.gui");

#endif

// Register the embedded-PNG art provider before any UI work.

// wxArtProvider::Push takes ownership of the pointer; wx tears

// the providers down at app exit.

wxArtProvider::Push(new CamuleArtProvider());

// Get theApp

theApp = &wxGetApp();

// Handle uncaught exceptions

InstallMuleExceptionHandler();

// Parse cmdline arguments.

if (!InitCommon(AMULE_APP_BASE::argc, AMULE_APP_BASE::argv)) {

return false;

}

// Initialize wx sockets (needed for http download in background with Asio sockets)

wxSocketBase::Initialize();

// Create the polling timer

poll_timer = new wxTimer(this,ID_CORE_TIMER_EVENT);

if (!poll_timer) {

AddLogLineCS(_("Fatal Error: Failed to create Poll Timer"));

OnExit();

}

m_connect = new CRemoteConnect(this);

m_AsioService = new CAsioService;

glob_prefs = new CPreferencesRem(m_connect);

long enableZLIB;

wxConfig::Get()->Read("/EC/ZLIB", &enableZLIB, 1);

m_connect->SetCapabilities(enableZLIB != 0, true, false); // ZLIB, UTF8 numbers, notification

// The ForceZLIB override is read from the connection dialog

// (see ShowConnectionDialog) so the user's checkbox choice in this

// session overrides the persisted /EC/ForceZLIB value.

InitCustomLanguages();

InitLocale(m_locale, StrLang2wx(thePrefs::GetLanguageID()));

if (ShowConnectionDialog()) {

// The watchdog timer is armed inside ShowConnectionDialog right

// before each ConnectToCore call — the retry loop re-arms it on

// every attempt, so OnInit doesn't need to touch it here.

AddLogLineNS(_("Going to event loop..."));

return true;

}

// User cancelled (or ShowConnectionDialog failed before reaching the

// connect step). Tear down the partial init so the Asio thread pool,

// poll timer and remote-connect socket don't leak — wx will never

// call ShutDown() / OnExit() because the main loop isn't entered when

// OnInit() returns false, so we have to unwind manually here. Without

// this, wx reports "4 threads were not terminated by the application".

if (m_AsioService) {

m_AsioService->Stop();

delete m_AsioService;

m_AsioService = NULL;

}

if (m_connect) {

m_connect->Destroy();

m_connect = NULL;

}

if (poll_timer) {

delete poll_timer;

poll_timer = NULL;

}

return false;

}

bool CamuleRemoteGuiApp::CryptoAvailable() const

{

return thePrefs::IsSecureIdentEnabled(); // good enough

}

bool CamuleRemoteGuiApp::ShowConnectionDialog()

{

// The dialog is kept alive across retry attempts so the values the

// user typed (host / port / password / Force-ZLIB) survive a wrong

// guess — they only need to fix the field that was wrong instead of

// re-typing everything. Destroyed in Startup() on success or below

// when the user cancels.

if (!dialog) {

dialog = new CEConnectDlg;

}

while (true) {

if (m_skipConnectionDialog) {

wxCommandEvent evt;

dialog->OnOK(evt);

// --skip is a one-shot: on retry the user must see the

// dialog so they can correct the bad values.

m_skipConnectionDialog = false;

} else if (dialog->ShowModal() != wxID_OK) {

dialog->Destroy();

dialog = NULL;

return false;

}

AddLogLineNS(_("Connecting..."));

// Watchdog on the EC connect. When the host is unreachable the

// TCP SYN can silently time out over several minutes while the

// main loop is running with no visible window, which the OS

// reports as "not responding". Fire a shorter timeout so we

// can show an error and re-prompt instead. Re-armed on every

// retry attempt so the user gets the same 15s budget each time.

delete connect_timeout_timer;

connect_timeout_timer = new wxTimer(this, ID_REMOTE_CONNECT_TIMEOUT_TIMER);

connect_timeout_timer->StartOnce(15000);

// Apply the dialog's Force-ZLIB checkbox state to the EC client

// before each ConnectToCore attempt (re-applied per retry so

// the user can toggle it between attempts if they need to).

m_connect->SetForceZlib(dialog->ForceZlib());

if (m_connect->ConnectToCore(dialog->Host(), dialog->Port(),

dialog->Login(), dialog->PassHash(),

"amule-remote", "0x0001")) {

// Sync part succeeded; async OnECConnection will

// resolve the auth outcome.

return true;

}

// Sync failure (DNS / immediate connect-refused). The async

// path won't fire — cancel the watchdog ourselves, show the

// error, recreate the EC client so its half-baked socket

// state is gone, and loop back to the dialog.

connect_timeout_timer->Stop();

delete connect_timeout_timer;

connect_timeout_timer = NULL;

wxMessageBox(_("Connection failed. Please check the host, port, and password."),

_("ERROR"), wxOK | wxICON_ERROR);

ResetEcConnect();

}

}

void CamuleRemoteGuiApp::ResetEcConnect()

{

// Tear down the busted EC client and recreate a fresh one. The

// CRemoteConnect's socket / auth state isn't safe to reuse after

// a failed handshake. glob_prefs holds a reference to m_connect

// so it's reborn alongside. Both objects are only fully wired

// into the rest of the app by Startup(), which doesn't run until

// a successful connect — recreating them here is safe.

delete glob_prefs;

glob_prefs = NULL;

if (m_connect) {

m_connect->Destroy();

m_connect = NULL;

}

m_connect = new CRemoteConnect(this);

glob_prefs = new CPreferencesRem(m_connect);

long enableZLIB;

wxConfig::Get()->Read("/EC/ZLIB", &enableZLIB, 1);

m_connect->SetCapabilities(enableZLIB != 0, true, false);

}

void CamuleRemoteGuiApp::OnECConnection(wxEvent& event) {

// Connect attempt resolved one way or the other — kill the watchdog.

if (connect_timeout_timer) {

connect_timeout_timer->Stop();

delete connect_timeout_timer;

connect_timeout_timer = NULL;

}

wxECSocketEvent& evt = *((wxECSocketEvent*)&event);

AddLogLineNS(_("Remote GUI EC event handler"));

wxString reply = evt.GetServerReply();

AddLogLineC(reply);

if (evt.GetResult() == true) {

// Connected - go to next init step

glob_prefs->LoadRemote();

} else if (dialog) {

// Connect failed during the initial attempt or a previous

// retry (dialog is still alive — it's only destroyed in

// Startup() after a successful connect). Show the error,

// reset the EC client, and reopen the dialog with the

// previous values still in place so the user can fix the

// wrong field and try again. If the user cancels the retry,

// then we shut down.

wxMessageBox(

(CFormat(_("Connection Failed. Unable to connect to %s:%d\n")) % dialog->Host() % dialog->Port()) + reply,

_("ERROR"), wxOK | wxICON_ERROR);

ResetEcConnect();

if (!ShowConnectionDialog()) {

AddLogLineNS(_("Going down"));

wxCloseEvent ev;

ShutDown(ev);

ExitMainLoop();

}

} else {

// Server disconnected after Startup() already ran — the

// dialog is gone, the rest of the app is wired up, and we

// have no clean path back. Tell the user and shut down.

AddLogLineNS(_("Going down"));

wxMessageBox(_("Connection closed - aMule has terminated probably."), _("ERROR"), wxOK);

wxCloseEvent ev;

ShutDown(ev);

ExitMainLoop();

}

}

void CamuleRemoteGuiApp::OnConnectTimeout(wxTimerEvent&)

{

delete connect_timeout_timer;

connect_timeout_timer = NULL;

wxString host = dialog ? dialog->Host() : wxString();

long port = dialog ? dialog->Port() : 0;

wxMessageBox(

CFormat(_("Connection timed out. Unable to reach %s:%d within the allotted time.\nPlease check the host, port and that aMule is running with External Connections enabled."))

% host % port,

_("ERROR"), wxOK | wxICON_ERROR);

// Reset the EC client and reopen the dialog so the user can

// correct the host / port / etc. If they cancel, then quit.

ResetEcConnect();

if (!ShowConnectionDialog()) {

wxCloseEvent ev;

ShutDown(ev);

ExitMainLoop();

}

}

void CamuleRemoteGuiApp::OnECInitDone(wxEvent& )

{

Startup();

}

void CamuleRemoteGuiApp::OnNotifyEvent(CMuleGUIEvent& evt)

{

evt.Notify();

}

void CamuleRemoteGuiApp::Startup() {

if (dialog->SaveUserPass()) {

wxConfig::Get()->Write("/EC/Host", dialog->Host());

wxConfig::Get()->Write("/EC/Port", dialog->Port());

wxConfig::Get()->Write("/EC/Password", dialog->PassHash());

wxConfig::Get()->Write("/EC/ForceZLIB", dialog->ForceZlib() ? 1l : 0l);

}

dialog->Destroy();

dialog = NULL;

m_ConnState = 0;

m_clientID = 0;

serverconnect = new CServerConnectRem(m_connect);

m_statistics = new CStatistics(*m_connect);

stattree = new CStatTreeRem(m_connect);

statgraphs = new CStatGraphRem(m_connect);

clientlist = new CUpDownClientListRem(m_connect);

searchlist = new CSearchListRem(m_connect);

serverlist = new CServerListRem(m_connect);

friendlist = new CFriendListRem(m_connect);

sharedfiles = new CSharedFilesRem(m_connect);

knownfiles = new CKnownFilesRem(m_connect);

downloadqueue = new CDownQueueRem(m_connect);

ipfilter = new CIPFilterRem(m_connect);

m_allUploadingKnownFile = new CKnownFile;

// Create main dialog

InitGui(m_geometryEnabled, m_geometryString);

// Forward wxLog events to CLogger

wxLog::SetActiveTarget(new CLoggerTarget);

knownfiles->DoRequery(EC_OP_GET_UPDATE, EC_TAG_KNOWNFILE);

// Start the Poll Timer

poll_timer->Start(1000);

amuledlg->StartGuiTimer();

// Now activate GeoIP, so that the download dialog doesn't get destroyed immediately

#ifdef ENABLE_IP2COUNTRY

if (thePrefs::IsGeoIPEnabled()) {

amuledlg->m_IP2Country->Enable();

}

#endif

}

int CamuleRemoteGuiApp::ShowAlert(wxString msg, wxString title, int flags)

{

return CamuleGuiBase::ShowAlert(msg, title, flags);

}

void CamuleRemoteGuiApp::AddRemoteLogLine(const wxString& line)

{

amuledlg->AddLogLine(line);

}

int CamuleRemoteGuiApp::InitGui(bool geometry_enabled, wxString &geom_string)

{

CamuleGuiBase::InitGui(geometry_enabled, geom_string);

SetTopWindow(amuledlg);

AddLogLineN(_("Ready")); // The first log line after the window is up triggers output of all the ones before

return 0;

}

bool CamuleRemoteGuiApp::CopyTextToClipboard(wxString strText)

{

return CamuleGuiBase::CopyTextToClipboard(strText);

}

uint32 CamuleRemoteGuiApp::GetPublicIP()

{

return 0;

}

wxString CamuleRemoteGuiApp::GetLog(bool reset)

{

if (reset) {

amuledlg->ResetLog(ID_LOGVIEW);

CECPacket req(EC_OP_RESET_LOG);

m_connect->SendPacket(&req);

}

return "";

}

wxString CamuleRemoteGuiApp::GetServerLog(bool)

{

return "";

}

bool CamuleRemoteGuiApp::AddServer(CServer * server, bool)

{

CECPacket req(EC_OP_SERVER_ADD);

req.AddTag(CECTag(EC_TAG_SERVER_ADDRESS, CFormat("%s:%d") % server->GetAddress() % server->GetPort()));

req.AddTag(CECTag(EC_TAG_SERVER_NAME, server->GetListName()));

m_connect->SendPacket(&req);

return true;

}

bool CamuleRemoteGuiApp::IsFirewalled() const

{

if (IsConnectedED2K() && !serverconnect->IsLowID()) {

return false;

}

return IsFirewalledKad();

}

bool CamuleRemoteGuiApp::IsConnectedED2K() const {

return serverconnect && serverconnect->IsConnected();

}

void CamuleRemoteGuiApp::StartKad() {

m_connect->StartKad();

}

void CamuleRemoteGuiApp::StopKad() {

m_connect->StopKad();

}

void CamuleRemoteGuiApp::BootstrapKad(uint32 ip, uint16 port)

{

CECPacket req(EC_OP_KAD_BOOTSTRAP_FROM_IP);

req.AddTag(CECTag(EC_TAG_BOOTSTRAP_IP, ip));

req.AddTag(CECTag(EC_TAG_BOOTSTRAP_PORT, port));

m_connect->SendPacket(&req);

}

void CamuleRemoteGuiApp::UpdateNotesDat(const wxString& url)

{

CECPacket req(EC_OP_KAD_UPDATE_FROM_URL);

req.AddTag(CECTag(EC_TAG_KADEMLIA_UPDATE_URL, url));

m_connect->SendPacket(&req);

}

void CamuleRemoteGuiApp::DisconnectED2K() {

if (IsConnectedED2K()) {

m_connect->DisconnectED2K();

}

}

uint32 CamuleRemoteGuiApp::GetED2KID() const

{

return serverconnect ? serverconnect->GetClientID() : 0;

}

uint32 CamuleRemoteGuiApp::GetID() const

{

return m_clientID;

}

void CamuleRemoteGuiApp::ShowUserCount() {

wxString buffer;

static const wxString s_singlenetstatusformat = _("Users: %s | Files: %s");

static const wxString s_bothnetstatusformat = _("Users: E: %s K: %s | Files: E: %s K: %s");

if (thePrefs::GetNetworkED2K() && thePrefs::GetNetworkKademlia()) {

buffer = CFormat(s_bothnetstatusformat) % CastItoIShort(theStats::GetED2KUsers()) % CastItoIShort(theStats::GetKadUsers()) % CastItoIShort(theStats::GetED2KFiles()) % CastItoIShort(theStats::GetKadFiles());

} else if (thePrefs::GetNetworkED2K()) {

buffer = CFormat(s_singlenetstatusformat) % CastItoIShort(theStats::GetED2KUsers()) % CastItoIShort(theStats::GetED2KFiles());

} else if (thePrefs::GetNetworkKademlia()) {

buffer = CFormat(s_singlenetstatusformat) % CastItoIShort(theStats::GetKadUsers()) % CastItoIShort(theStats::GetKadFiles());

} else {

buffer = _("No networks selected");

}

Notify_ShowUserCount(buffer);

}

/*

* Preferences: holds both local and remote settings.

*

* First, everything is loaded from local config file. Later, settings

* that are relevant on remote side only are loaded thru EC

*/

CPreferencesRem::CPreferencesRem(CRemoteConnect *conn)

{

m_conn = conn;

//

// Settings queried from remote side

//

m_exchange_send_selected_prefs =

EC_PREFS_GENERAL |

EC_PREFS_CONNECTIONS |

EC_PREFS_MESSAGEFILTER |

EC_PREFS_ONLINESIG |

EC_PREFS_SERVERS |

EC_PREFS_FILES |

EC_PREFS_DIRECTORIES |

EC_PREFS_SECURITY |

EC_PREFS_CORETWEAKS |

EC_PREFS_REMOTECONTROLS |

EC_PREFS_KADEMLIA;

m_exchange_recv_selected_prefs =

m_exchange_send_selected_prefs |

EC_PREFS_CATEGORIES;

}

void CPreferencesRem::HandlePacket(const CECPacket *packet)

{

static_cast<const CEC_Prefs_Packet *>(packet)->Apply();

const CECTag *cat_tags = packet->GetTagByName(EC_TAG_PREFS_CATEGORIES);

if (cat_tags) {

for (CECTag::const_iterator it = cat_tags->begin(); it != cat_tags->end(); ++it) {

const CECTag &cat_tag = *it;

Category_Struct *cat = new Category_Struct;

cat->title = cat_tag.GetTagByName(EC_TAG_CATEGORY_TITLE)->GetStringData();

cat->path = CPath(cat_tag.GetTagByName(EC_TAG_CATEGORY_PATH)->GetStringData());

cat->comment = cat_tag.GetTagByName(EC_TAG_CATEGORY_COMMENT)->GetStringData();

cat->color = cat_tag.GetTagByName(EC_TAG_CATEGORY_COLOR)->GetInt();

cat->prio = cat_tag.GetTagByName(EC_TAG_CATEGORY_PRIO)->GetInt();

theApp->glob_prefs->AddCat(cat);

}

} else {

Category_Struct *cat = new Category_Struct;

cat->title = _("All");

cat->color = 0;

cat->prio = PR_NORMAL;

theApp->glob_prefs->AddCat(cat);

}

wxECInitDoneEvent event;

theApp->AddPendingEvent(event);

}

bool CPreferencesRem::LoadRemote()

{

//

// override local settings with remote

CECPacket req(EC_OP_GET_PREFERENCES, EC_DETAIL_UPDATE);

// bring categories too

req.AddTag(CECTag(EC_TAG_SELECT_PREFS, m_exchange_recv_selected_prefs));

m_conn->SendRequest(this, &req);

return true;

}

void CPreferencesRem::SendToRemote()

{

CEC_Prefs_Packet pref_packet(m_exchange_send_selected_prefs, EC_DETAIL_UPDATE, EC_DETAIL_FULL);

m_conn->SendPacket(&pref_packet);

}

// Surfaces the EC_OP_FAILED reply from amuled's EC_OP_ADD_LINK handler

// to the user. CDownQueueRem::AddLink used to drop the reply on the

// floor (fire-and-forget SendPacket), so a malformed ed2k link -- e.g.

// the original #310 reproducer `ed2k::3D366ED505B977FC61C9A6EE01E96329`

// -- silently did nothing. amuled does the right thing now (logs

// "Unknown protocol of link" and returns EC_OP_FAILED + EC_TAG_STRING),

// but the GUI side has to actually show the message.

class CAddLinkHandler : public CECPacketHandlerBase {

virtual void HandlePacket(const CECPacket *packet);

};

void CAddLinkHandler::HandlePacket(const CECPacket *packet)

{

if (packet->GetOpCode() == EC_OP_FAILED) {

// Daemon-side EC_OP_ADD_LINK always tags the failure response

// with an EC_TAG_STRING explaining what went wrong. Reuse that

// string as the fallback too (it's already in the i18n catalog

// at po/amule.pot:1783, so no new string needs adding here).

const CECTag *tag = packet->GetFirstTagSafe();

wxString msg = (tag && tag->IsString())

? wxGetTranslation(tag->GetStringData())

: wxGetTranslation(wxTRANSLATE("Invalid link or already on list."));

// Defer the modal off the OnPacketReceived call stack: wxMessageBox

// spins a nested wx event loop, which dispatches CoreNotify_LibSocket*

// events that re-enter CECSocket::OnInput on the same socket and

// clobber its rx state (m_curr_rx_data / m_bytes_needed / m_in_header).

// Under heavy notification load — a batched-link add against a

// big shareset — the corrupted parse trips a protocol-error

// CloseSocket, which is the desync amuled logs as "External

// connection closed" right after the AddLink batch (#757 part 1).

wxTheApp->CallAfter([msg]() {

wxMessageBox(msg, _("ERROR"), wxOK | wxICON_ERROR);

});

}

delete this;

}

class CCatHandler : public CECPacketHandlerBase {

virtual void HandlePacket(const CECPacket *packet);

};

void CCatHandler::HandlePacket(const CECPacket *packet)

{

if (packet->GetOpCode() == EC_OP_FAILED) {

const CECTag * catTag = packet->GetTagByName(EC_TAG_CATEGORY);

const CECTag * pathTag = packet->GetTagByName(EC_TAG_CATEGORY_PATH);

if (catTag && pathTag && catTag->GetInt() < theApp->glob_prefs->GetCatCount()) {

int cat = catTag->GetInt();

Category_Struct* cs = theApp->glob_prefs->GetCategory(cat);

wxString msg = CFormat(_("Can't create directory '%s' for category '%s', keeping directory '%s'."))

% cs->path.GetPrintable() % cs->title % pathTag->GetStringData();

cs->path = CPath(pathTag->GetStringData());

theApp->amuledlg->m_transferwnd->UpdateCategory(cat);

theApp->amuledlg->m_transferwnd->downloadlistctrl->Refresh();

// Same re-entrancy hazard as CAddLinkHandler above: keep the

// modal off the OnPacketReceived stack so a nested wx event

// loop doesn't corrupt CECSocket rx state.

wxTheApp->CallAfter([msg]() {

wxMessageBox(msg, _("ERROR"), wxOK);

});

}

}

delete this;

}

bool CPreferencesRem::CreateCategory(

Category_Struct *& category,

const wxString& name,

const CPath& path,

const wxString& comment,

uint32 color,

uint8 prio)

{

CECPacket req(EC_OP_CREATE_CATEGORY);

CEC_Category_Tag tag(0xffffffff, name, path.GetRaw(), comment, color, prio);

req.AddTag(tag);

m_conn->SendRequest(new CCatHandler, &req);

category = new Category_Struct();

category->path = path;

category->title = name;

category->comment = comment;

category->color = color;

category->prio = prio;

AddCat(category);

return true;

}

bool CPreferencesRem::UpdateCategory(

uint8 cat,

const wxString& name,

const CPath& path,

const wxString& comment,

uint32 color,

uint8 prio)

{

CECPacket req(EC_OP_UPDATE_CATEGORY);

CEC_Category_Tag tag(cat, name, path.GetRaw(), comment, color, prio);

req.AddTag(tag);

m_conn->SendRequest(new CCatHandler, &req);

Category_Struct *category = m_CatList[cat];

category->path = path;

category->title = name;

category->comment = comment;

category->color = color;

category->prio = prio;

return true;

}

void CPreferencesRem::RemoveCat(uint8 cat)

{

CECPacket req(EC_OP_DELETE_CATEGORY);

CEC_Category_Tag tag(cat, EC_DETAIL_CMD);

req.AddTag(tag);

m_conn->SendPacket(&req);

CPreferences::RemoveCat(cat);

}

//

// Container implementation

//

CServerConnectRem::CServerConnectRem(CRemoteConnect *conn)

{

m_CurrServer = 0;

m_Conn = conn;

}

void CServerConnectRem::ConnectToAnyServer()

{

CECPacket req(EC_OP_SERVER_CONNECT);

m_Conn->SendPacket(&req);

}

void CServerConnectRem::StopConnectionTry()

{

// lfroen: isn't Disconnect the same ?

}

void CServerConnectRem::Disconnect()