./BitVector.h

Bug Summary

File:	rootdir/src/./BitVector.h
Warning:	line 142, column 36 Null pointer passed to 1st parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name amule-remote-gui.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/rootdir/src -fcoverage-compilation-dir=/rootdir/src -resource-dir /usr/lib/llvm-19/lib/clang/19 -D HAVE_CONFIG_H -I . -I .. -D USE_WX_EXTENSIONS -I /usr/lib/x86_64-linux-gnu/wx/include/gtk3-unicode-3.2 -I /usr/include/wx-3.2 -D _FILE_OFFSET_BITS=64 -D WXUSINGDLL -D __WXGTK__ -D ENABLE_IP2COUNTRY=1 -I ./libs -I libs -I ./include -D CLIENT_GUI -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-register -fdeprecated-macro -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fcxx-exceptions -fexceptions -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2025-01-17-081402-14897-1 -x c++ amule-remote-gui.cpp

amule-remote-gui.cpp

→

1//
2// This file is part of the aMule Project.
3//
4// Copyright (c) 2005-2011 aMule Team ( admin@amule.org / http://www.amule.org )
5//
6// Any parts of this program derived from the xMule, lMule or eMule project,
7// or contributed by third-party developers are copyrighted by their
8// respective authors.
9//
10// This program is free software; you can redistribute it and/or modify
11// it under the terms of the GNU General Public License as published by
12// the Free Software Foundation; either version 2 of the License, or
13// (at your option) any later version.
14//
15// This program is distributed in the hope that it will be useful,
16// but WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18// GNU General Public License for more details.
19//
20// You should have received a copy of the GNU General Public License
21// along with this program; if not, write to the Free Software
22// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
23//


26#include <wx/ipc.h>
27#include <wx/cmdline.h>			// Needed for wxCmdLineParser
28#include <wx/config.h>			// Do_not_auto_remove (win32)
29#include <wx/fileconf.h>		// Needed for wxFileConfig
30#include <wx/socket.h>			// Needed for wxSocketBase


33#include <common/Format.h>
34#include <common/StringFunctions.h>
35#include <common/MD5Sum.h>


38#include <include/common/EventIDs.h>


41#include "amule.h"			// Interface declarations.
42#include "amuleDlg.h"			// Needed for CamuleDlg
43#include "ClientCredits.h"
44#include "SourceListCtrl.h"
45#include "ChatWnd.h"
46#include "DataToText.h"			// Needed for GetSoftName()
47#include "DownloadListCtrl.h"		// Needed for CDownloadListCtrl
48#include "Friend.h"
49#include "GetTickCount.h"	// Needed for GetTickCount
50#include "GuiEvents.h"
51#ifdef ENABLE_IP2COUNTRY1
#include "IP2Country.h"		// Needed for IP2Country
53#endif
54#include "InternalEvents.h"	// Needed for wxEVT_CORE_FINISHED_HTTP_DOWNLOAD
55#include "Logger.h"
56#include "muuli_wdr.h"			// Needed for IDs
57#include "PartFile.h"			// Needed for CPartFile
58#include "SearchDlg.h"			// Needed for CSearchDlg
59#include "Server.h"			// Needed for GetListName
60#include "ServerWnd.h"			// Needed for CServerWnd
61#include "SharedFilesCtrl.h"		// Needed for CSharedFilesCtrl
62#include "SharedFilesWnd.h"		// Needed for CSharedFilesWnd
63#include "TransferWnd.h"		// Needed for CTransferWnd
64#include "UpDownClientEC.h"		// Needed for CUpDownClient
65#include "ServerListCtrl.h"		// Needed for CServerListCtrl
66#include "ScopedPtr.h"
67#include "StatisticsDlg.h"	// Needed for CStatisticsDlg


70CEConnectDlg::CEConnectDlg()

72wxDialog(theApp->amuledlg, -1, _("Connect to remote amule")wxGetTranslation(("Connect to remote amule")), wxDefaultPosition)
73{
CoreConnect(this, true);

wxString pref_host, pref_port;
wxConfigwxFileConfig::Get()->Read(wxT("/EC/Host")L"/EC/Host", &pref_host, wxT("localhost")L"localhost");
wxConfigwxFileConfig::Get()->Read(wxT("/EC/Port")L"/EC/Port", &pref_port, wxT("4712")L"4712");
wxConfigwxFileConfig::Get()->Read(wxT("/EC/Password")L"/EC/Password", &pwd_hash);

CastChild(ID_REMOTE_HOST, wxTextCtrl)dynamic_cast<wxTextCtrl*>( FindWindow( 10301 ) )->SetValue(pref_host);
CastChild(ID_REMOTE_PORT, wxTextCtrl)dynamic_cast<wxTextCtrl*>( FindWindow( 10302 ) )->SetValue(pref_port);
CastChild(ID_EC_PASSWD, wxTextCtrl)dynamic_cast<wxTextCtrl*>( FindWindow( 10304 ) )->SetValue(pwd_hash);

CentreOnParent();
86}


89wxString CEConnectDlg::PassHash()
90{
return pwd_hash;
92}


95BEGIN_EVENT_TABLE(CEConnectDlg, wxDialog)const wxEventTable CEConnectDlg::sm_eventTable = { &wxDialog
::sm_eventTable, &CEConnectDlg::sm_eventTableEntries[0] }
; const wxEventTable *CEConnectDlg::GetEventTable() const { return
 &CEConnectDlg::sm_eventTable; } wxEventHashTable CEConnectDlg
::sm_eventHashTable(CEConnectDlg::sm_eventTable); wxEventHashTable
 &CEConnectDlg::GetEventHashTable() const { return CEConnectDlg
::sm_eventHashTable; } const wxEventTableEntry CEConnectDlg::
sm_eventTableEntries[] = {
EVT_BUTTON(wxID_OK, CEConnectDlg::OnOK)wxEventTableEntry(wxEVT_BUTTON, wxID_OK, wxID_ANY, wxNewEventTableFunctor
(wxEVT_BUTTON, wxEventFunctionCast(wxPrivate::DoCast<wxPrivate
::EventArgOf<wxCommandEventFunction>::type>(&CEConnectDlg
::OnOK))), __null),
97END_EVENT_TABLE()wxEventTableEntry(wxEVT_NULL, 0, 0, __null, __null) };


100void CEConnectDlg::OnOK(wxCommandEvent& evt)
101{
wxString s_port = CastChild(ID_REMOTE_PORT, wxTextCtrl)dynamic_cast<wxTextCtrl*>( FindWindow( 10302 ) )->GetValue();
port = StrToLong(s_port);

host = CastChild(ID_REMOTE_HOST, wxTextCtrl)dynamic_cast<wxTextCtrl*>( FindWindow( 10301 ) )->GetValue();
passwd = CastChild(ID_EC_PASSWD, wxTextCtrl)dynamic_cast<wxTextCtrl*>( FindWindow( 10304 ) )->GetValue();

if (passwd != pwd_hash) {
pwd_hash = MD5Sum(passwd).GetHash();
}
m_save_user_pass = CastChild(ID_EC_SAVE, wxCheckBox)dynamic_cast<wxCheckBox*>( FindWindow( 10305 ) )->IsChecked();
evt.Skip();
113}


116DEFINE_LOCAL_EVENT_TYPE(wxEVT_EC_INIT_DONE)const wxEventType wxEVT_EC_INIT_DONE = wxNewEventType();


119BEGIN_EVENT_TABLE(CamuleRemoteGuiApp, wxApp)const wxEventTable CamuleRemoteGuiApp::sm_eventTable = { &
wxApp::sm_eventTable, &CamuleRemoteGuiApp::sm_eventTableEntries
[0] }; const wxEventTable *CamuleRemoteGuiApp::GetEventTable(
) const { return &CamuleRemoteGuiApp::sm_eventTable; } wxEventHashTable
 CamuleRemoteGuiApp::sm_eventHashTable(CamuleRemoteGuiApp::sm_eventTable
); wxEventHashTable &CamuleRemoteGuiApp::GetEventHashTable
() const { return CamuleRemoteGuiApp::sm_eventHashTable; } const
 wxEventTableEntry CamuleRemoteGuiApp::sm_eventTableEntries[]
 = {
// Core timer
EVT_TIMER(ID_CORE_TIMER_EVENT, CamuleRemoteGuiApp::OnPollTimer)wxEventTableEntry(wxEVT_TIMER, ID_CORE_TIMER_EVENT, wxID_ANY,
 wxNewEventTableFunctor(wxEVT_TIMER, wxEventFunctionCast(wxPrivate
::DoCast<wxPrivate::EventArgOf<wxTimerEventFunction>
::type>(&CamuleRemoteGuiApp::OnPollTimer))), __null),

EVT_CUSTOM(wxEVT_EC_CONNECTION, -1, CamuleRemoteGuiApp::OnECConnection)wxEventTableEntry(wxEVT_EC_CONNECTION, -1, wxID_ANY, wxNewEventTableFunctor
(wxEVT_EC_CONNECTION, wxEventFunctionCast(wxPrivate::DoCast<
wxPrivate::EventArgOf<wxEventFunction>::type>(&CamuleRemoteGuiApp
::OnECConnection))), __null),
EVT_CUSTOM(wxEVT_EC_INIT_DONE, -1, CamuleRemoteGuiApp::OnECInitDone)wxEventTableEntry(wxEVT_EC_INIT_DONE, -1, wxID_ANY, wxNewEventTableFunctor
(wxEVT_EC_INIT_DONE, wxEventFunctionCast(wxPrivate::DoCast<
wxPrivate::EventArgOf<wxEventFunction>::type>(&CamuleRemoteGuiApp
::OnECInitDone))), __null),

EVT_MULE_NOTIFY(CamuleRemoteGuiApp::OnNotifyEvent)wxEventTableEntry(MULE_EVT_NOTIFY, -1, -1, wxNewEventTableFunctor
(MULE_EVT_NOTIFY, (wxObjectEventFunction) (wxEventFunction) static_cast
<MuleNotifyEventFunction>(&CamuleRemoteGuiApp::OnNotifyEvent
)), (wxObject*) __null),

128#ifdef ENABLE_IP2COUNTRY1
// HTTPDownload finished
EVT_MULE_INTERNAL(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD, -1, CamuleRemoteGuiApp::OnFinishedHTTPDownload)wxEventTableEntry(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD, -1, -1, wxNewEventTableFunctor
(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD, (wxObjectEventFunction) (
wxEventFunction) static_cast<MuleInternalEventFunction>
(&CamuleRemoteGuiApp::OnFinishedHTTPDownload)), (wxObject
*) __null),
131#endif
132END_EVENT_TABLE()wxEventTableEntry(wxEVT_NULL, 0, 0, __null, __null) };


135IMPLEMENT_APP(CamuleRemoteGuiApp)int main(int argc, char **argv) { ; ; return wxEntry(argc, argv
); } CamuleRemoteGuiApp& wxGetApp() { return *static_cast
<CamuleRemoteGuiApp*>(wxApp::GetInstance()); } wxAppConsole
 *wxCreateApp() { wxAppConsole::CheckBuildOptions("3" "." "2"
 " (" "wchar_t" ",compiler with C++ ABI compatible with gcc 4"
 ",wx containers" ",compatible with 3.0" ")", "your program")
; return new CamuleRemoteGuiApp; } wxAppInitializer wxTheAppInitializer
((wxAppInitializerFunction) wxCreateApp);


138int CamuleRemoteGuiApp::OnExit()
139{
StopTickTimer();

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

return wxApp::OnExit();
145}


148void CamuleRemoteGuiApp::OnPollTimer(wxTimerEvent&)
149{
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();
	}
}
// Back to the roots
request_step = 0;
break;
default:
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 193, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
request_step = 0;
}

// Check for new links once per second.
static uint32 lastED2KLinkCheck = 0;
if (GetTickCount() - lastED2KLinkCheck >= 1000) {
AddLinksFromFile();
lastED2KLinkCheck = GetTickCount();
}
203}


206void CamuleRemoteGuiApp::OnFinishedHTTPDownload(CMuleInternalEvent& event)
207{
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();
}
213}


216void CamuleRemoteGuiApp::ShutDown(wxCloseEvent &WXUNUSED(evt))
217{
// Stop the Core Timer
delete poll_timer;
poll_timer = NULL__null;

222#ifdef ASIO_SOCKETS
m_AsioService->Stop();
delete m_AsioService;
m_AsioService = NULL__null;
226#endif

// Destroy the EC socket
m_connect->Destroy();
m_connect = NULL__null;

//
if (amuledlg) {
amuledlg->DlgShutDown();
amuledlg->Destroy();
amuledlg = NULL__null;
}
delete m_allUploadingKnownFile;
delete stattree;
240}


243bool CamuleRemoteGuiApp::OnInit()
244{
StartTickTimer();
amuledlg = NULL__null;

// Get theApp
theApp = &wxGetApp();

// Handle uncaught exceptions
InstallMuleExceptionHandler();

// Parse cmdline arguments.
if (!InitCommon(AMULE_APP_BASEwxApp::argc, AMULE_APP_BASEwxApp::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"))theLogger.AddLogLine(L"amule-remote-gui.cpp", 265, true, logStandard
, wxGetTranslation(("Fatal Error: Failed to create Poll Timer"
)), true);
OnExit();
}

m_connect = new CRemoteConnect(this);

271#ifdef ASIO_SOCKETS
m_AsioService = new CAsioService;
273#endif

glob_prefs = new CPreferencesRem(m_connect);
long enableZLIB;
wxConfigwxFileConfig::Get()->Read(wxT("/EC/ZLIB")L"/EC/ZLIB", &enableZLIB, 1);
m_connect->SetCapabilities(enableZLIB != 0, true, false);	// ZLIB, UTF8 numbers, notification

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

if (ShowConnectionDialog()) {
AddLogLineNS(_("Going to event loop..."))theLogger.AddLogLine(L"amule-remote-gui.cpp", 284, false, logStandard
, wxGetTranslation(("Going to event loop...")), true);
return true;
}

return false;
289}


292bool CamuleRemoteGuiApp::CryptoAvailable() const
293{
return thePrefs::IsSecureIdentEnabled(); // good enough
295}


298bool CamuleRemoteGuiApp::ShowConnectionDialog()
299{
dialog = new CEConnectDlg;

if (m_skipConnectionDialog) {
wxCommandEvent evt;
dialog->OnOK(evt);
} else if (dialog->ShowModal() != wxID_OK) {
dialog->Destroy();

return false;
}
AddLogLineNS(_("Connecting..."))theLogger.AddLogLine(L"amule-remote-gui.cpp", 310, false, logStandard
, wxGetTranslation(("Connecting...")), true);
if (!m_connect->ConnectToCore(dialog->Host(), dialog->Port(),
dialog->Login(), dialog->PassHash(),
wxT("amule-remote")L"amule-remote", wxT("0x0001")L"0x0001")) {
wxMessageBox(_("Connection failed ")wxGetTranslation(("Connection failed ")),_("ERROR")wxGetTranslation(("ERROR")),wxOK0x00000004);

return false;
}

return true;
320}


323void CamuleRemoteGuiApp::OnECConnection(wxEvent& event) {
wxECSocketEvent& evt = *((wxECSocketEvent*)&event);
AddLogLineNS(_("Remote GUI EC event handler"))theLogger.AddLogLine(L"amule-remote-gui.cpp", 325, false, logStandard
, wxGetTranslation(("Remote GUI EC event handler")), true);
wxString reply = evt.GetServerReply();
AddLogLineC(reply)theLogger.AddLogLine(L"amule-remote-gui.cpp", 327, true, logStandard
, reply);
if (evt.GetResult() == true) {
// Connected - go to next init step
glob_prefs->LoadRemote();
} else {
AddLogLineNS(_("Going down"))theLogger.AddLogLine(L"amule-remote-gui.cpp", 332, false, logStandard
, wxGetTranslation(("Going down")), true);
if (dialog) {	// connect failed
	wxMessageBox(
	(CFormat(_("Connection Failed. Unable to connect to %s:%d\n")wxGetTranslation(("Connection Failed. Unable to connect to %s:%d\n"
))) % dialog->Host() % dialog->Port()) + reply,
	_("ERROR")wxGetTranslation(("ERROR")), wxOK0x00000004);
} else {		// server disconnected (probably terminated) later
	wxMessageBox(_("Connection closed - aMule has terminated probably.")wxGetTranslation(("Connection closed - aMule has terminated probably."
)), _("ERROR")wxGetTranslation(("ERROR")), wxOK0x00000004);
}
wxCloseEvent ev;
ShutDown(ev);
ExitMainLoop();
}
344}


347void CamuleRemoteGuiApp::OnECInitDone(wxEvent& )
348{
Startup();
350}


353void CamuleRemoteGuiApp::OnNotifyEvent(CMuleGUIEvent& evt)
354{
evt.Notify();
356}


359void CamuleRemoteGuiApp::Startup() {

if (dialog->SaveUserPass()) {
wxConfigwxFileConfig::Get()->Write(wxT("/EC/Host")L"/EC/Host", dialog->Host());
wxConfigwxFileConfig::Get()->Write(wxT("/EC/Port")L"/EC/Port", dialog->Port());
wxConfigwxFileConfig::Get()->Write(wxT("/EC/Password")L"/EC/Password", dialog->PassHash());
}
dialog->Destroy();
dialog = NULL__null;

m_ConnState = 0;
m_clientID  = 0;

serverconnect = new CServerConnectRem(m_connect);
m_statistics = new CStatistics(*m_connect);
stattree = new CStatTreeRem(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
402#ifdef ENABLE_IP2COUNTRY1
if (thePrefs::IsGeoIPEnabled()) {
amuledlg->m_IP2Country->Enable();
}
406#endif
407}


410int CamuleRemoteGuiApp::ShowAlert(wxString msg, wxString title, int flags)
411{
return CamuleGuiBase::ShowAlert(msg, title, flags);
413}


416void CamuleRemoteGuiApp::AddRemoteLogLine(const wxString& line)
417{
amuledlg->AddLogLine(line);
419}

421int CamuleRemoteGuiApp::InitGui(bool geometry_enabled, wxString &geom_string)
422{
CamuleGuiBase::InitGui(geometry_enabled, geom_string);
SetTopWindow(amuledlg);
AddLogLineN(_("Ready"))theLogger.AddLogLine(L"amule-remote-gui.cpp", 425, false, logStandard
, wxGetTranslation(("Ready"))); // The first log line after the window is up triggers output of all the ones before
return 0;
427}


430bool CamuleRemoteGuiApp::CopyTextToClipboard(wxString strText)
431{
return CamuleGuiBase::CopyTextToClipboard(strText);
433}


436uint32 CamuleRemoteGuiApp::GetPublicIP()
437{
return 0;
439}


442wxString CamuleRemoteGuiApp::GetLog(bool reset)
443{
if (reset) {
amuledlg->ResetLog(ID_LOGVIEW10242);
CECPacket req(EC_OP_RESET_LOG);
m_connect->SendPacket(&req);
}
return wxEmptyString;
450}


453wxString CamuleRemoteGuiApp::GetServerLog(bool)
454{
return wxEmptyString;
456}


459bool CamuleRemoteGuiApp::AddServer(CServer * server, bool)
460{
CECPacket req(EC_OP_SERVER_ADD);
req.AddTag(CECTag(EC_TAG_SERVER_ADDRESS, CFormat(wxT("%s:%d")L"%s:%d") % server->GetAddress() % server->GetPort()));
req.AddTag(CECTag(EC_TAG_SERVER_NAME, server->GetListName()));
m_connect->SendPacket(&req);

return true;
467}


470bool CamuleRemoteGuiApp::IsFirewalled() const
471{
if (IsConnectedED2K() && !serverconnect->IsLowID()) {
return false;
}

return IsFirewalledKad();
477}


480bool CamuleRemoteGuiApp::IsConnectedED2K() const {
return serverconnect && serverconnect->IsConnected();
482}


485void CamuleRemoteGuiApp::StartKad() {
m_connect->StartKad();
487}


490void CamuleRemoteGuiApp::StopKad() {
m_connect->StopKad();
492}


495void CamuleRemoteGuiApp::BootstrapKad(uint32 ip, uint16 port)
496{
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);
502}


505void CamuleRemoteGuiApp::UpdateNotesDat(const wxString& url)
506{
CECPacket req(EC_OP_KAD_UPDATE_FROM_URL);
req.AddTag(CECTag(EC_TAG_KADEMLIA_UPDATE_URL, url));

m_connect->SendPacket(&req);
511}


514void CamuleRemoteGuiApp::DisconnectED2K() {
if (IsConnectedED2K()) {
m_connect->DisconnectED2K();
}
518}


521uint32 CamuleRemoteGuiApp::GetED2KID() const
522{
return serverconnect ? serverconnect->GetClientID() : 0;
524}


527uint32 CamuleRemoteGuiApp::GetID() const
528{
return m_clientID;
530}


533void CamuleRemoteGuiApp::ShowUserCount() {
wxString buffer;

static const wxString s_singlenetstatusformat = _("Users: %s | Files: %s")wxGetTranslation(("Users: %s | Files: %s"));
static const wxString s_bothnetstatusformat = _("Users: E: %s K: %s | Files: E: %s K: %s")wxGetTranslation(("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")wxGetTranslation(("No networks selected"));
}

Notify_ShowUserCount(buffer)MuleNotify::DoNotify(&MuleNotify::ShowUserCount, buffer);
550}


553/*
* 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
*/
559CPreferencesRem::CPreferencesRem(CRemoteConnect *conn)
560{
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;
581}


584void CPreferencesRem::HandlePacket(const CECPacket *packet)
585{
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")wxGetTranslation(("All"));
cat->color =  0;
cat->prio = PR_NORMAL1;
theApp->glob_prefs->AddCat(cat);
}
wxECInitDoneEvent event;
theApp->AddPendingEvent(event);

610}


613bool CPreferencesRem::LoadRemote()
614{
//
// 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;
625}


628void CPreferencesRem::SendToRemote()
629{
CEC_Prefs_Packet pref_packet(m_exchange_send_selected_prefs, EC_DETAIL_UPDATE, EC_DETAIL_FULL);
m_conn->SendPacket(&pref_packet);
632}


635class CCatHandler : public CECPacketHandlerBase {
virtual void HandlePacket(const CECPacket *packet);
637};


640void CCatHandler::HandlePacket(const CECPacket *packet)
641{
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);
	wxMessageBox(CFormat(_("Can't create directory '%s' for category '%s', keeping directory '%s'.")wxGetTranslation(("Can't create directory '%s' for category '%s', keeping directory '%s'."
)))
		% cs->path.GetPrintable() % cs->title % pathTag->GetStringData(),
		_("ERROR")wxGetTranslation(("ERROR")), wxOK0x00000004);
	cs->path = CPath(pathTag->GetStringData());
	theApp->amuledlg->m_transferwnd->UpdateCategory(cat);
	theApp->amuledlg->m_transferwnd->downloadlistctrl->Refresh();
}
}
delete this;
657}


660bool CPreferencesRem::CreateCategory(
Category_Struct *& category,
const wxString& name,
const CPath& path,
const wxString& comment,
uint32 color,
uint8 prio)
667{
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;
683}


686bool CPreferencesRem::UpdateCategory(
uint8 cat,
const wxString& name,
const CPath& path,
const wxString& comment,
uint32 color,
uint8 prio)
693{
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;
707}


710void CPreferencesRem::RemoveCat(uint8 cat)
711{
CECPacket req(EC_OP_DELETE_CATEGORY);
CEC_Category_Tag tag(cat, EC_DETAIL_CMD);
req.AddTag(tag);
m_conn->SendPacket(&req);
CPreferences::RemoveCat(cat);
717}


720//
721// Container implementation
722//
723CServerConnectRem::CServerConnectRem(CRemoteConnect *conn)
724{
m_CurrServer = 0;
m_Conn = conn;
727}


730void CServerConnectRem::ConnectToAnyServer()
731{
CECPacket req(EC_OP_SERVER_CONNECT);
m_Conn->SendPacket(&req);
734}


737void CServerConnectRem::StopConnectionTry()
738{
// lfroen: isn't Disconnect the same ?
740}


743void CServerConnectRem::Disconnect()
744{
CECPacket req(EC_OP_SERVER_DISCONNECT);
m_Conn->SendPacket(&req);
747}


750void CServerConnectRem::ConnectToServer(CServer *server)
751{
m_Conn->ConnectED2K(server->GetIP(), server->GetPort());
753}


756void CServerConnectRem::HandlePacket(const CECPacket *packet)
757{
const CEC_ConnState_Tag *tag = static_cast<const CEC_ConnState_Tag *>(packet->GetTagByName(EC_TAG_CONNSTATE));
if (!tag) {
return;
}

theApp->m_ConnState = 0;
CServer *server;
m_ID = tag->GetEd2kId();
theApp->m_clientID = tag->GetClientId();
tag->GetKadID(theApp->m_kadID);

if (tag->IsConnectedED2K()) {
const CECTag *srvtag = tag->GetTagByName(EC_TAG_SERVER);
if (srvtag) {
	server = theApp->serverlist->GetByID(srvtag->GetInt());
	if (server != m_CurrServer) {
		theApp->amuledlg->m_serverwnd->serverlistctrl->HighlightServer(server, true);
		m_CurrServer = server;
	}
}
theApp->m_ConnState |= CONNECTED_ED2K(1<<0);
} else if ( m_CurrServer ) {
   theApp->amuledlg->m_serverwnd->serverlistctrl->HighlightServer(m_CurrServer, false);
   m_CurrServer = 0;
}

if (tag->IsConnectedKademlia()) {
if (tag->IsKadFirewalled()) {
	theApp->m_ConnState |= CONNECTED_KAD_FIREWALLED(1<<3);
} else {
	theApp->m_ConnState |= CONNECTED_KAD_OK(1<<2);
}
} else {
if (tag->IsKadRunning()) {
	theApp->m_ConnState |= CONNECTED_KAD_NOT(1<<1);
}
}

theApp->amuledlg->ShowConnectionState();
797}


800/*
* Server list: host list of ed2k servers.
*/
803CServerListRem::CServerListRem(CRemoteConnect *conn)

805CRemoteContainer<CServer, uint32, CEC_Server_Tag>(conn, true)
806{
807}


810void CServerListRem::HandlePacket(const CECPacket *)
811{
// There is no packet for the server list, it is part of the general update packet
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 813, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
// CRemoteContainer<CServer, uint32, CEC_Server_Tag>::HandlePacket(packet);
815}


818void CServerListRem::UpdateServerMetFromURL(wxString url)
819{
CECPacket req(EC_OP_SERVER_UPDATE_FROM_URL);
req.AddTag(CECTag(EC_TAG_SERVERS_UPDATE_URL, url));

m_conn->SendPacket(&req);
824}


827void CServerListRem::SetStaticServer(CServer* server, bool isStatic)
828{
// update display right away
server->SetIsStaticMember(isStatic);
Notify_ServerRefresh(server)MuleNotify::DoNotify(&MuleNotify::ServerRefresh, server);

CECPacket req(EC_OP_SERVER_SET_STATIC_PRIO);
req.AddTag(CECTag(EC_TAG_SERVER, server->ECID()));
req.AddTag(CECTag(EC_TAG_SERVER_STATIC, isStatic));

m_conn->SendPacket(&req);
838}


841void CServerListRem::SetServerPrio(CServer* server, uint32 prio)
842{
// update display right away
server->SetPreference(prio);
Notify_ServerRefresh(server)MuleNotify::DoNotify(&MuleNotify::ServerRefresh, server);

CECPacket req(EC_OP_SERVER_SET_STATIC_PRIO);
req.AddTag(CECTag(EC_TAG_SERVER, server->ECID()));
req.AddTag(CECTag(EC_TAG_SERVER_PRIO, prio));

m_conn->SendPacket(&req);
852}


855void CServerListRem::RemoveServer(CServer* server)
856{
m_conn->RemoveServer(server->GetIP(),server->GetPort());
858}


861void CServerListRem::UpdateUserFileStatus(CServer *server)
862{
if (server) {
m_TotalUser = server->GetUsers();
m_TotalFile = server->GetFiles();
}
867}


870CServer *CServerListRem::GetServerByAddress(const wxString& WXUNUSED(address), uint16 WXUNUSED(port)) const
871{
// It's ok to return 0 for context where this code is used in remote gui
return 0;
874}

876CServer *CServerListRem::GetServerByIPTCP(uint32 WXUNUSED(nIP), uint16 WXUNUSED(nPort)) const
877{
// It's ok to return 0 for context where this code is used in remote gui
return 0;
880}

882CServer *CServerListRem::CreateItem(const CEC_Server_Tag *tag)
883{
CServer * server = new CServer(tag);
ProcessItemUpdate(tag, server);
return server;
887}


890void CServerListRem::DeleteItem(CServer *in_srv)
891{
CScopedPtr<CServer> srv(in_srv);
theApp->amuledlg->m_serverwnd->serverlistctrl->RemoveServer(srv.get());
894}


897uint32 CServerListRem::GetItemID(CServer *server)
898{
return server->ECID();
900}


903void CServerListRem::ProcessItemUpdate(const CEC_Server_Tag * tag, CServer * server)
904{
if (!tag->HasChildTags()) {
return;
}
tag->ServerName(& server->listname);
tag->ServerDesc(& server->description);
tag->ServerVersion(& server->m_strVersion);
tag->GetMaxUsers(& server->maxusers);

tag->GetFiles(& server->files);
tag->GetUsers(& server->users);

tag->GetPrio(& server->preferences); // SRV_PR_NORMAL = 0, so it's ok
  tag->GetStatic(& server->staticservermember);

tag->GetPing(& server->ping);
tag->GetFailed(& server->failedcount);

theApp->amuledlg->m_serverwnd->serverlistctrl->RefreshServer(server);
923}


926CServer::CServer(const CEC_Server_Tag *tag) : CECID(tag->GetInt())
927{
ip = tag->GetTagByNameSafe(EC_TAG_SERVER_IP)->GetInt();
port = tag->GetTagByNameSafe(EC_TAG_SERVER_PORT)->GetInt();

Init();
932}


935/*
* IP filter
*/
938CIPFilterRem::CIPFilterRem(CRemoteConnect* conn)
939{
m_conn = conn;
941}


944void CIPFilterRem::Reload()
945{
CECPacket req(EC_OP_IPFILTER_RELOAD);
m_conn->SendPacket(&req);
948}


951void CIPFilterRem::Update(wxString url)
952{
CECPacket req(EC_OP_IPFILTER_UPDATE);
req.AddTag(CECTag(EC_TAG_STRING, url));

m_conn->SendPacket(&req);
957}


960/*
* Shared files list
*/
963CSharedFilesRem::CSharedFilesRem(CRemoteConnect *conn)
964{
m_conn = conn;
966}


969void CSharedFilesRem::Reload(bool, bool)
970{
CECPacket req(EC_OP_SHAREDFILES_RELOAD);

m_conn->SendPacket(&req);
974}


977bool CSharedFilesRem::RenameFile(CKnownFile* file, const CPath& newName)
978{
// We use the printable name, as the filename originated from user input,
// and the filesystem name might not be valid on the remote host.
const wxString strNewName = newName.GetPrintable();

CECPacket request(EC_OP_RENAME_FILE);
request.AddTag(CECTag(EC_TAG_KNOWNFILE, file->GetFileHash()));
request.AddTag(CECTag(EC_TAG_PARTFILE_NAME, strNewName));

m_conn->SendPacket(&request);

return true;
990}


993void CSharedFilesRem::SetFileCommentRating(CKnownFile* file, const wxString& newComment, int8 newRating)
994{
CECPacket request(EC_OP_SHARED_FILE_SET_COMMENT);
request.AddTag(CECTag(EC_TAG_KNOWNFILE, file->GetFileHash()));
request.AddTag(CECTag(EC_TAG_KNOWNFILE_COMMENT, newComment));
request.AddTag(CECTag(EC_TAG_KNOWNFILE_RATING, newRating));

m_conn->SendPacket(&request);
1001}


1004void CSharedFilesRem::CopyFileList(std::vector<CKnownFile*>& out_list) const
1005{
out_list.reserve(size());
for (const_iterator it = begin(); it != end(); ++it) {
out_list.push_back(it->second);
}
1010}


1013void CKnownFilesRem::DeleteItem(CKnownFile * file)
1014{
uint32 id = file->ECID();
if (theApp->sharedfiles->count(id)) {
theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->RemoveFile(file);
theApp->sharedfiles->erase(id);
}
if (theApp->downloadqueue->count(id)) {
theApp->amuledlg->m_transferwnd->downloadlistctrl->RemoveFile(static_cast<CPartFile *>(file));
theApp->downloadqueue->erase(id);
}
delete file;
1025}


1028uint32 CKnownFilesRem::GetItemID(CKnownFile *file)
1029{
return file->ECID();
1031}


1034void CKnownFilesRem::ProcessItemUpdate(const CEC_SharedFile_Tag *tag, CKnownFile *file)
1035{
const CECTag *parttag = tag->GetTagByName(EC_TAG_PARTFILE_PART_STATUS);
if (parttag) {
const uint8 *data =	file->m_partStatus.Decode(
		(uint8 *)parttag->GetTagData(),
		parttag->GetTagDataLen());
for(int i = 0; i < file->GetPartCount(); ++i) {
	file->m_AvailPartFrequency[i] = data[i];
}
}
wxString fileName;
if (tag->FileName(fileName)) {
file->SetFileName(CPath(fileName));
}
if (tag->FilePath(fileName)) {
file->m_filePath = CPath(fileName);
}
tag->UpPrio(&file->m_iUpPriorityEC);
tag->GetAICHHash(file->m_AICHMasterHash);
// Bad thing - direct writing another class' members
tag->GetRequests(&file->statistic.requested);
tag->GetAllRequests(&file->statistic.alltimerequested);
tag->GetAccepts(&file->statistic.accepted);
tag->GetAllAccepts(&file->statistic.alltimeaccepted);
tag->GetXferred(&file->statistic.transferred);
tag->GetAllXferred(&file->statistic.alltimetransferred);
tag->UpPrio(&file->m_iUpPriorityEC);
if (file->m_iUpPriorityEC >= 10) {
file->m_iUpPriority = file->m_iUpPriorityEC - 10;
file->m_bAutoUpPriority = true;
} else {
file->m_iUpPriority = file->m_iUpPriorityEC;
file->m_bAutoUpPriority = false;
}
tag->GetCompleteSourcesLow(&file->m_nCompleteSourcesCountLo);
tag->GetCompleteSourcesHigh(&file->m_nCompleteSourcesCountHi);
tag->GetCompleteSources(&file->m_nCompleteSourcesCount);

tag->GetOnQueue(&file->m_queuedCount);

tag->GetComment(file->m_strComment);
tag->GetRating(file->m_iRating);

requested += file->statistic.requested;
transferred += file->statistic.transferred;
accepted += file->statistic.transferred;

if (!m_initialUpdate) {
theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->UpdateItem(file);
}

if (file->IsPartFile()) {
ProcessItemUpdatePartfile(static_cast<const CEC_PartFile_Tag *>(tag), static_cast<CPartFile *>(file));
}
1089}

1091void CSharedFilesRem::SetFilePrio(CKnownFile *file, uint8 prio)
1092{
CECPacket req(EC_OP_SHARED_SET_PRIO);

CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, prio));

req.AddTag(hashtag);

m_conn->SendPacket(&req);
1101}

1103void CKnownFilesRem::ProcessUpdate(const CECTag *reply, CECPacket *, int)
1104{
requested = 0;
transferred = 0;
accepted = 0;

std::set<uint32> core_files;
for (CECPacket::const_iterator it = reply->begin(); it != reply->end(); ++it) {
const CECTag * curTag = &*it;
ec_tagname_t tagname = curTag->GetTagName();
if (tagname == EC_TAG_CLIENT) {
	theApp->clientlist->ProcessUpdate(curTag, NULL__null, EC_TAG_CLIENT);
} else if (tagname == EC_TAG_SERVER) {
	theApp->serverlist->ProcessUpdate(curTag, NULL__null, EC_TAG_SERVER);
} else if (tagname == EC_TAG_FRIEND) {
	theApp->friendlist->ProcessUpdate(curTag, NULL__null, EC_TAG_FRIEND);
} else if (tagname == EC_TAG_KNOWNFILE || tagname == EC_TAG_PARTFILE) {
	const CEC_SharedFile_Tag *tag = static_cast<const CEC_SharedFile_Tag *>(curTag);
	uint32 id = tag->ID();
	bool isNew = true;
	if (!m_initialUpdate) {
		core_files.insert(id);
		std::map<uint32, CKnownFile*>::iterator it2 = m_items_hash.find(id);
		if (it2 != m_items_hash.end() ) {
			// Item already known: update it
			if (tag->HasChildTags()) {
				ProcessItemUpdate(tag, it2->second);
			}
			isNew = false;
		}
	}
	if (isNew) {
		CKnownFile * newFile;
		if (tag->GetTagName() == EC_TAG_PARTFILE) {
			CPartFile *file = new CPartFile(static_cast<const CEC_PartFile_Tag *>(tag));
			ProcessItemUpdate(tag, file);
			(*theApp->downloadqueue)[id] = file;
			theApp->amuledlg->m_transferwnd->downloadlistctrl->AddFile(file);
			newFile = file;
		} else {
			newFile = new CKnownFile(tag);
			ProcessItemUpdate(tag, newFile);
			(*theApp->sharedfiles)[id] = newFile;
			if (!m_initialUpdate) {
				theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->ShowFile(newFile);
			}
		}
		AddItem(newFile);
	}
}
}

if (m_initialUpdate) {
theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->ShowFileList();
m_initialUpdate = false;
} else {
// remove items no longer present
for(iterator it = begin(); it != end();) {
	iterator it2 = it++;
	if (!core_files.count(GetItemID(*it2))) {
		RemoveItem(it2);	// This calls DeleteItem, where it is removed from lists and views.
	}
}
}
1167}

1169CKnownFilesRem::CKnownFilesRem(CRemoteConnect * conn) : CRemoteContainer<CKnownFile, uint32, CEC_SharedFile_Tag>(conn, true)
1170{
requested = 0;
transferred = 0;
accepted = 0;
m_initialUpdate = true;
1175}


1178/*
* List of uploading and waiting clients.
*/
1181CUpDownClientListRem::CUpDownClientListRem(CRemoteConnect *conn)

1183CRemoteContainer<CClientRef, uint32, CEC_UpDownClient_Tag>(conn, true)
1184{
1185}


1188CClientRef::CClientRef(const CEC_UpDownClient_Tag *tag)
1189{
m_client = new CUpDownClient(tag);
1191#ifdef DEBUG_ZOMBIE_CLIENTS
m_client->Link(wxT("TAG")L"TAG");
1193#else
m_client->Link();
1195#endif
1196}


1199CUpDownClient::CUpDownClient(const CEC_UpDownClient_Tag *tag) : CECID(tag->ID())
1200{
m_linked = 0;
1202#ifdef DEBUG_ZOMBIE_CLIENTS
m_linkedDebug = false;
1204#endif
// Clients start up empty, then get asked for their data.
// So all data here is processed in ProcessItemUpdate and thus updatable.
m_bEmuleProtocol		= false;
m_AvailPartCount		= 0;
m_clientSoft			= 0;
m_nDownloadState		= 0;
m_Friend				= NULL__null;
m_bFriendSlot			= false;
m_nKadPort				= 0;
m_kBpsDown				= 0;
m_dwUserIP				= 0;
m_lastDownloadingPart	= 0xffff;
m_nextRequestedPart		= 0xffff;
m_obfuscationStatus		= 0;
m_nOldRemoteQueueRank	= 0;
m_nRemoteQueueRank		= 0;
m_reqfile				= NULL__null;
m_score					= 0;
m_dwServerIP			= 0;
m_nServerPort			= 0;
m_nSourceFrom			= SF_NONE;
m_nTransferredDown		= 0;
m_nTransferredUp		= 0;
m_nUpDatarate			= 0;
m_uploadingfile			= NULL__null;
m_waitingPosition		= 0;
m_nUploadState			= 0;
m_nUserIDHybrid			= 0;
m_nUserPort				= 0;
m_nClientVersion		= 0;
m_fNoViewSharedFiles	= true;
m_identState			= IS_NOTAVAILABLE;
m_bRemoteQueueFull		= false;

credits = new CClientCredits(new CreditStruct());
1240}

1242#ifdef DEBUG_ZOMBIE_CLIENTS
1243void CUpDownClient::Unlink(const wxString& from)
1244{
std::multiset<wxString>::iterator it = m_linkedFrom.find(from);
if (it != m_linkedFrom.end()) {
m_linkedFrom.erase(it);
}
m_linked--;
if (!m_linked) {
if (m_linkedDebug) {
	AddLogLineN(CFormat(wxT("Last reference to client %d %p unlinked, delete it.")) % ECID() % this)theLogger.AddLogLine(L"amule-remote-gui.cpp", 1252, false, logStandard
, CFormat(L"Last reference to client %d %p unlinked, delete it."
) % ECID() % this);
}
delete this;
}
1256}

1258#else

1260void CUpDownClient::Unlink()
1261{
m_linked--;
if (!m_linked) {
delete this;
}
1266}
1267#endif


1270uint64 CUpDownClient::GetDownloadedTotal() const
1271{
return credits->GetDownloadedTotal();
1273}


1276uint64 CUpDownClient::GetUploadedTotal() const
1277{
return credits->GetUploadedTotal();
1279}


1282double CUpDownClient::GetScoreRatio() const
1283{
return credits->GetScoreRatio(GetIP(), theApp->CryptoAvailable());
1285}

1287/* End Warning */


1290CUpDownClient::~CUpDownClient()
1291{
delete credits;
1293}


1296CClientRef *CUpDownClientListRem::CreateItem(const CEC_UpDownClient_Tag *tag)
1297{
CClientRef *client = new CClientRef(tag);
ProcessItemUpdate(tag, client);
1
Calling 'CUpDownClientListRem::ProcessItemUpdate'→

return client;
1302}


1305void CUpDownClientListRem::DeleteItem(CClientRef *clientref)
1306{
CUpDownClient* client = clientref->GetClient();
if (client->m_reqfile) {
client->m_reqfile->DelSource(client);
client->m_reqfile = NULL__null;
}
Notify_SourceCtrlRemoveSource(client->ECID(), (CPartFile*) NULL)MuleNotify::DoNotify(&MuleNotify::SourceCtrlRemoveSource,
 client->ECID(), (CPartFile*) __null);

if (client->m_uploadingfile) {
client->m_uploadingfile->RemoveUploadingClient(client);	// this notifies
client->m_uploadingfile = NULL__null;
}
theApp->m_allUploadingKnownFile->RemoveUploadingClient(client);	// in case it vanished directly while uploading
Notify_SharedCtrlRemoveClient(client->ECID(), (CKnownFile*) NULL)MuleNotify::DoNotify(&MuleNotify::SharedCtrlRemoveClient,
 client->ECID(), (CKnownFile*) __null);

if (client->m_Friend) {
client->m_Friend->UnLinkClient();	// this notifies
client->m_Friend = NULL__null;
}

1326#ifdef DEBUG_ZOMBIE_CLIENTS
if (client->m_linked > 1) {
AddLogLineC(CFormat(wxT("Client %d still linked in %d places: %s")) % client->ECID() % (client->m_linked - 1) % client->GetLinkedFrom())theLogger.AddLogLine(L"amule-remote-gui.cpp", 1328, true, logStandard
, CFormat(L"Client %d still linked in %d places: %s") % client
->ECID() % (client->m_linked - 1) % client->GetLinkedFrom
());
client->m_linkedDebug = true;
}
1331#endif

delete clientref;
1334}


1337uint32 CUpDownClientListRem::GetItemID(CClientRef *client)
1338{
return client->ECID();
1340}


1343void CUpDownClientListRem::ProcessItemUpdate(
const CEC_UpDownClient_Tag *tag,
CClientRef *clientref)
1346{
if (!tag->HasChildTags()) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
return;		// speed exit for clients without any change
}
CUpDownClient *client = clientref->GetClient();

tag->UserID(&client->m_nUserIDHybrid);
tag->ClientName(&client->m_Username);
// Client Software
bool sw_updated = false;
if (tag->ClientSoftware(client->m_clientSoft)) {
4
←
Assuming the condition is false→
client->m_clientSoftString = GetSoftName(client->m_clientSoft);
sw_updated = true;
}
if (tag->SoftVerStr(client->m_clientVerString) || sw_updated5.1
'sw_updated' is false
1
'sw_updated' is false
) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
if (client->m_clientSoftString == _("Unknown")wxGetTranslation(("Unknown"))) {
	client->m_fullClientVerString = client->m_clientSoftString;
} else {
	client->m_fullClientVerString = client->m_clientSoftString + wxT(" ")L" " + client->m_clientVerString;
}
}
// User hash
tag->UserHash(&client->m_UserHash);

// User IP:Port
tag->UserIP(client->m_dwUserIP);
tag->UserPort(&client->m_nUserPort);

// Server IP:Port
tag->ServerIP(&client->m_dwServerIP);
tag->ServerPort(&client->m_nServerPort);
tag->ServerName(&client->m_ServerName);

tag->KadPort(client->m_nKadPort);
tag->FriendSlot(client->m_bFriendSlot);

tag->GetCurrentIdentState(&client->m_identState);
tag->ObfuscationStatus(client->m_obfuscationStatus);
tag->HasExtendedProtocol(&client->m_bEmuleProtocol);

tag->WaitingPosition(&client->m_waitingPosition);
tag->RemoteQueueRank(&client->m_nRemoteQueueRank);
client->m_bRemoteQueueFull = client->m_nRemoteQueueRank == 0xffff;
7
←
Assuming field 'm_nRemoteQueueRank' is not equal to 65535→
tag->OldRemoteQueueRank(&client->m_nOldRemoteQueueRank);

tag->ClientDownloadState(client->m_nDownloadState);
if (tag->ClientUploadState(client->m_nUploadState)) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
if (client->m_nUploadState == US_UPLOADING) {
	theApp->m_allUploadingKnownFile->AddUploadingClient(client);
} else {
	theApp->m_allUploadingKnownFile->RemoveUploadingClient(client);
}
}

tag->SpeedUp(&client->m_nUpDatarate);
if ( client->m_nDownloadState == DS_DOWNLOADING ) {
10
←
Assuming field 'm_nDownloadState' is not equal to DS_DOWNLOADING→
11
←
Taking false branch→
tag->SpeedDown(&client->m_kBpsDown);
} else {
client->m_kBpsDown = 0;
}

//tag->WaitTime(&client->m_WaitTime);
//tag->XferTime(&client->m_UpStartTimeDelay);
//tag->LastReqTime(&client->m_dwLastUpRequest);
//tag->QueueTime(&client->m_WaitStartTime);

CreditStruct *credit_struct = const_cast<CreditStruct *>(client->credits->GetDataStruct());
tag->XferUp(&credit_struct->uploaded);
tag->XferUpSession(&client->m_nTransferredUp);

tag->XferDown(&credit_struct->downloaded);
tag->XferDownSession(&client->m_nTransferredDown);

tag->Score(&client->m_score);

tag->NextRequestedPart(client->m_nextRequestedPart);
tag->LastDownloadingPart(client->m_lastDownloadingPart);

uint8 sourceFrom = 0;
if (tag->GetSourceFrom(sourceFrom)) {
12
←
Assuming the condition is false→
13
←
Taking false branch→
client->m_nSourceFrom = (ESourceFrom)sourceFrom;
}

tag->RemoteFilename(client->m_clientFilename);
tag->DisableViewShared(client->m_fNoViewSharedFiles);
tag->Version(client->m_nClientVersion);
tag->ModVersion(client->m_strModVersion);
tag->OSInfo(client->m_sClientOSInfo);
tag->AvailableParts(client->m_AvailPartCount);

// Download client
uint32 fileID;
bool notified = false;
if (tag->RequestFile(fileID)) {
14
←
Assuming the condition is true→
15
←
Taking true branch→
if (client->m_reqfile) {
16
←
Assuming field 'm_reqfile' is non-null→
17
←
Taking true branch→
	Notify_SourceCtrlRemoveSource(client->ECID(), client->m_reqfile)MuleNotify::DoNotify(&MuleNotify::SourceCtrlRemoveSource,
 client->ECID(), client->m_reqfile);
	client->m_reqfile->DelSource(client);
	client->m_reqfile = NULL__null;
	client->m_downPartStatus.clear();
18
←
Calling 'BitVector::clear'→
20
←
Returning from 'BitVector::clear'→
}
CKnownFile * kf = theApp->knownfiles->GetByID(fileID);
if (kf && kf->IsCPartFile()) {
21
←
Assuming 'kf' is null→
	client->m_reqfile = static_cast<CPartFile *>(kf);
	client->m_reqfile->AddSource(client);
	client->m_downPartStatus.setsize(kf->GetPartCount(), 0);
	Notify_SourceCtrlAddSource(client->m_reqfile, CCLIENTREF(client, wxT("AddSource")), A4AF_SOURCE)MuleNotify::DoNotify(&MuleNotify::SourceCtrlAddSource, client
->m_reqfile, CClientRef(client), A4AF_SOURCE);
	notified = true;
}
}

// Part status
const CECTag * partStatusTag = tag->GetTagByName(EC_TAG_CLIENT_PART_STATUS);
if (partStatusTag) {
22
←
Assuming 'partStatusTag' is non-null→
23
←
Taking true branch→
if (partStatusTag->GetTagDataLen() == 0) {
24
←
Assuming the condition is false→
25
←
Taking false branch→
	// empty tag means full source
	client->m_downPartStatus.SetAllTrue();
} else if (partStatusTag->GetTagDataLen() == client->m_downPartStatus.SizeBuffer()) {
26
←
Assuming the condition is true→
27
←
Taking true branch→
	client->m_downPartStatus.SetBuffer(partStatusTag->GetTagData());
28
←
Calling 'BitVector::SetBuffer'→
}
notified = false;
}

if (!notified && client->m_reqfile && client->m_reqfile->ShowSources()) {
SourceItemType type;
switch (client->GetDownloadState()) {
	case DS_DOWNLOADING:
	case DS_ONQUEUE:
		// We will send A4AF, which will be checked.
		type = A4AF_SOURCE;
		break;
	default:
		type = UNAVAILABLE_SOURCE;
		break;
}

Notify_SourceCtrlUpdateSource(client->ECID(), type)MuleNotify::DoNotify(&MuleNotify::SourceCtrlUpdateSource,
 client->ECID(), type);
}

// Upload client
notified = false;
if (tag->UploadFile(fileID)) {
if (client->m_uploadingfile) {
	client->m_uploadingfile->RemoveUploadingClient(client);	// this notifies
	notified = true;
	client->m_uploadingfile = NULL__null;
}
CKnownFile * kf = theApp->knownfiles->GetByID(fileID);
if (kf) {
	client->m_uploadingfile = kf;
	client->m_upPartStatus.setsize(kf->GetPartCount(), 0);
	client->m_uploadingfile->AddUploadingClient(client);	// this notifies
	notified = true;
}
}

// Part status
partStatusTag = tag->GetTagByName(EC_TAG_CLIENT_UPLOAD_PART_STATUS);
if (partStatusTag) {
if (partStatusTag->GetTagDataLen() == client->m_upPartStatus.SizeBuffer()) {
	client->m_upPartStatus.SetBuffer(partStatusTag->GetTagData());
}
notified = false;
}

if (!notified && client->m_uploadingfile
&& (client->m_uploadingfile->ShowPeers() || (client->m_nUploadState == US_UPLOADING))) {
	// notify if KnowFile is selected, or if it's uploading (in case clients are in show uploading mode)
SourceItemType type;
switch (client->GetUploadState()) {
	case US_UPLOADING:
	case US_ONUPLOADQUEUE:
		type = AVAILABLE_SOURCE;
		break;
	default:
		type = UNAVAILABLE_SOURCE;
		break;
}
Notify_SharedCtrlRefreshClient(client->ECID(), type)MuleNotify::DoNotify(&MuleNotify::SharedCtrlRefreshClient
, client->ECID(), type);
}
1525}


1528/*
* Download queue container: hold PartFiles with progress status
*
*/


1534bool CDownQueueRem::AddLink(const wxString &link, uint8 cat)
1535{
CECPacket req(EC_OP_ADD_LINK);
CECTag link_tag(EC_TAG_STRING, link);
link_tag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, cat));
req.AddTag(link_tag);

m_conn->SendPacket(&req);
return true;
1543}


1546void CDownQueueRem::ResetCatParts(int cat)
1547{
// Called when category is deleted. Command will be performed on the remote side,
// but files still should be updated here right away, or drawing errors (colour not available)
// will happen.
for (iterator it = begin(); it != end(); ++it) {
CPartFile* file = it->second;
file->RemoveCategory(cat);
}
1555}



1559void CKnownFilesRem::ProcessItemUpdatePartfile(const CEC_PartFile_Tag *tag, CPartFile *file)
1560{
//
// update status
//
tag->Speed(&file->m_kbpsDown);
file->kBpsDown = file->m_kbpsDown / 1024.0;

tag->SizeXfer(&file->transferred);
tag->SizeDone(&file->completedsize);
tag->SourceXferCount(&file->transferingsrc);
tag->SourceNotCurrCount(&file->m_notCurrentSources);
tag->SourceCount(&file->m_source_count);
tag->SourceCountA4AF(&file->m_a4af_source_count);
tag->FileStatus(&file->status);
tag->Stopped(&file->m_stopped);

tag->LastSeenComplete(&file->lastseencomplete);
tag->LastDateChanged(&file->m_lastDateChanged);
tag->DownloadActiveTime(&file->m_nDlActiveTime);
tag->AvailablePartCount(&file->m_availablePartsCount);
tag->Shared(&file->m_isShared);
tag->A4AFAuto(file->m_is_A4AF_auto);
tag->HashingProgress(file->m_hashingProgress);

tag->GetLostDueToCorruption(&file->m_iLostDueToCorruption);
tag->GetGainDueToCompression(&file->m_iGainDueToCompression);
tag->TotalPacketsSavedDueToICH(&file->m_iTotalPacketsSavedDueToICH);

tag->FileCat(&file->m_category);

tag->DownPrio(&file->m_iDownPriorityEC);
if ( file->m_iDownPriorityEC >= 10 ) {
file->m_iDownPriority = file->m_iDownPriorityEC - 10;
file->m_bAutoDownPriority = true;
} else {
file->m_iDownPriority = file->m_iDownPriorityEC;
file->m_bAutoDownPriority = false;
}

file->percentcompleted = (100.0*file->GetCompletedSize()) / file->GetFileSize();

//
// Copy part/gap status
//
const CECTag *gaptag = tag->GetTagByName(EC_TAG_PARTFILE_GAP_STATUS);
const CECTag *parttag = tag->GetTagByName(EC_TAG_PARTFILE_PART_STATUS);
const CECTag *reqtag = tag->GetTagByName(EC_TAG_PARTFILE_REQ_STATUS);
if (gaptag || parttag || reqtag) {
PartFileEncoderData &encoder = file->m_PartFileEncoderData;

if (gaptag) {
	ArrayOfUInts64 gaps;
	encoder.DecodeGaps(gaptag, gaps);
	int gap_size = gaps.size() / 2;
	// clear gaplist
	file->m_gaplist.Init(file->GetFileSize(), false);

	// and refill it
	for (int j = 0; j < gap_size; j++) {
		file->m_gaplist.AddGap(gaps[2*j], gaps[2*j+1]);
	}
}
if (parttag) {
	encoder.DecodeParts(parttag, file->m_SrcpartFrequency);
	// sanity check
	wxASSERT (file->m_SrcpartFrequency.size() == file->GetPartCount())do { if ( file->m_SrcpartFrequency.size() == file->GetPartCount
() ) { } else if ( wxTheAssertHandler && (wxOnAssert(
"amule-remote-gui.cpp", 1625, __FUNCTION__, "file->m_SrcpartFrequency.size() == file->GetPartCount()"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );
}
if (reqtag) {
	ArrayOfUInts64 reqs;
	encoder.DecodeReqs(reqtag, reqs);
	int req_size = reqs.size() / 2;
	// clear reqlist
	DeleteContents(file->m_requestedblocks_list);

	// and refill it
	for (int j = 0; j < req_size; j++) {
		Requested_Block_Struct* block = new Requested_Block_Struct;
		block->StartOffset = reqs[2*j];
		block->EndOffset   = reqs[2*j+1];
		file->m_requestedblocks_list.push_back(block);
	}
}
}

// Get source names and counts
const CECTag *srcnametag = tag->GetTagByName(EC_TAG_PARTFILE_SOURCE_NAMES);
if (srcnametag) {
SourcenameItemMap &map = file->GetSourcenameItemMap();
for (CECTag::const_iterator it = srcnametag->begin(); it != srcnametag->end(); ++it) {
	uint32 key = it->GetInt();
	int count = it->GetTagByNameSafe(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS)->GetInt();
	if (count == 0) {
		map.erase(key);
	} else {
		SourcenameItem &item = map[key];
		item.count = count;
		const CECTag *nametag = it->GetTagByName(EC_TAG_PARTFILE_SOURCE_NAMES);
		if (nametag) {
			item.name = nametag->GetStringData();
		}
	}
}
}

// Get comments
const CECTag *commenttag = tag->GetTagByName(EC_TAG_PARTFILE_COMMENTS);
if (commenttag) {
file->ClearFileRatingList();
for (CECTag::const_iterator it = commenttag->begin(); it != commenttag->end(); ) {
	wxString u = (it++)->GetStringData();
	wxString f = (it++)->GetStringData();
	int r = (it++)->GetInt();
	wxString c = (it++)->GetStringData();
	file->AddFileRatingList(u, f, r, c);
}
file->UpdateFileRatingCommentAvail();
}

// Update A4AF sources
ListOfUInts32 & clientIDs = file->GetA4AFClientIDs();
const CECTag *a4aftag = tag->GetTagByName(EC_TAG_PARTFILE_A4AF_SOURCES);
if (a4aftag) {
file->ClearA4AFList();
clientIDs.clear();
for (CECTag::const_iterator it = a4aftag->begin(); it != a4aftag->end(); ++it) {
	if (it->GetTagName() != EC_TAG_ECID) {	// should always be this
		continue;
	}
	uint32 id = it->GetInt();
	CClientRef * src = theApp->clientlist->GetByID(id);
	if (src) {
		file->AddA4AFSource(src->GetClient());
	} else {
		// client wasn't transmitted yet, try it later
		clientIDs.push_back(id);
	}
}
} else if (!clientIDs.empty()) {
// Process clients from the last pass whose ids were still unknown then
for (ListOfUInts32::iterator it = clientIDs.begin(); it != clientIDs.end(); ) {
	ListOfUInts32::iterator it1 = it++;
	uint32 id = *it1;
	CClientRef * src = theApp->clientlist->GetByID(id);
	if (src) {
		file->AddA4AFSource(src->GetClient());
		clientIDs.erase(it1);
	}
}
}

theApp->amuledlg->m_transferwnd->downloadlistctrl->UpdateItem(file);

// If file is shared check if it is already listed in shared files.
// If not, add it and show it.
if (file->IsShared() && !theApp->sharedfiles->count(file->ECID())) {
(*theApp->sharedfiles)[file->ECID()] = file;
theApp->amuledlg->m_sharedfileswnd->sharedfilesctrl->ShowFile(file);
}
1718}


1721void CDownQueueRem::SendFileCommand(CPartFile *file, ec_tagname_t cmd)
1722{
CECPacket req(cmd);
req.AddTag(CECTag(EC_TAG_PARTFILE, file->GetFileHash()));

m_conn->SendPacket(&req);
1727}


1730void CDownQueueRem::Prio(CPartFile *file, uint8 prio)
1731{
CECPacket req(EC_OP_PARTFILE_PRIO_SET);

CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO, prio));
req.AddTag(hashtag);

m_conn->SendPacket(&req);
1739}


1742void CDownQueueRem::AutoPrio(CPartFile *file, bool flag)
1743{
CECPacket req(EC_OP_PARTFILE_PRIO_SET);

CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());

hashtag.AddTag(CECTag(EC_TAG_PARTFILE_PRIO,
(uint8)(flag ? PR_AUTO5 : file->GetDownPriority())));
req.AddTag(hashtag);

m_conn->SendPacket(&req);
1753}


1756void CDownQueueRem::Category(CPartFile *file, uint8 cat)
1757{
CECPacket req(EC_OP_PARTFILE_SET_CAT);
file->SetCategory(cat);

CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, cat));
req.AddTag(hashtag);

m_conn->SendPacket(&req);
1766}


1769void CDownQueueRem::AddSearchToDownload(CSearchFile* file, uint8 category)
1770{
CECPacket req(EC_OP_DOWNLOAD_SEARCH_RESULT);
CECTag hashtag(EC_TAG_PARTFILE, file->GetFileHash());
hashtag.AddTag(CECTag(EC_TAG_PARTFILE_CAT, category));
req.AddTag(hashtag);

m_conn->SendPacket(&req);
1777}


1780void CDownQueueRem::ClearCompleted(const ListOfUInts32 & ecids)
1781{
CECPacket req(EC_OP_CLEAR_COMPLETED);
for (ListOfUInts32::const_iterator it = ecids.begin(); it != ecids.end(); ++it) {
req.AddTag(CECTag(EC_TAG_ECID, *it));
}

m_conn->SendPacket(&req);
1788}


1791/*
* List of friends.
*/
1794CFriendListRem::CFriendListRem(CRemoteConnect *conn)

1796CRemoteContainer<CFriend, uint32, CEC_Friend_Tag>(conn, true)
1797{
1798}


1801void CFriendListRem::HandlePacket(const CECPacket *)
1802{
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 1803, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );		// not needed
1804}


1807CFriend * CFriendListRem::CreateItem(const CEC_Friend_Tag * tag)
1808{
CFriend * Friend = new CFriend(tag->ID());
ProcessItemUpdate(tag, Friend);
return Friend;
1812}


1815void CFriendListRem::DeleteItem(CFriend * Friend)
1816{
Friend->UnLinkClient(false);
Notify_ChatRemoveFriend(Friend)MuleNotify::DoNotify(&MuleNotify::ChatRemoveFriend, Friend
);
1819}


1822uint32 CFriendListRem::GetItemID(CFriend * Friend)
1823{
return Friend->ECID();
1825}


1828void CFriendListRem::ProcessItemUpdate(const CEC_Friend_Tag * tag, CFriend * Friend)
1829{
if (!tag->HasChildTags()) {
return;
}
tag->Name(Friend->m_strName);
tag->UserHash(Friend->m_UserHash);
tag->IP(Friend->m_dwLastUsedIP);
tag->Port(Friend->m_nLastUsedPort);
uint32 clientID;
bool notified = false;
if (tag->Client(clientID)) {
if (clientID) {
	CClientRef * client = theApp->clientlist->GetByID(clientID);
	if (client) {
		Friend->LinkClient(*client);	// this notifies
		notified = true;
	}
} else {
	// Unlink
	Friend->UnLinkClient(false);
}
}
if (!notified) {
Notify_ChatUpdateFriend(Friend)MuleNotify::DoNotify(&MuleNotify::ChatUpdateFriend, Friend
);
}
1854}


1857void CFriendListRem::AddFriend(const CClientRef& toadd)
1858{
CECPacket req(EC_OP_FRIEND);

CECEmptyTag addtag(EC_TAG_FRIEND_ADD);
addtag.AddTag(CECTag(EC_TAG_CLIENT, toadd.ECID()));
req.AddTag(addtag);

m_conn->SendPacket(&req);
1866}


1869void CFriendListRem::AddFriend(const CMD4Hash& userhash, uint32 lastUsedIP, uint32 lastUsedPort, const wxString& name)
1870{
CECPacket req(EC_OP_FRIEND);

CECEmptyTag addtag(EC_TAG_FRIEND_ADD);
addtag.AddTag(CECTag(EC_TAG_FRIEND_HASH, userhash));
addtag.AddTag(CECTag(EC_TAG_FRIEND_IP, lastUsedIP));
addtag.AddTag(CECTag(EC_TAG_FRIEND_PORT, lastUsedPort));
addtag.AddTag(CECTag(EC_TAG_FRIEND_NAME, name));
req.AddTag(addtag);

m_conn->SendPacket(&req);
1881}


1884void CFriendListRem::RemoveFriend(CFriend* toremove)
1885{
CECPacket req(EC_OP_FRIEND);

CECEmptyTag removetag(EC_TAG_FRIEND_REMOVE);
removetag.AddTag(CECTag(EC_TAG_FRIEND, toremove->ECID()));
req.AddTag(removetag);

m_conn->SendPacket(&req);
1893}


1896void CFriendListRem::SetFriendSlot(CFriend* Friend, bool new_state)
1897{
CECPacket req(EC_OP_FRIEND);

CECTag slottag(EC_TAG_FRIEND_FRIENDSLOT, new_state);
slottag.AddTag(CECTag(EC_TAG_FRIEND, Friend->ECID()));
req.AddTag(slottag);

m_conn->SendPacket(&req);
1905}


1908void CFriendListRem::RequestSharedFileList(CFriend* Friend)
1909{
CECPacket req(EC_OP_FRIEND);

CECEmptyTag sharedtag(EC_TAG_FRIEND_SHARED);
sharedtag.AddTag(CECTag(EC_TAG_FRIEND, Friend->ECID()));
req.AddTag(sharedtag);

m_conn->SendPacket(&req);
1917}


1920void CFriendListRem::RequestSharedFileList(CClientRef& client)
1921{
CECPacket req(EC_OP_FRIEND);

CECEmptyTag sharedtag(EC_TAG_FRIEND_SHARED);
sharedtag.AddTag(CECTag(EC_TAG_CLIENT, client.ECID()));
req.AddTag(sharedtag);

m_conn->SendPacket(&req);
1929}



1933/*
* Search results
*/
1936CSearchListRem::CSearchListRem(CRemoteConnect *conn) : CRemoteContainer<CSearchFile, uint32, CEC_SearchFile_Tag>(conn, true)
1937{
m_curr_search = -1;
1939}


1942wxString CSearchListRem::StartNewSearch(
uint32* nSearchID, SearchType search_type,
const CSearchList::CSearchParams& params)
1945{
CECPacket search_req(EC_OP_SEARCH_START);
EC_SEARCH_TYPE ec_search_type = EC_SEARCH_LOCAL;
switch(search_type) {
case LocalSearch: ec_search_type = EC_SEARCH_LOCAL; break;
case GlobalSearch: ec_search_type =  EC_SEARCH_GLOBAL; break;
case KadSearch: ec_search_type =  EC_SEARCH_KAD; break;
}
search_req.AddTag(
CEC_Search_Tag(params.searchString, ec_search_type,
params.typeText, params.extension, params.availability,
params.minSize, params.maxSize));

m_conn->SendPacket(&search_req);
m_curr_search = *(nSearchID); // No kad remote search yet.

Flush();

return wxEmptyString; // EC reply will have the error mesg is needed.
1964}


1967void CSearchListRem::StopSearch(bool)
1968{
if (m_curr_search != -1) {
CECPacket search_req(EC_OP_SEARCH_STOP);
m_conn->SendPacket(&search_req);
}
1973}


1976void CSearchListRem::HandlePacket(const CECPacket *packet)
1977{
if ( packet->GetOpCode() == EC_OP_SEARCH_PROGRESS ) {
CoreNotify_Search_Update_Progress(packet->GetFirstTagSafe()->GetInt())MuleNotify::DoNotify(&MuleNotify::Search_Update_Progress,
 packet->GetFirstTagSafe()->GetInt());
} else {
CRemoteContainer<CSearchFile, uint32, CEC_SearchFile_Tag>::HandlePacket(packet);
}
1983}


1986CSearchFile::CSearchFile(const CEC_SearchFile_Tag *tag)

1988CECID(tag->ID()),
1989m_parent(NULL__null),
1990m_showChildren(false),
1991m_sourceCount(0),
1992m_completeSourceCount(0),
1993m_kademlia(false),
1994m_downloadStatus(NEW),
1995m_clientID(0),
1996m_clientPort(0),
1997m_kadPublishInfo(0)
1998{
SetFileName(CPath(tag->FileName()));
m_abyFileHash = tag->FileHash();
SetFileSize(tag->SizeFull());

m_searchID = theApp->searchlist->m_curr_search;
uint32 parentID = tag->ParentID();
if (parentID) {
CSearchFile * parent = theApp->searchlist->GetByID(parentID);
if (parent) {
	parent->AddChild(this);
}
}
2011}


2014void CSearchFile::AddChild(CSearchFile* file)
2015{
m_children.push_back(file);
file->m_parent = this;
2018}


2021// dtor is virtual - must be implemented
2022CSearchFile::~CSearchFile()
2023{
2024}


2027CSearchFile *CSearchListRem::CreateItem(const CEC_SearchFile_Tag *tag)
2028{
CSearchFile *file = new CSearchFile(tag);
ProcessItemUpdate(tag, file);

theApp->amuledlg->m_searchwnd->AddResult(file);

return file;
2035}


2038void CSearchListRem::DeleteItem(CSearchFile *file)
2039{
delete file;
2041}


2044uint32 CSearchListRem::GetItemID(CSearchFile *file)
2045{
return file->ECID();
2047}


2050void CSearchListRem::ProcessItemUpdate(const CEC_SearchFile_Tag *tag, CSearchFile *file)
2051{
uint32 sourceCount = file->m_sourceCount;
uint32 completeSourceCount = file->m_completeSourceCount;
CSearchFile::DownloadStatus status = file->m_downloadStatus;
tag->SourceCount(&file->m_sourceCount);
tag->CompleteSourceCount(&file->m_completeSourceCount);
tag->DownloadStatus((uint32 *) &file->m_downloadStatus);

if (file->m_sourceCount != sourceCount
	|| file->m_completeSourceCount != completeSourceCount
	|| file->m_downloadStatus != status) {
if (theApp->amuledlg && theApp->amuledlg->m_searchwnd) {
	theApp->amuledlg->m_searchwnd->UpdateResult(file);
}
}
2066}


2069bool CSearchListRem::Phase1Done(const CECPacket *WXUNUSED(reply))
2070{
CECPacket progress_req(EC_OP_SEARCH_PROGRESS);
m_conn->SendRequest(this, &progress_req);

return true;
2075}


2078void CSearchListRem::RemoveResults(long nSearchID)
2079{
ResultMap::iterator it = m_results.find(nSearchID);
if (it != m_results.end()) {
CSearchResultList& list = it->second;
for (unsigned int i = 0; i < list.size(); ++i) {
	delete list[i];
}
m_results.erase(it);
}
2088}


2091const CSearchResultList& CSearchListRem::GetSearchResults(long nSearchID)
2092{
ResultMap::const_iterator it = m_results.find(nSearchID);
if (it != m_results.end()) {
return it->second;
}

// TODO: Should we assert in this case?
static CSearchResultList list;
return list;
2101}


2104void CStatsUpdaterRem::HandlePacket(const CECPacket *packet)
2105{
theStats::UpdateStats(packet);
theApp->amuledlg->ShowTransferRate();
theApp->ShowUserCount(); // maybe there should be a check if a usercount changed ?
// handle the connstate tag which is included in the stats packet
theApp->serverconnect->HandlePacket(packet);
2111}


2114void CUpDownClient::RequestSharedFileList()
2115{
CClientRef ref = CCLIENTREF(this, wxEmptyString)CClientRef(this);
theApp->friendlist->RequestSharedFileList(ref);
2118}


2121bool CUpDownClient::SwapToAnotherFile(
bool WXUNUSED(bIgnoreNoNeeded),
bool WXUNUSED(ignoreSuspensions),
bool WXUNUSED(bRemoveCompletely),
CPartFile* toFile)
2126{
CECPacket req(EC_OP_CLIENT_SWAP_TO_ANOTHER_FILE);
req.AddTag(CECTag(EC_TAG_CLIENT, ECID()));
req.AddTag(CECTag(EC_TAG_PARTFILE, toFile->GetFileHash()));
theApp->m_connect->SendPacket(&req);

return true;
2133}


2136wxString CAICHHash::GetString() const
2137{
return EncodeBase32(m_abyBuffer, HASHSIZE20);
2139}


2142//
2143// Those functions are virtual. So even they don't get called they must
2144// be defined so linker will be happy
2145//
2146CPacket* CKnownFile::CreateSrcInfoPacket(const CUpDownClient *, uint8 /*byRequestedVersion*/, uint16 /*nRequestedOptions*/)
2147{
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 2148, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
return 0;
2150}


2153bool CKnownFile::LoadFromFile(const class CFileDataIO*)
2154{
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 2155, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
return false;
2157}


2160void CKnownFile::UpdatePartsInfo()
2161{
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 2162, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
2163}


2166CPacket* CPartFile::CreateSrcInfoPacket(CUpDownClient const *, uint8 /*byRequestedVersion*/, uint16 /*nRequestedOptions*/)
2167{
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 2168, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
return 0;
2170}


2173void CPartFile::UpdatePartsInfo()
2174{
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("amule-remote-gui.cpp"
, 2175, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
2176}



2180void CPartFile::UpdateFileRatingCommentAvail()
2181{
bool prevComment = m_hasComment;
int prevRating = m_iUserRating;

m_hasComment = false;
m_iUserRating = 0;
int ratingCount = 0;

FileRatingList::iterator it = m_FileRatingList.begin();
for (; it != m_FileRatingList.end(); ++it) {
SFileRating& cur_rat = *it;

if (!cur_rat.Comment.IsEmpty()) {
	m_hasComment = true;
}

uint8 rating = cur_rat.Rating;
if (rating) {
	wxASSERT(rating <= 5)do { if ( rating <= 5 ) { } else if ( wxTheAssertHandler &&
 (wxOnAssert("amule-remote-gui.cpp", 2199, __FUNCTION__, "rating <= 5"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );

	ratingCount++;
	m_iUserRating += rating;
}
}

if (ratingCount) {
m_iUserRating /= ratingCount;
wxASSERT(m_iUserRating > 0 && m_iUserRating <= 5)do { if ( m_iUserRating > 0 && m_iUserRating <=
) { } else if ( wxTheAssertHandler && (wxOnAssert(
"amule-remote-gui.cpp", 2208, __FUNCTION__, "m_iUserRating > 0 && m_iUserRating <= 5"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );
}

if ((prevComment != m_hasComment) || (prevRating != m_iUserRating)) {
UpdateDisplayedInfo();
}
2214}


2217void CStatTreeRem::DoRequery()
2218{
CECPacket request(EC_OP_GET_STATSTREE);
if (thePrefs::GetMaxClientVersions() != 0) {
request.AddTag(CECTag(EC_TAG_STATTREE_CAPPING, (uint8)thePrefs::GetMaxClientVersions()));
}
m_conn->SendRequest(this, &request);
2224}

2226void CStatTreeRem::HandlePacket(const CECPacket * p)
2227{
const CECTag* treeRoot = p->GetTagByName(EC_TAG_STATTREE_NODE);
if (treeRoot) {
theApp->amuledlg->m_statisticswnd->RebuildStatTreeRemote(treeRoot);
theApp->amuledlg->m_statisticswnd->ShowStatistics();
}
2233}

2235CamuleRemoteGuiApp *theApp;

2237//
2238// since gui is not linked with amule.cpp - define events here
2239//
2240DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_FINISHED_HTTP_DOWNLOAD)const wxEventType wxEVT_CORE_FINISHED_HTTP_DOWNLOAD = wxNewEventType
();
2241DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_SOURCE_DNS_DONE)const wxEventType wxEVT_CORE_SOURCE_DNS_DONE = wxNewEventType
();
2242DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_UDP_DNS_DONE)const wxEventType wxEVT_CORE_UDP_DNS_DONE = wxNewEventType();
2243DEFINE_LOCAL_EVENT_TYPE(wxEVT_CORE_SERVER_DNS_DONE)const wxEventType wxEVT_CORE_SERVER_DNS_DONE = wxNewEventType
();
2244// File_checked_for_headers

←

./BitVector.h

1//
2// This file is part of the aMule Project.
3//
4// Copyright (c) 2009-2011 aMule Team ( admin@amule.org / http://www.amule.org )
5// Copyright (c) 2009-2011 Stu Redman ( sturedman@amule.org )
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//

26#ifndef BITVECTOR_H
27#define BITVECTOR_H

29//
30// Packed bit vector
31//
32class BitVector {
33public:
BitVector()
{
m_bits	= 0;
m_bytes = 0;
m_allTrue = 0;
m_vector = NULL__null;
}

~BitVector() { clear();	}

// number of bits
uint32 size() const	{ return m_bits; }

// is it empty?
bool empty() const { return m_bits == 0; }

// get bit at index
bool get(uint32 idx) const
{
if (idx >= m_bits) {
	wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("./BitVector.h"
, 54, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
	return false;
}
return (m_vector[idx / 8] & s_posMask[idx & 7]) != 0;
}

// set bit at index
void set(uint32 idx, bool value)
{
if (idx >= m_bits) {
	wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("./BitVector.h"
, 64, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
	return;
}
uint32 bidx = idx / 8;
if (value) {
	m_vector[bidx] = m_vector[bidx] | s_posMask[idx & 7];
	// If it was not all true before, then we don't know now.
	if (m_allTrue == 0) {
		m_allTrue = 2;
	}
} else {
	m_vector[bidx] = m_vector[bidx] & s_negMask[idx & 7];
	m_allTrue = 0;
}
}

// set number of bits to zero and free memory
void clear()
{
m_bits	= 0;
m_bytes = 0;
m_allTrue = 0;
delete[] m_vector;
m_vector = NULL__null;
19
←
Null pointer value stored to field 'm_vector'→
}

// set number of bits and initialize them with value
void setsize(uint32 newsize, bool value)
{
if (newsize == 0) {
	clear();
	return;
}
m_bits = newsize;
m_bytes = newsize / 8;
if (newsize & 7) {
	m_bytes++;
}
delete[] m_vector;
m_vector = new uint8[m_bytes];
memset(m_vector, value ? 0xFF : 0, m_bytes);
m_allTrue = value ? 1 : 0;
}

// are all bits true ?
bool AllTrue() const
{
if (m_allTrue == 2) {
	// don't know, have to check
	bool foundFalse = false;
	uint32 lastByte = m_bytes;
	if (m_bits & 7) {
		// uneven: check bits of last byte individually
		lastByte--;
		for (uint32 i = m_bits & 0xfffffff8; !foundFalse && i < m_bits; i++) {
			foundFalse = !get(i);
		}
	}
	// check bytewise
	for (uint32 i = 0; !foundFalse && i < lastByte; i++) {
		foundFalse = m_vector[i] != 0xff;
	}
	// This is really just a caching of information,
	// so m_allTrue is mutable and AllTrue() still const.
	m_allTrue = foundFalse ? 0 : 1;
}
return m_allTrue == 1;
}

// set all bits to true
void SetAllTrue() { if (m_bytes) { memset(m_vector, 0xFF, m_bytes); } }

// handling of the internal buffer (for EC)
// get size
uint32 SizeBuffer() const { return m_bytes; }
// get buffer
const void* GetBuffer() const { return m_vector; }
// set buffer
void SetBuffer(const void* src) { memcpy(m_vector, src, m_bytes); m_allTrue = 2; }
29
←
Null pointer passed to 1st parameter expecting 'nonnull'

144private:
uint32	m_bits;			// number of bits
uint32	m_bytes;		// number of bytes in the vector
uint8 *	m_vector;		// the storage
mutable uint8 m_allTrue;// All true ? 0: no  1: yes  2: don't know
static const uint8 s_posMask[]; // = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80}; implemented in OtherFunctions.cpp
static const uint8 s_negMask[]; // = {0xFE, 0xFD, 0xFB, 0xF7, 0xEF, 0xDF, 0xBF, 0x7F};
151};

153#endif