ExternalConn.cpp

Bug Summary

File:	rootdir/src/ExternalConn.cpp
Warning:	line 1865, column 11 Using a fixed address is not portable because that address will probably not be valid in all environments or platforms

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 ExternalConn.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/include/upnp -D ENABLE_UPNP=1 -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 -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++ ExternalConn.cpp

ExternalConn.cpp

→

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

27#include "config.h"				// Needed for VERSION

29#include <ec/cpp/ECMuleSocket.h>		// Needed for CECSocket

31#include <common/Format.h>			// Needed for CFormat

33#include <common/ClientVersion.h>
34#include <common/MD5Sum.h>

36#include "ExternalConn.h"			// Interface declarations
37#include "updownclient.h"			// Needed for CUpDownClient
38#include "Server.h"				// Needed for CServer
39#include "ServerList.h"				// Needed for CServerList
40#include "PartFile.h"				// Needed for CPartFile
41#include "ServerConnect.h"			// Needed for CServerConnect
42#include "UploadQueue.h"			// Needed for CUploadQueue
43#include "amule.h"				// Needed for theApp
44#include "SearchList.h"				// Needed for GetSearchResults
45#include "ClientList.h"
46#include "Preferences.h"			// Needed for CPreferences
47#include "Logger.h"
48#include "GuiEvents.h"				// Needed for Notify_* macros
49#include "Statistics.h"				// Needed for theStats
50#include "KnownFileList.h"			// Needed for CKnownFileList
51#include "Friend.h"
52#include "FriendList.h"
53#include "RandomFunctions.h"
54#include "kademlia/kademlia/Kademlia.h"
55#include "kademlia/kademlia/UDPFirewallTester.h"
56#include "Statistics.h"


59//-------------------- File_Encoder --------------------


62/*
* Encode 'obtained parts' info to be sent to remote gui
*/
65class CKnownFile_Encoder {
// number of sources for each part for progress bar colouring
RLE_Data m_enc_data;
68protected:
const CKnownFile *m_file;
70public:
CKnownFile_Encoder(const CKnownFile *file = 0) { m_file = file; }

virtual ~CKnownFile_Encoder() {}

virtual void Encode(CECTag *parent_tag);

virtual void ResetEncoder()
{
m_enc_data.ResetEncoder();
}

virtual void SetShared() { }
virtual bool IsShared() { return true; }
virtual bool IsPartFile_Encoder() { return false; }
const CKnownFile * GetFile() { return m_file; }
86};

88/*!
* PartStatus strings and gap lists are quite long - RLE encoding will help.
*
* Instead of sending each time full part-status string, send
* RLE encoded difference from previous one.
*
* PartFileEncoderData class is used for decode only,
* while CPartFile_Encoder is used for encode only.
*/
97class CPartFile_Encoder : public CKnownFile_Encoder {
// blocks requested for download
RLE_Data m_req_status;
// gap list
RLE_Data m_gap_status;
// source names
SourcenameItemMap m_sourcenameItemMap;
// counter for unique source name ids
int m_sourcenameID;
// not all part files are shared (only when at least one part is complete)
bool m_shared;

// cast inherited member to CPartFile
const CPartFile * m_PartFile() { wxCHECK(m_file->IsCPartFile(), NULL)if ( m_file->IsCPartFile() ) {} else { do { if ( wxTheAssertHandler
 && (wxOnAssert("ExternalConn.cpp", 110, __FUNCTION__
, "\"m_file->IsCPartFile()\"", (const char*)__null), wxTrapInAssert
) ) { wxTrapInAssert = false; asm volatile ("int $3"); } } while
 ( (void)0, 0 ); return __null; } struct wxDummyCheckStruct110; return static_cast<const CPartFile *>(m_file); }
111public:
// encoder side
CPartFile_Encoder(const CPartFile *file = 0) : CKnownFile_Encoder(file)
{
m_sourcenameID = 0;
m_shared = false;
}

virtual ~CPartFile_Encoder() {}

// encode - take data from m_file
virtual void Encode(CECTag *parent_tag);

// Encoder may reset history if full info requested
virtual void ResetEncoder();

virtual void SetShared() { m_shared = true; }
virtual bool IsShared() { return m_shared; }
virtual bool IsPartFile_Encoder() { return true; }
130};

132class CFileEncoderMap : public std::map<uint32, CKnownFile_Encoder*> {
typedef std::set<uint32> IDSet;
134public:
~CFileEncoderMap();
void UpdateEncoders();
137};

139CFileEncoderMap::~CFileEncoderMap()
140{
// DeleteContents() causes infinite recursion here!
for (iterator it = begin(); it != end(); ++it) {
delete it->second;
}
145}

147// Check if encoder contains files that are no longer used
148// or if we have new files without encoder yet.
149void CFileEncoderMap::UpdateEncoders()
150{
IDSet curr_files, dead_files;
// Downloads
std::vector<CPartFile*> downloads;
theApp->downloadqueue->CopyFileList(downloads, true);
for (uint32 i = downloads.size(); i--;) {
uint32 id = downloads[i]->ECID();
curr_files.insert(id);
if (!count(id)) {
	(*this)[id] = new CPartFile_Encoder(downloads[i]);
}
}
// Shares
std::vector<CKnownFile*> shares;
theApp->sharedfiles->CopyFileList(shares);
for (uint32 i = shares.size(); i--;) {
uint32 id = shares[i]->ECID();
// Check if it is already there.
// The curr_files.count(id) is enough, the IsCPartFile() is just a speedup.
if (shares[i]->IsCPartFile() && curr_files.count(id)) {
	(*this)[id]->SetShared();
	continue;
}
curr_files.insert(id);
if (!count(id)) {
	(*this)[id] = new CKnownFile_Encoder(shares[i]);
}
}
// Check for removed files, and store them in a set for deletion.
// (std::map documentation is unclear if a construct like
//		iterator to_del = it++; erase(to_del) ;
// works or invalidates it too.)
for (iterator it = begin(); it != end(); ++it) {
if (!curr_files.count(it->first)) {
	dead_files.insert(it->first);
}
}
// then delete them
for (IDSet::iterator it = dead_files.begin(); it != dead_files.end(); ++it) {
iterator it2 = find(*it);
delete it2->second;
erase(it2);
}
193}


196//-------------------- CECServerSocket --------------------

198class CECServerSocket : public CECMuleSocket
199{
200public:
CECServerSocket(ECNotifier *notifier);
virtual ~CECServerSocket();

virtual const CECPacket *OnPacketReceived(const CECPacket *packet, uint32 trueSize);
virtual void OnLost();

virtual void WriteDoneAndQueueEmpty();

void	ResetLog() { m_LoggerAccess.Reset(); }
210private:
ECNotifier *m_ec_notifier;

const CECPacket *Authenticate(const CECPacket *);

enum {
CONN_INIT,
CONN_SALT_SENT,
CONN_ESTABLISHED,
CONN_FAILED
} m_conn_state;

uint64_t m_passwd_salt;
CLoggerAccess m_LoggerAccess;
CFileEncoderMap	m_FileEncoder;
CObjTagMap		m_obj_tagmap;
CECPacket *ProcessRequest2(const CECPacket *request);

virtual bool IsAuthorized() { return m_conn_state == CONN_ESTABLISHED; }
229};


232CECServerSocket::CECServerSocket(ECNotifier *notifier)

234CECMuleSocket(true),
235m_conn_state(CONN_INIT),
236m_passwd_salt(GetRandomUint64())
237{
wxASSERT(theApp->ECServerHandler)do { if ( theApp->ECServerHandler ) { } else if ( wxTheAssertHandler
 && (wxOnAssert("ExternalConn.cpp", 238, __FUNCTION__
, "theApp->ECServerHandler", (const char*)__null), wxTrapInAssert
) ) { wxTrapInAssert = false; asm volatile ("int $3"); } } while
 ( (void)0, 0 );
theApp->ECServerHandler->AddSocket(this);
m_ec_notifier = notifier;
241}


244CECServerSocket::~CECServerSocket()
245{
wxASSERT(theApp->ECServerHandler)do { if ( theApp->ECServerHandler ) { } else if ( wxTheAssertHandler
 && (wxOnAssert("ExternalConn.cpp", 246, __FUNCTION__
, "theApp->ECServerHandler", (const char*)__null), wxTrapInAssert
) ) { wxTrapInAssert = false; asm volatile ("int $3"); } } while
 ( (void)0, 0 );
theApp->ECServerHandler->RemoveSocket(this);
248}


251const CECPacket *CECServerSocket::OnPacketReceived(const CECPacket *packet, uint32 trueSize)
252{
packet->DebugPrint(true, trueSize);

const CECPacket *reply = NULL__null;

if (m_conn_state == CONN_FAILED) {
1
Assuming field 'm_conn_state' is not equal to CONN_FAILED→
2
←
Taking false branch→
// Client didn't close the socket when authentication failed.
AddLogLineN(_("Client sent packet after authentication failed."))theLogger.AddLogLine(L"ExternalConn.cpp", 259, false, logStandard
, wxGetTranslation(("Client sent packet after authentication failed."
)));
CloseSocket();
}

if (m_conn_state != CONN_ESTABLISHED) {
3
←
Assuming field 'm_conn_state' is not equal to CONN_ESTABLISHED→
4
←
Taking true branch→
// This is called twice:
// 1) send salt
// 2) verify password
reply = Authenticate(packet);
5
←
Calling 'CECServerSocket::Authenticate'→
} else {
reply = ProcessRequest2(packet);
}
return reply;
272}


275void CECServerSocket::OnLost()
276{
AddLogLineN(_("External connection closed."))theLogger.AddLogLine(L"ExternalConn.cpp", 277, false, logStandard
, wxGetTranslation(("External connection closed.")));
theApp->ECServerHandler->m_ec_notifier->Remove_EC_Client(this);
DestroySocket();
280}

282void CECServerSocket::WriteDoneAndQueueEmpty()
283{
if ( HaveNotificationSupport() && (m_conn_state == CONN_ESTABLISHED) ) {
CECPacket *packet = m_ec_notifier->GetNextPacket(this);
if ( packet ) {
	SendPacket(packet);
}
} else {
//printf("[EC] %p: WriteDoneAndQueueEmpty but notification disabled\n", this);
}
292}

294//-------------------- ExternalConn --------------------

296#ifndef ASIO_SOCKETS
297enum
298{	// id for sockets
SERVER_ID = 1000
300};


303BEGIN_EVENT_TABLE(ExternalConn, wxEvtHandler)const wxEventTable ExternalConn::sm_eventTable = { &wxEvtHandler
::sm_eventTable, &ExternalConn::sm_eventTableEntries[0] }
; const wxEventTable *ExternalConn::GetEventTable() const { return
 &ExternalConn::sm_eventTable; } wxEventHashTable ExternalConn
::sm_eventHashTable(ExternalConn::sm_eventTable); wxEventHashTable
 &ExternalConn::GetEventHashTable() const { return ExternalConn
::sm_eventHashTable; } const wxEventTableEntry ExternalConn::
sm_eventTableEntries[] = {
EVT_SOCKET(SERVER_ID, ExternalConn::OnServerEvent)wxEventTableEntry(wxEVT_SOCKET, SERVER_ID, wxID_ANY, wxNewEventTableFunctor
(wxEVT_SOCKET, wxEventFunctionCast(wxPrivate::DoCast<wxPrivate
::EventArgOf<wxSocketEventFunction>::type>(&ExternalConn
::OnServerEvent))), __null),
305END_EVENT_TABLE()wxEventTableEntry(wxEVT_NULL, 0, 0, __null, __null) };
306#endif


309ExternalConn::ExternalConn(amuleIPV4Address addr, wxString *msg)
310{
wxString msgLocal;
m_ECServer = NULL__null;
// Are we allowed to accept External Connections?
if ( thePrefs::AcceptExternalConnections() ) {
// We must have a valid password, otherwise we will not allow EC connections
if (thePrefs::ECPassword().IsEmpty()) {
	*msg += wxT("External connections disabled due to empty password!\n")L"External connections disabled due to empty password!\n";
	AddLogLineC(_("External connections disabled due to empty password!"))theLogger.AddLogLine(L"ExternalConn.cpp", 318, true, logStandard
, wxGetTranslation(("External connections disabled due to empty password!"
)));
	return;
}

// Create the socket
m_ECServer = new CExternalConnListener(addr, MULE_SOCKET_REUSEADDRwxSOCKET_REUSEADDR, this);
324#ifndef ASIO_SOCKETS
m_ECServer->SetEventHandler(*this, SERVER_ID);
m_ECServer->SetNotify(wxSOCKET_CONNECTION_FLAG);
327#endif
m_ECServer->Notify(true);

int port = addr.Service();
wxString ip = addr.IPAddress();
if (m_ECServer->IsOk()) {
	msgLocal = CFormat(wxT("*** TCP socket (ECServer) listening on %s:%d")L"*** TCP socket (ECServer) listening on %s:%d") % ip % port;
	*msg += msgLocal + wxT("\n")L"\n";
	AddLogLineN(msgLocal)theLogger.AddLogLine(L"ExternalConn.cpp", 335, false, logStandard
, msgLocal);
} else {
	msgLocal = CFormat(wxT("Could not listen for external connections at %s:%d!")L"Could not listen for external connections at %s:%d!") % ip % port;
	*msg += msgLocal + wxT("\n")L"\n";
	AddLogLineN(msgLocal)theLogger.AddLogLine(L"ExternalConn.cpp", 339, false, logStandard
, msgLocal);
}
} else {
*msg += wxT("External connections disabled in config file\n")L"External connections disabled in config file\n";
AddLogLineN(_("External connections disabled in config file"))theLogger.AddLogLine(L"ExternalConn.cpp", 343, false, logStandard
, wxGetTranslation(("External connections disabled in config file"
)));
}
m_ec_notifier = new ECNotifier();
346}


349ExternalConn::~ExternalConn()
350{
KillAllSockets();
delete m_ECServer;
delete m_ec_notifier;
354}


357void ExternalConn::AddSocket(CECServerSocket *s)
358{
wxASSERT(s)do { if ( s ) { } else if ( wxTheAssertHandler && (wxOnAssert
("ExternalConn.cpp", 359, __FUNCTION__, "s", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
socket_list.insert(s);
361}


364void ExternalConn::RemoveSocket(CECServerSocket *s)
365{
wxASSERT(s)do { if ( s ) { } else if ( wxTheAssertHandler && (wxOnAssert
("ExternalConn.cpp", 366, __FUNCTION__, "s", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
socket_list.erase(s);
368}


371void ExternalConn::KillAllSockets()
372{
AddDebugLogLineN(logGeneral,do {} while (false)
CFormat(wxT("ExternalConn::KillAllSockets(): %d sockets to destroy.")) %do {} while (false)
	socket_list.size())do {} while (false);
SocketSet::iterator it = socket_list.begin();
while (it != socket_list.end()) {
CECServerSocket *s = *(it++);
s->Close();
s->Destroy();
}
socket_list.clear();
383}


386void ExternalConn::ResetAllLogs()
387{
SocketSet::iterator it = socket_list.begin();
while (it != socket_list.end()) {
CECServerSocket *s = *(it++);
s->ResetLog();
}
393}


396#ifndef ASIO_SOCKETS
397void ExternalConn::OnServerEvent(wxSocketEvent& WXUNUSED(event))
398{
m_ECServer->OnAccept();
400}
401#endif


404void CExternalConnListener::OnAccept()
405{
CECServerSocket *sock = new CECServerSocket(m_conn->m_ec_notifier);
// Accept new connection if there is one in the pending
// connections queue, else exit. We use Accept(FALSE) for
// non-blocking accept (although if we got here, there
// should ALWAYS be a pending connection).
if (AcceptWith(*sock, false)) {
AddLogLineN(_("New external connection accepted"))theLogger.AddLogLine(L"ExternalConn.cpp", 412, false, logStandard
, wxGetTranslation(("New external connection accepted")));
} else {
delete sock;
AddLogLineN(_("ERROR: couldn't accept a new external connection"))theLogger.AddLogLine(L"ExternalConn.cpp", 415, false, logStandard
, wxGetTranslation(("ERROR: couldn't accept a new external connection"
)));
}

418}

420//
421// Authentication
422//
423const CECPacket *CECServerSocket::Authenticate(const CECPacket *request)
424{
CECPacket *response;

if (request5.1
'request' is not equal to NULL
1
'request' is not equal to NULL
 == NULL__null) {
6
←
Taking false branch→
return new CECPacket(EC_OP_AUTH_FAIL);
}

// Password must be specified if we are to allow remote connections
if ( thePrefs::ECPassword().IsEmpty() ) {
7
←
Assuming the condition is false→
AddLogLineC(_("External connection refused due to empty password in preferences!"))theLogger.AddLogLine(L"ExternalConn.cpp", 433, true, logStandard
, wxGetTranslation(("External connection refused due to empty password in preferences!"
)));

return new CECPacket(EC_OP_AUTH_FAIL);
}

if ((m_conn_state == CONN_INIT) && (request->GetOpCode() == EC_OP_AUTH_REQ) ) {
8
←
Assuming field 'm_conn_state' is not equal to CONN_INIT→
// cppcheck-suppress unreadVariable
const CECTag *clientName = request->GetTagByName(EC_TAG_CLIENT_NAME);
// cppcheck-suppress unreadVariable
const CECTag *clientVersion = request->GetTagByName(EC_TAG_CLIENT_VERSION);

AddLogLineN(CFormat( _("Connecting client: %s %s") )theLogger.AddLogLine(L"ExternalConn.cpp", 446, false, logStandard
, CFormat( wxGetTranslation(("Connecting client: %s %s")) ) %
 ( clientName ? clientName->GetStringData() : wxString(wxGetTranslation
(("Unknown"))) ) % ( clientVersion ? clientVersion->GetStringData
() : wxString(wxGetTranslation(("Unknown version"))) ))
	% ( clientName ? clientName->GetStringData() : wxString(_("Unknown")) )theLogger.AddLogLine(L"ExternalConn.cpp", 446, false, logStandard
, CFormat( wxGetTranslation(("Connecting client: %s %s")) ) %
 ( clientName ? clientName->GetStringData() : wxString(wxGetTranslation
(("Unknown"))) ) % ( clientVersion ? clientVersion->GetStringData
() : wxString(wxGetTranslation(("Unknown version"))) ))
	% ( clientVersion ? clientVersion->GetStringData() : wxString(_("Unknown version")) ) )theLogger.AddLogLine(L"ExternalConn.cpp", 446, false, logStandard
, CFormat( wxGetTranslation(("Connecting client: %s %s")) ) %
 ( clientName ? clientName->GetStringData() : wxString(wxGetTranslation
(("Unknown"))) ) % ( clientVersion ? clientVersion->GetStringData
() : wxString(wxGetTranslation(("Unknown version"))) ));
const CECTag *protocol = request->GetTagByName(EC_TAG_PROTOCOL_VERSION);
448#ifdef EC_VERSION_ID
// For SVN versions, both client and server must use SVNDATE, and they must be the same
CMD4Hash vhash;
if (!vhash.Decode(wxT(EC_VERSION_ID)LEC_VERSION_ID)) {
	response = new CECPacket(EC_OP_AUTH_FAIL);
	response->AddTag(CECTag(EC_TAG_STRING, wxT("Fatal error, version hash is not a valid MD4-hash.")L"Fatal error, version hash is not a valid MD4-hash."));
} else if (!request->GetTagByName(EC_TAG_VERSION_ID) || request->GetTagByNameSafe(EC_TAG_VERSION_ID)->GetMD4Data() != vhash) {
	response = new CECPacket(EC_OP_AUTH_FAIL);
	response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Incorrect EC version ID, there might be binary incompatibility. Use core and remote from same snapshot.")"Incorrect EC version ID, there might be binary incompatibility. Use core and remote from same snapshot."));
457#else
// For release versions, we don't want to allow connections from any arbitrary SVN client.
if (request->GetTagByName(EC_TAG_VERSION_ID)) {
	response = new CECPacket(EC_OP_AUTH_FAIL);
	response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("You cannot connect to a release version from an arbitrary development snapshot! *sigh* possible crash prevented")"You cannot connect to a release version from an arbitrary development snapshot! *sigh* possible crash prevented"));
462#endif
} else if (protocol != NULL__null) {
	uint16 proto_version = protocol->GetInt();
	if (proto_version == EC_CURRENT_PROTOCOL_VERSION) {
		response = new CECPacket(EC_OP_AUTH_SALT);
		response->AddTag(CECTag(EC_TAG_PASSWD_SALT, m_passwd_salt));
		m_conn_state = CONN_SALT_SENT;
		//
		// So far ok, check capabilities of client
		//
		if (request->GetTagByName(EC_TAG_CAN_ZLIB)) {
			m_my_flags |= EC_FLAG_ZLIB;
		}
		if (request->GetTagByName(EC_TAG_CAN_UTF8_NUMBERS)) {
			m_my_flags |= EC_FLAG_UTF8_NUMBERS;
		}
		m_haveNotificationSupport = request->GetTagByName(EC_TAG_CAN_NOTIFY) != NULL__null;
		AddDebugLogLineN(logEC, CFormat(wxT("Client capabilities: ZLIB: %s  UTF8 numbers: %s  Push notification: %s") )do {} while (false)
			% ((m_my_flags & EC_FLAG_ZLIB) ? wxT("yes") : wxT("no"))do {} while (false)
			% ((m_my_flags & EC_FLAG_UTF8_NUMBERS) ? wxT("yes") : wxT("no"))do {} while (false)
			% (m_haveNotificationSupport ? wxT("yes") : wxT("no")))do {} while (false);
	} else {
		response = new CECPacket(EC_OP_AUTH_FAIL);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid protocol version.")"Invalid protocol version."
			+ CFormat(wxT("( %#.4x != %#.4x )")L"( %#.4x != %#.4x )") % proto_version % (uint16_t)EC_CURRENT_PROTOCOL_VERSION));
	}
} else {
	response = new CECPacket(EC_OP_AUTH_FAIL);
	response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Missing protocol version tag.")"Missing protocol version tag."));
}
} else if ((m_conn_state == CONN_SALT_SENT) && (request->GetOpCode() == EC_OP_AUTH_PASSWD)) {
9
←
Assuming field 'm_conn_state' is not equal to CONN_SALT_SENT→
const CECTag *passwd = request->GetTagByName(EC_TAG_PASSWD_HASH);
CMD4Hash passh;

if (!passh.Decode(thePrefs::ECPassword())) {
	wxString err = wxTRANSLATE("Authentication failed: invalid hash specified as EC password.")"Authentication failed: invalid hash specified as EC password.";
	AddLogLineN(wxString(wxGetTranslation(err))theLogger.AddLogLine(L"ExternalConn.cpp", 499, false, logStandard
, wxString(wxGetTranslation(err)) + L" " + thePrefs::ECPassword
())
				+ wxT(" ") + thePrefs::ECPassword())theLogger.AddLogLine(L"ExternalConn.cpp", 499, false, logStandard
, wxString(wxGetTranslation(err)) + L" " + thePrefs::ECPassword
());
	response = new CECPacket(EC_OP_AUTH_FAIL);
	response->AddTag(CECTag(EC_TAG_STRING, err));
} else {
	wxString saltHash = MD5Sum(CFormat(wxT("%lX")L"%lX") % m_passwd_salt).GetHash();
	wxString saltStr = CFormat(wxT("%lX")L"%lX") % m_passwd_salt;

	passh.Decode(MD5Sum(thePrefs::ECPassword().Lower() + saltHash).GetHash());

	if (passwd && passwd->GetMD4Data() == passh) {
		response = new CECPacket(EC_OP_AUTH_OK);
		response->AddTag(CECTag(EC_TAG_SERVER_VERSION, wxT(VERSION)L"SVN"));
	} else {
		wxString err;
		if (passwd) {
			err = wxTRANSLATE("Authentication failed: wrong password.")"Authentication failed: wrong password.";
		} else {
			err = wxTRANSLATE("Authentication failed: missing password.")"Authentication failed: missing password.";
		}

		response = new CECPacket(EC_OP_AUTH_FAIL);
		response->AddTag(CECTag(EC_TAG_STRING, err));
		AddLogLineN(wxGetTranslation(err))theLogger.AddLogLine(L"ExternalConn.cpp", 521, false, logStandard
, wxGetTranslation(err));
	}
}
} else {
response = new CECPacket(EC_OP_AUTH_FAIL);
response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid request, please authenticate first.")"Invalid request, please authenticate first."));
}

if (response->GetOpCode() == EC_OP_AUTH_OK) {
10
←
Assuming the condition is true→
11
←
Taking true branch→
m_conn_state = CONN_ESTABLISHED;
AddLogLineN(_("Access granted."))theLogger.AddLogLine(L"ExternalConn.cpp", 531, false, logStandard
, wxGetTranslation(("Access granted.")));
// Establish notification handler if client supports it
if (HaveNotificationSupport()) {
12
←
Assuming the condition is true→
13
←
Taking true branch→
	theApp->ECServerHandler->m_ec_notifier->Add_EC_Client(this);
14
←
Calling 'ECNotifier::Add_EC_Client'→
}
} else if (response->GetOpCode() == EC_OP_AUTH_FAIL) {
// Log message sent to client
if (response->GetFirstTagSafe()->IsString()) {
	AddLogLineN(CFormat(_("Sent error message \"%s\" to client.")) % wxGetTranslation(response->GetFirstTagSafe()->GetStringData()))theLogger.AddLogLine(L"ExternalConn.cpp", 539, false, logStandard
, CFormat(wxGetTranslation(("Sent error message \"%s\" to client."
))) % wxGetTranslation(response->GetFirstTagSafe()->GetStringData
()));
}
// Access denied!
AddLogLineN(CFormat(_("Unauthorized access attempt from %s. Connection closed.")) % GetPeer() )theLogger.AddLogLine(L"ExternalConn.cpp", 542, false, logStandard
, CFormat(wxGetTranslation(("Unauthorized access attempt from %s. Connection closed."
))) % GetPeer());
m_conn_state = CONN_FAILED;
}

return response;
547}

549// Make a Logger tag (if there are any logging messages) and add it to the response
550static void AddLoggerTag(CECPacket *response, CLoggerAccess &LoggerAccess)
551{
if (LoggerAccess.HasString()) {
CECEmptyTag tag(EC_TAG_STATS_LOGGER_MESSAGE);
// Tag structure is fix: tag carries nothing, inside are the strings
// maximum of 200 log lines per message
int entries = 0;
wxString line;
while (entries < 200 && LoggerAccess.GetString(line)) {
	tag.AddTag(CECTag(EC_TAG_STRING, line));
	entries++;
}
response->AddTag(tag);
//printf("send Log tag %d %d\n", FirstEntry, entries);
}
565}

567static CECPacket *Get_EC_Response_StatRequest(const CECPacket *request, CLoggerAccess &LoggerAccess)
568{
CECPacket *response = new CECPacket(EC_OP_STATS);

switch (request->GetDetailLevel()) {
case EC_DETAIL_FULL:
// This is not an actual INC_UPDATE.
// amulegui only sets the detail level of the stats package to EC_DETAIL_INC_UPDATE
// so that the included conn state tag is created the way it is needed here.
case EC_DETAIL_INC_UPDATE:
	response->AddTag(CECTag(EC_TAG_STATS_UP_OVERHEAD, (uint32)theStats::GetUpOverheadRate()));
	response->AddTag(CECTag(EC_TAG_STATS_DOWN_OVERHEAD, (uint32)theStats::GetDownOverheadRate()));
	response->AddTag(CECTag(EC_TAG_STATS_BANNED_COUNT, /*(uint32)*/theStats::GetBannedCount()));
	AddLoggerTag(response, LoggerAccess);
	// Needed only for the remote tray icon context menu
	response->AddTag(CECTag(EC_TAG_STATS_TOTAL_SENT_BYTES, theStats::GetTotalSentBytes()));
	response->AddTag(CECTag(EC_TAG_STATS_TOTAL_RECEIVED_BYTES, theStats::GetTotalReceivedBytes()));
	response->AddTag(CECTag(EC_TAG_STATS_SHARED_FILE_COUNT, theStats::GetSharedFileCount()));
/* fall through */
case EC_DETAIL_WEB:
case EC_DETAIL_CMD:
	response->AddTag(CECTag(EC_TAG_STATS_UL_SPEED, (uint32)theStats::GetUploadRate()));
	response->AddTag(CECTag(EC_TAG_STATS_DL_SPEED, (uint32)(theStats::GetDownloadRate())));
	response->AddTag(CECTag(EC_TAG_STATS_UL_SPEED_LIMIT, (uint32)(thePrefs::GetMaxUpload()*1024.0)));
	response->AddTag(CECTag(EC_TAG_STATS_DL_SPEED_LIMIT, (uint32)(thePrefs::GetMaxDownload()*1024.0)));
	response->AddTag(CECTag(EC_TAG_STATS_UL_QUEUE_LEN, /*(uint32)*/theStats::GetWaitingUserCount()));
	response->AddTag(CECTag(EC_TAG_STATS_TOTAL_SRC_COUNT, /*(uint32)*/theStats::GetFoundSources()));
	// User/Filecounts
	{
		uint32 totaluser = 0, totalfile = 0;
		theApp->serverlist->GetUserFileStatus( totaluser, totalfile );
		response->AddTag(CECTag(EC_TAG_STATS_ED2K_USERS, totaluser));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_USERS, Kademlia::CKademlia::GetKademliaUsers()));
		response->AddTag(CECTag(EC_TAG_STATS_ED2K_FILES, totalfile));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_FILES, Kademlia::CKademlia::GetKademliaFiles()));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_NODES, CStatistics::GetKadNodes()));
	}
	// Kad stats
	if (Kademlia::CKademlia::IsConnected()) {
		response->AddTag(CECTag(EC_TAG_STATS_KAD_FIREWALLED_UDP, Kademlia::CUDPFirewallTester::IsFirewalledUDP(true)));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_SOURCES, Kademlia::CKademlia::GetIndexed()->m_totalIndexSource));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_KEYWORDS, Kademlia::CKademlia::GetIndexed()->m_totalIndexKeyword));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_NOTES, Kademlia::CKademlia::GetIndexed()->m_totalIndexNotes));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_LOAD, Kademlia::CKademlia::GetIndexed()->m_totalIndexLoad));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_IP_ADRESS, wxUINT32_SWAP_ALWAYS(Kademlia::CKademlia::GetPrefs()->GetIPAddress())((wxUint32) ( (((wxUint32) (Kademlia::CKademlia::GetPrefs()->
GetIPAddress()) & (wxUint32) 0x000000ffU) << 24) | (
((wxUint32) (Kademlia::CKademlia::GetPrefs()->GetIPAddress
()) & (wxUint32) 0x0000ff00U) << 8) | (((wxUint32) (
Kademlia::CKademlia::GetPrefs()->GetIPAddress()) & (wxUint32
) 0x00ff0000U) >> 8) | (((wxUint32) (Kademlia::CKademlia
::GetPrefs()->GetIPAddress()) & (wxUint32) 0xff000000U
) >> 24)))));
		response->AddTag(CECTag(EC_TAG_STATS_KAD_IN_LAN_MODE, Kademlia::CKademlia::IsRunningInLANMode()));
		response->AddTag(CECTag(EC_TAG_STATS_BUDDY_STATUS, theApp->clientlist->GetBuddyStatus()));
		uint32 BuddyIP = 0;
		uint16 BuddyPort = 0;
		CUpDownClient * Buddy = theApp->clientlist->GetBuddy();
		if (Buddy) {
			BuddyIP = Buddy->GetIP();
			BuddyPort = Buddy->GetUDPPort();
		}
		response->AddTag(CECTag(EC_TAG_STATS_BUDDY_IP, BuddyIP));
		response->AddTag(CECTag(EC_TAG_STATS_BUDDY_PORT, BuddyPort));
	}
case EC_DETAIL_UPDATE:
	break;
};

return response;
629}

631static CECPacket *Get_EC_Response_GetSharedFiles(const CECPacket *request, CFileEncoderMap &encoders)
632{
wxASSERT(request->GetOpCode() == EC_OP_GET_SHARED_FILES)do { if ( request->GetOpCode() == EC_OP_GET_SHARED_FILES )
 { } else if ( wxTheAssertHandler && (wxOnAssert("ExternalConn.cpp"
, 633, __FUNCTION__, "request->GetOpCode() == EC_OP_GET_SHARED_FILES"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );

CECPacket *response = new CECPacket(EC_OP_SHARED_FILES);

EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
//
// request can contain list of queried items
CTagSet<uint32, EC_TAG_KNOWNFILE> queryitems(request);

encoders.UpdateEncoders();

for (uint32 i = 0; i < theApp->sharedfiles->GetFileCount(); ++i) {
const CKnownFile *cur_file = theApp->sharedfiles->GetFileByIndex(i);

if ( !cur_file || (!queryitems.empty() && !queryitems.count(cur_file->ECID())) ) {
	continue;
}

CEC_SharedFile_Tag filetag(cur_file, detail_level);
CKnownFile_Encoder *enc = encoders[cur_file->ECID()];
if ( detail_level != EC_DETAIL_UPDATE ) {
	enc->ResetEncoder();
}
enc->Encode(&filetag);
response->AddTag(filetag);
}
return response;
660}

662static CECPacket *Get_EC_Response_GetUpdate(CFileEncoderMap &encoders, CObjTagMap &tagmap)
663{
CECPacket *response = new CECPacket(EC_OP_SHARED_FILES);

encoders.UpdateEncoders();
for (CFileEncoderMap::iterator it = encoders.begin(); it != encoders.end(); ++it) {
const CKnownFile *cur_file = it->second->GetFile();
CValueMap &valuemap = tagmap.GetValueMap(cur_file->ECID());
// Completed cleared Partfiles are still stored as CPartfile,
// but encoded as KnownFile, so we have to check the encoder type
// instead of the file type.
if (it->second->IsPartFile_Encoder()) {
	CEC_PartFile_Tag filetag(static_cast<const CPartFile*>(cur_file), EC_DETAIL_INC_UPDATE, &valuemap);
	// Add information if partfile is shared
	filetag.AddTag(EC_TAG_PARTFILE_SHARED, it->second->IsShared(), &valuemap);

	CPartFile_Encoder * enc = static_cast<CPartFile_Encoder *>(encoders[cur_file->ECID()]);
	enc->Encode(&filetag);
	response->AddTag(filetag);
} else {
	CEC_SharedFile_Tag filetag(cur_file, EC_DETAIL_INC_UPDATE, &valuemap);
	CKnownFile_Encoder * enc = encoders[cur_file->ECID()];
	enc->Encode(&filetag);
	response->AddTag(filetag);
}
}

// Add clients
CECEmptyTag clients(EC_TAG_CLIENT);
const CClientList::IDMap& clientList = theApp->clientlist->GetClientList();
bool onlyTransmittingClients = thePrefs::IsTransmitOnlyUploadingClients();
for (CClientList::IDMap::const_iterator it = clientList.begin(); it != clientList.end(); ++it) {
const CUpDownClient* cur_client = it->second.GetClient();
if (onlyTransmittingClients && !cur_client->IsDownloading()) {
	// For poor CPU cores only transmit uploading clients. This will save a lot of CPU.
	// Set ExternalConnect/TransmitOnlyUploadingClients to 1 for it.
	continue;
}
CValueMap &valuemap = tagmap.GetValueMap(cur_client->ECID());
clients.AddTag(CEC_UpDownClient_Tag(cur_client, EC_DETAIL_INC_UPDATE, &valuemap));
}
response->AddTag(clients);

// Add servers
CECEmptyTag servers(EC_TAG_SERVER);
std::vector<const CServer*> serverlist = theApp->serverlist->CopySnapshot();
uint32 nrServers = serverlist.size();
for (uint32 i = 0; i < nrServers; i++) {
const CServer* cur_server = serverlist[i];
CValueMap &valuemap = tagmap.GetValueMap(cur_server->ECID());
servers.AddTag(CEC_Server_Tag(cur_server, &valuemap));
}
response->AddTag(servers);

// Add friends
CECEmptyTag friends(EC_TAG_FRIEND);
for (CFriendList::const_iterator it = theApp->friendlist->begin(); it != theApp->friendlist->end(); ++it) {
const CFriend* cur_friend = *it;
CValueMap &valuemap = tagmap.GetValueMap(cur_friend->ECID());
friends.AddTag(CEC_Friend_Tag(cur_friend, &valuemap));
}
response->AddTag(friends);

return response;
726}

728static CECPacket *Get_EC_Response_GetClientQueue(const CECPacket *request, CObjTagMap &tagmap, int op)
729{
CECPacket *response = new CECPacket(op);

EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();

//
// request can contain list of queried items
// (not for incremental update of course)
CTagSet<uint32, EC_TAG_CLIENT> queryitems(request);

const CClientRefList& clients = theApp->uploadqueue->GetUploadingList();
CClientRefList::const_iterator it = clients.begin();
for (; it != clients.end(); ++it) {
CUpDownClient* cur_client = it->GetClient();

if (!cur_client) {	// shouldn't happen
	continue;
}
if (!queryitems.empty() && !queryitems.count(cur_client->ECID())) {
	continue;
}
CValueMap *valuemap = NULL__null;
if (detail_level == EC_DETAIL_INC_UPDATE) {
	valuemap = &tagmap.GetValueMap(cur_client->ECID());
}
CEC_UpDownClient_Tag cli_tag(cur_client, detail_level, valuemap);

response->AddTag(cli_tag);
}

return response;
760}


763static CECPacket *Get_EC_Response_GetDownloadQueue(const CECPacket *request, CFileEncoderMap &encoders)
764{
CECPacket *response = new CECPacket(EC_OP_DLOAD_QUEUE);

EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
//
// request can contain list of queried items
CTagSet<uint32, EC_TAG_PARTFILE> queryitems(request);

encoders.UpdateEncoders();

for (unsigned int i = 0; i < theApp->downloadqueue->GetFileCount(); i++) {
CPartFile *cur_file = theApp->downloadqueue->GetFileByIndex(i);

if ( !queryitems.empty() && !queryitems.count(cur_file->ECID()) ) {
	continue;
}

CEC_PartFile_Tag filetag(cur_file, detail_level);

CPartFile_Encoder * enc = static_cast<CPartFile_Encoder *>(encoders[cur_file->ECID()]);
if ( detail_level != EC_DETAIL_UPDATE ) {
	enc->ResetEncoder();
}
enc->Encode(&filetag);

response->AddTag(filetag);
}
return response;
792}


795static CECPacket *Get_EC_Response_PartFile_Cmd(const CECPacket *request)
796{
CECPacket *response = NULL__null;

// request can contain multiple files.
for (CECPacket::const_iterator it1 = request->begin(); it1 != request->end(); ++it1) {
const CECTag &hashtag = *it1;

wxASSERT(hashtag.GetTagName() == EC_TAG_PARTFILE)do { if ( hashtag.GetTagName() == EC_TAG_PARTFILE ) { } else if
 ( wxTheAssertHandler && (wxOnAssert("ExternalConn.cpp"
, 803, __FUNCTION__, "hashtag.GetTagName() == EC_TAG_PARTFILE"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );

CMD4Hash hash = hashtag.GetMD4Data();
CPartFile *pfile = theApp->downloadqueue->GetFileByID( hash );

if ( !pfile ) {
	AddLogLineN(CFormat(_("Remote PartFile command failed: FileHash not found: %s")) % hash.Encode())theLogger.AddLogLine(L"ExternalConn.cpp", 809, false, logStandard
, CFormat(wxGetTranslation(("Remote PartFile command failed: FileHash not found: %s"
))) % hash.Encode());
	response = new CECPacket(EC_OP_FAILED);
	response->AddTag(CECTag(EC_TAG_STRING, CFormat(wxString(wxTRANSLATE("FileHash not found: %s")"FileHash not found: %s")) % hash.Encode()));
	//return response;
	break;
}
switch (request->GetOpCode()) {
	case EC_OP_PARTFILE_SWAP_A4AF_THIS:
		CoreNotify_PartFile_Swap_A4AF(pfile)MuleNotify::DoNotify(&MuleNotify::PartFile_Swap_A4AF, pfile
);
		break;
	case EC_OP_PARTFILE_SWAP_A4AF_THIS_AUTO:
		CoreNotify_PartFile_Swap_A4AF_Auto(pfile)MuleNotify::DoNotify(&MuleNotify::PartFile_Swap_A4AF_Auto
, pfile);
		break;
	case EC_OP_PARTFILE_SWAP_A4AF_OTHERS:
		CoreNotify_PartFile_Swap_A4AF_Others(pfile)MuleNotify::DoNotify(&MuleNotify::PartFile_Swap_A4AF_Others
, pfile);
		break;
	case EC_OP_PARTFILE_PAUSE:
		pfile->PauseFile();
		break;
	case EC_OP_PARTFILE_RESUME:
		pfile->ResumeFile();
		pfile->SavePartFile();
		break;
	case EC_OP_PARTFILE_STOP:
		pfile->StopFile();
		break;
	case EC_OP_PARTFILE_PRIO_SET: {
			uint8 prio = hashtag.GetFirstTagSafe()->GetInt();
			if ( prio == PR_AUTO5 ) {
				pfile->SetAutoDownPriority(1);
			} else {
				pfile->SetAutoDownPriority(0);
				pfile->SetDownPriority(prio);
			}
		}
		break;
	case EC_OP_PARTFILE_DELETE:
		if ( thePrefs::StartNextFile() && (pfile->GetStatus() != PS_PAUSED7) ) {
			theApp->downloadqueue->StartNextFile(pfile);
		}
		pfile->Delete();
		break;

	case EC_OP_PARTFILE_SET_CAT:
		pfile->SetCategory(hashtag.GetFirstTagSafe()->GetInt());
		break;

	default:
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("OOPS! OpCode processing error!")"OOPS! OpCode processing error!"));
		break;
}
}
if (!response) {
response = new CECPacket(EC_OP_NOOP);
}
return response;
866}

868static CECPacket *Get_EC_Response_Server_Add(const CECPacket *request)
869{
CECPacket *response = NULL__null;

wxString full_addr = request->GetTagByNameSafe(EC_TAG_SERVER_ADDRESS)->GetStringData();
wxString name = request->GetTagByNameSafe(EC_TAG_SERVER_NAME)->GetStringData();

wxString s_ip = full_addr.Left(full_addr.Find(':'));
wxString s_port = full_addr.Mid(full_addr.Find(':') + 1);

long port = StrToULong(s_port);
CServer* toadd = new CServer(port, s_ip);
toadd->SetListName(name.IsEmpty() ? full_addr : name);

if ( theApp->AddServer(toadd, true) ) {
response = new CECPacket(EC_OP_NOOP);
} else {
response = new CECPacket(EC_OP_FAILED);
response->AddTag(CECTag(EC_TAG_STRING, _("Server not added")wxGetTranslation(("Server not added"))));
delete toadd;
}

return response;
891}

893static CECPacket *Get_EC_Response_Server(const CECPacket *request)
894{
CECPacket *response = NULL__null;
const CECTag *srv_tag = request->GetTagByName(EC_TAG_SERVER);
CServer *srv = 0;
if ( srv_tag ) {
srv = theApp->serverlist->GetServerByIPTCP(srv_tag->GetIPv4Data().IP(), srv_tag->GetIPv4Data().m_port);
// server tag passed, but server not found
if ( !srv ) {
	response = new CECPacket(EC_OP_FAILED);
	response->AddTag(CECTag(EC_TAG_STRING,
				CFormat(wxString(wxTRANSLATE("server not found: %s")"server not found: %s")) % srv_tag->GetIPv4Data().StringIP()));
	return response;
}
}
switch (request->GetOpCode()) {
case EC_OP_SERVER_DISCONNECT:
	theApp->serverconnect->Disconnect();
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_SERVER_REMOVE:
	if ( srv ) {
		theApp->serverlist->RemoveServer(srv);
		response = new CECPacket(EC_OP_NOOP);
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING,
					wxTRANSLATE("need to define server to be removed")"need to define server to be removed"));
	}
	break;
case EC_OP_SERVER_CONNECT:
	if (thePrefs::GetNetworkED2K()) {
		if ( srv ) {
			theApp->serverconnect->ConnectToServer(srv);
			response = new CECPacket(EC_OP_NOOP);
		} else {
			theApp->serverconnect->ConnectToAnyServer();
			response = new CECPacket(EC_OP_NOOP);
		}
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("eD2k is disabled in preferences.")"eD2k is disabled in preferences."));
	}
	break;
}
if (!response) {
response = new CECPacket(EC_OP_FAILED);
response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("OOPS! OpCode processing error!")"OOPS! OpCode processing error!"));
}
return response;
943}


946static CECPacket *Get_EC_Response_Friend(const CECPacket *request)
947{
CECPacket *response = NULL__null;
const CECTag *tag = request->GetTagByName(EC_TAG_FRIEND_ADD);
if (tag) {
const CECTag *subtag = tag->GetTagByName(EC_TAG_CLIENT);
if (subtag) {
	CUpDownClient * client = theApp->clientlist->FindClientByECID(subtag->GetInt());
	if (client) {
		theApp->friendlist->AddFriend(CCLIENTREF(client, wxT("Get_EC_Response_Friend theApp->friendlist->AddFriend"))CClientRef(client));
		response = new CECPacket(EC_OP_NOOP);
	}
} else {
	const CECTag *hashtag	= tag->GetTagByName(EC_TAG_FRIEND_HASH);
	const CECTag *iptag		= tag->GetTagByName(EC_TAG_FRIEND_IP);
	const CECTag *porttag	= tag->GetTagByName(EC_TAG_FRIEND_PORT);
	const CECTag *nametag	= tag->GetTagByName(EC_TAG_FRIEND_NAME);
	if (hashtag && iptag && porttag && nametag) {
		theApp->friendlist->AddFriend(hashtag->GetMD4Data(), iptag->GetInt(), porttag->GetInt(), nametag->GetStringData());
		response = new CECPacket(EC_OP_NOOP);
	}
}
} else if ((tag = request->GetTagByName(EC_TAG_FRIEND_REMOVE))) {
const CECTag *subtag = tag->GetTagByName(EC_TAG_FRIEND);
if (subtag) {
	CFriend * Friend = theApp->friendlist->FindFriend(subtag->GetInt());
	if (Friend) {
		theApp->friendlist->RemoveFriend(Friend);
		response = new CECPacket(EC_OP_NOOP);
	}
}
} else if ((tag = request->GetTagByName(EC_TAG_FRIEND_FRIENDSLOT))) {
const CECTag *subtag = tag->GetTagByName(EC_TAG_FRIEND);
if (subtag) {
	CFriend * Friend = theApp->friendlist->FindFriend(subtag->GetInt());
	if (Friend) {
		theApp->friendlist->SetFriendSlot(Friend, tag->GetInt() != 0);
		response = new CECPacket(EC_OP_NOOP);
	}
}
} else if ((tag = request->GetTagByName(EC_TAG_FRIEND_SHARED))) {
response = new CECPacket(EC_OP_FAILED);
response->AddTag(CECTag(EC_TAG_STRING, wxT("Request shared files list not implemented yet.")L"Request shared files list not implemented yet."));
989#if 0
// This works fine - but there is no way atm to transfer the results to amulegui, so disable it for now.

const CECTag *subtag = tag->GetTagByName(EC_TAG_FRIEND);
if (subtag) {
	CFriend * Friend = theApp->friendlist->FindFriend(subtag->GetInt());
	if (Friend) {
		theApp->friendlist->RequestSharedFileList(Friend);
		response = new CECPacket(EC_OP_NOOP);
	}
} else if ((subtag = tag->GetTagByName(EC_TAG_CLIENT))) {
	CUpDownClient * client = theApp->clientlist->FindClientByECID(subtag->GetInt());
	if (client) {
		client->RequestSharedFileList();
		response = new CECPacket(EC_OP_NOOP);
	}
}
1006#endif
}

if (!response) {
response = new CECPacket(EC_OP_FAILED);
response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("OOPS! OpCode processing error!")"OOPS! OpCode processing error!"));
}
return response;
1014}


1017static CECPacket *Get_EC_Response_Search_Results(const CECPacket *request)
1018{
CECPacket *response = new CECPacket(EC_OP_SEARCH_RESULTS);

EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
//
// request can contain list of queried items
CTagSet<uint32, EC_TAG_SEARCHFILE> queryitems(request);

const CSearchResultList& list = theApp->searchlist->GetSearchResults(0xffffffff);
CSearchResultList::const_iterator it = list.begin();
while (it != list.end()) {
CSearchFile* sf = *it++;
if ( !queryitems.empty() && !queryitems.count(sf->ECID()) ) {
	continue;
}
response->AddTag(CEC_SearchFile_Tag(sf, detail_level));
}
return response;
1036}

1038static CECPacket *Get_EC_Response_Search_Results(CObjTagMap &tagmap)
1039{
CECPacket *response = new CECPacket(EC_OP_SEARCH_RESULTS);

const CSearchResultList& list = theApp->searchlist->GetSearchResults(0xffffffff);
CSearchResultList::const_iterator it = list.begin();
while (it != list.end()) {
CSearchFile* sf = *it++;
CValueMap &valuemap = tagmap.GetValueMap(sf->ECID());
response->AddTag(CEC_SearchFile_Tag(sf, EC_DETAIL_INC_UPDATE, &valuemap));
// Add the children
if (sf->HasChildren()) {
	const CSearchResultList& children = sf->GetChildren();
	for (size_t i = 0; i < children.size(); ++i) {
		CSearchFile* sfc = children.at(i);
		CValueMap &valuemap1 = tagmap.GetValueMap(sfc->ECID());
		response->AddTag(CEC_SearchFile_Tag(sfc, EC_DETAIL_INC_UPDATE, &valuemap1));
	}
}
}
return response;
1059}

1061static CECPacket *Get_EC_Response_Search_Results_Download(const CECPacket *request)
1062{
CECPacket *response = new CECPacket(EC_OP_STRINGS);
for (CECPacket::const_iterator it = request->begin(); it != request->end(); ++it) {
const CECTag &tag = *it;
CMD4Hash hash = tag.GetMD4Data();
uint8 category = tag.GetFirstTagSafe()->GetInt();
theApp->searchlist->AddFileToDownloadByHash(hash, category);
}
return response;
1071}

1073static CECPacket *Get_EC_Response_Search_Stop(const CECPacket *WXUNUSED(request))
1074{
CECPacket *reply = new CECPacket(EC_OP_MISC_DATA);
theApp->searchlist->StopSearch();
return reply;
1078}

1080static CECPacket *Get_EC_Response_Search(const CECPacket *request)
1081{
wxString response;

const CEC_Search_Tag *search_request = static_cast<const CEC_Search_Tag *>(request->GetFirstTagSafe());
theApp->searchlist->RemoveResults(0xffffffff);

CSearchList::CSearchParams params;
params.searchString	= search_request->SearchText();
params.typeText		= search_request->SearchFileType();
params.extension	= search_request->SearchExt();
params.minSize		= search_request->MinSize();
params.maxSize		= search_request->MaxSize();
params.availability	= search_request->Avail();


EC_SEARCH_TYPE search_type = search_request->SearchType();
SearchType core_search_type = LocalSearch;
uint32 op = EC_OP_FAILED;
switch (search_type) {
case EC_SEARCH_GLOBAL:
	core_search_type = GlobalSearch;
/* fall through */
case EC_SEARCH_KAD:
	if (core_search_type != GlobalSearch) { // Not a global search obviously
		core_search_type = KadSearch;
	}
/* fall through */
case EC_SEARCH_LOCAL: {
	uint32 search_id = 0xffffffff;
	wxString error = theApp->searchlist->StartNewSearch(&search_id, core_search_type, params);
	if (!error.IsEmpty()) {
		response = error;
	} else {
		response = wxTRANSLATE("Search in progress. Refetch results in a moment!")"Search in progress. Refetch results in a moment!";
		op = EC_OP_STRINGS;
	}
	break;
}
case EC_SEARCH_WEB:
		response = wxTRANSLATE("WebSearch from remote interface makes no sense.")"WebSearch from remote interface makes no sense.";
	break;
}

CECPacket *reply = new CECPacket(op);
// error or search in progress
reply->AddTag(CECTag(EC_TAG_STRING, response));

return reply;
1129}

1131static CECPacket *Get_EC_Response_Set_SharedFile_Prio(const CECPacket *request)
1132{
CECPacket *response = new CECPacket(EC_OP_NOOP);
for (CECPacket::const_iterator it = request->begin(); it != request->end(); ++it) {
const CECTag &tag = *it;
CMD4Hash hash = tag.GetMD4Data();
uint8 prio = tag.GetFirstTagSafe()->GetInt();
CKnownFile* cur_file = theApp->sharedfiles->GetFileByID(hash);
if ( !cur_file ) {
	continue;
}
if (prio == PR_AUTO5) {
	cur_file->SetAutoUpPriority(1);
	cur_file->UpdateAutoUpPriority();
} else {
	cur_file->SetAutoUpPriority(0);
	cur_file->SetUpPriority(prio);
}
Notify_SharedFilesUpdateItem(cur_file)MuleNotify::DoNotify(&MuleNotify::SharedFilesUpdateItem, cur_file
);
}

return response;
1153}

1155void CPartFile_Encoder::Encode(CECTag *parent)
1156{
//
// Source part frequencies
//
CKnownFile_Encoder::Encode(parent);

//
// Gaps
//
const CGapList& gaplist = m_PartFile()->GetGapList();
const size_t gap_list_size = gaplist.size();
ArrayOfUInts64 gaps;
gaps.reserve(gap_list_size * 2);

for (CGapList::const_iterator curr_pos = gaplist.begin();
	curr_pos != gaplist.end(); ++curr_pos) {
gaps.push_back(curr_pos.start());
gaps.push_back(curr_pos.end());
}

int gap_enc_size = 0;
bool changed;
const uint8 *gap_enc_data = m_gap_status.Encode(gaps, gap_enc_size, changed);
if (changed) {
parent->AddTag(CECTag(EC_TAG_PARTFILE_GAP_STATUS, gap_enc_size, (void *)gap_enc_data));
}
delete[] gap_enc_data;

//
// Requested blocks
//
ArrayOfUInts64 req_buffer;
const CPartFile::CReqBlockPtrList& requestedblocks = m_PartFile()->GetRequestedBlockList();
CPartFile::CReqBlockPtrList::const_iterator curr_pos2 = requestedblocks.begin();

for ( ; curr_pos2 != requestedblocks.end(); ++curr_pos2 ) {
Requested_Block_Struct* block = *curr_pos2;
req_buffer.push_back(block->StartOffset);
req_buffer.push_back(block->EndOffset);
}
int req_enc_size = 0;
const uint8 *req_enc_data = m_req_status.Encode(req_buffer, req_enc_size, changed);
if (changed) {
parent->AddTag(CECTag(EC_TAG_PARTFILE_REQ_STATUS, req_enc_size, (void *)req_enc_data));
}
delete[] req_enc_data;

//
// Source names
//
// First count occurrence of all source names
//
CECEmptyTag sourceNames(EC_TAG_PARTFILE_SOURCE_NAMES);
typedef std::map<wxString, int> strIntMap;
strIntMap nameMap;
const CPartFile::SourceSet &sources = m_PartFile()->GetSourceList();
for (CPartFile::SourceSet::const_iterator it = sources.begin(); it != sources.end(); ++it) {
const CClientRef &cur_src = *it;
if (cur_src.GetRequestFile() != m_file || cur_src.GetClientFilename().Length() == 0) {
	continue;
}
const wxString &name = cur_src.GetClientFilename();
strIntMap::iterator itm = nameMap.find(name);
if (itm == nameMap.end()) {
	nameMap[name] = 1;
} else {
	itm->second++;
}
}
//
// Go through our last list
//
for (SourcenameItemMap::iterator it1 = m_sourcenameItemMap.begin(); it1 != m_sourcenameItemMap.end();) {
SourcenameItemMap::iterator it2 = it1++;
strIntMap::iterator itm = nameMap.find(it2->second.name);
if (itm == nameMap.end()) {
	// name doesn't exist anymore, tell client to forget it
	CECTag tag(EC_TAG_PARTFILE_SOURCE_NAMES, it2->first);
	tag.AddTag(CECIntTag(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS, 0));
	sourceNames.AddTag(tag);
	// and forget it
	m_sourcenameItemMap.erase(it2);
} else {
	// update count if it changed
	if (it2->second.count != itm->second) {
		CECTag tag(EC_TAG_PARTFILE_SOURCE_NAMES, it2->first);
		tag.AddTag(CECIntTag(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS, itm->second));
		sourceNames.AddTag(tag);
		it2->second.count = itm->second;
	}
	// remove it from nameMap so that only new names are left there
	nameMap.erase(itm);
}
}
//
// Add new names
//
for (strIntMap::iterator it3 = nameMap.begin(); it3 != nameMap.end(); ++it3) {
int id = ++m_sourcenameID;
CECIntTag tag(EC_TAG_PARTFILE_SOURCE_NAMES, id);
tag.AddTag(CECTag(EC_TAG_PARTFILE_SOURCE_NAMES, it3->first));
tag.AddTag(CECIntTag(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS, it3->second));
sourceNames.AddTag(tag);
// remember it
m_sourcenameItemMap[id] = SourcenameItem(it3->first, it3->second);
}
if (sourceNames.HasChildTags()) {
parent->AddTag(sourceNames);
}

1266}

1268void CPartFile_Encoder::ResetEncoder()
1269{
CKnownFile_Encoder::ResetEncoder();
m_gap_status.ResetEncoder();
m_req_status.ResetEncoder();
1273}

1275void CKnownFile_Encoder::Encode(CECTag *parent)
1276{
//
// Source part frequencies
//
// Reference to the availability list
const ArrayOfUInts16& list = m_file->IsPartFile() ?
static_cast<const CPartFile*>(m_file)->m_SrcpartFrequency :
m_file->m_AvailPartFrequency;
// Don't add tag if available parts aren't populated yet.
if (!list.empty()) {
int part_enc_size;
bool changed;
const uint8 *part_enc_data = m_enc_data.Encode(list, part_enc_size, changed);
if (changed) {
	parent->AddTag(CECTag(EC_TAG_PARTFILE_PART_STATUS, part_enc_size, part_enc_data));
}
delete[] part_enc_data;
}
1294}

1296static CECPacket *GetStatsGraphs(const CECPacket *request)
1297{
CECPacket *response = NULL__null;

switch (request->GetDetailLevel()) {
case EC_DETAIL_WEB:
case EC_DETAIL_FULL: {
	double dTimestamp = 0.0;
	if (request->GetTagByName(EC_TAG_STATSGRAPH_LAST) != NULL__null) {
		dTimestamp = request->GetTagByName(EC_TAG_STATSGRAPH_LAST)->GetDoubleData();
	}
	uint16 nScale = request->GetTagByNameSafe(EC_TAG_STATSGRAPH_SCALE)->GetInt();
	uint16 nMaxPoints = request->GetTagByNameSafe(EC_TAG_STATSGRAPH_WIDTH)->GetInt();
	uint32 *graphData;
	unsigned int numPoints = theApp->m_statistics->GetHistoryForWeb(nMaxPoints, (double)nScale, &dTimestamp, &graphData);
	if (numPoints) {
		response = new CECPacket(EC_OP_STATSGRAPHS);
		response->AddTag(CECTag(EC_TAG_STATSGRAPH_DATA, 4 * numPoints * sizeof(uint32), graphData));
		delete [] graphData;
		response->AddTag(CECTag(EC_TAG_STATSGRAPH_LAST, dTimestamp));
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("No points for graph.")"No points for graph."));
	}
	break;
}
case EC_DETAIL_INC_UPDATE:
case EC_DETAIL_UPDATE:
case EC_DETAIL_CMD:
	// No graphs
	response = new CECPacket(EC_OP_FAILED);
	response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Your client is not configured for this detail level.")"Your client is not configured for this detail level."));
	break;
}
if (!response) {
response = new CECPacket(EC_OP_FAILED);
// Unknown reason
}

return response;
1336}

1338CECPacket *CECServerSocket::ProcessRequest2(const CECPacket *request)
1339{

if ( !request ) {
return 0;
}

CECPacket *response = NULL__null;

switch (request->GetOpCode()) {
//
// Misc commands
//
case EC_OP_SHUTDOWN:
	if (!theApp->IsOnShutDown()) {
		response = new CECPacket(EC_OP_NOOP);
		AddLogLineC(_("External Connection: shutdown requested"))theLogger.AddLogLine(L"ExternalConn.cpp", 1354, true, logStandard
, wxGetTranslation(("External Connection: shutdown requested"
)));
1355#ifndef AMULE_DAEMON
		{
			wxCloseEvent evt;
			evt.SetCanVeto(false);
			theApp->ShutDown(evt);
		}
1361#else
		theApp->ExitMainLoop();
1363#endif
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Already shutting down.")"Already shutting down."));
	}
	break;
case EC_OP_ADD_LINK:
	for (CECPacket::const_iterator it = request->begin(); it != request->end(); ++it) {
		const CECTag &tag = *it;
		wxString link = tag.GetStringData();
		int category = 0;
		const CECTag *cattag = tag.GetTagByName(EC_TAG_PARTFILE_CAT);
		if (cattag) {
			category = cattag->GetInt();
		}
		AddLogLineC(CFormat(_("ExternalConn: adding link '%s'.")) % link)theLogger.AddLogLine(L"ExternalConn.cpp", 1378, true, logStandard
, CFormat(wxGetTranslation(("ExternalConn: adding link '%s'."
))) % link);
		if (response) {
			delete response;
		}
		if ( theApp->downloadqueue->AddLink(link, category) ) {
			response = new CECPacket(EC_OP_NOOP);
		} else {
			// Error messages are printed by the add function.
			response = new CECPacket(EC_OP_FAILED);
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid link or already on list.")"Invalid link or already on list."));
		}
	}
	break;
//
// Status requests
//
case EC_OP_STAT_REQ:
	response = Get_EC_Response_StatRequest(request, m_LoggerAccess);
	response->AddTag(CEC_ConnState_Tag(request->GetDetailLevel()));
	break;
case EC_OP_GET_CONNSTATE:
	response = new CECPacket(EC_OP_MISC_DATA);
	response->AddTag(CEC_ConnState_Tag(request->GetDetailLevel()));
	break;
//
//
//
case EC_OP_GET_SHARED_FILES:
	if ( request->GetDetailLevel() != EC_DETAIL_INC_UPDATE ) {
		response = Get_EC_Response_GetSharedFiles(request, m_FileEncoder);
	}
	break;
case EC_OP_GET_DLOAD_QUEUE:
	if ( request->GetDetailLevel() != EC_DETAIL_INC_UPDATE ) {
		response = Get_EC_Response_GetDownloadQueue(request, m_FileEncoder);
	}
	break;
//
// This will evolve into an update-all for inc tags
//
case EC_OP_GET_UPDATE:
	if ( request->GetDetailLevel() == EC_DETAIL_INC_UPDATE ) {
		response = Get_EC_Response_GetUpdate(m_FileEncoder, m_obj_tagmap);
	}
	break;
case EC_OP_GET_ULOAD_QUEUE:
	response = Get_EC_Response_GetClientQueue(request, m_obj_tagmap, EC_OP_ULOAD_QUEUE);
	break;
case EC_OP_PARTFILE_SWAP_A4AF_THIS:
case EC_OP_PARTFILE_SWAP_A4AF_THIS_AUTO:
case EC_OP_PARTFILE_SWAP_A4AF_OTHERS:
case EC_OP_PARTFILE_PAUSE:
case EC_OP_PARTFILE_RESUME:
case EC_OP_PARTFILE_STOP:
case EC_OP_PARTFILE_PRIO_SET:
case EC_OP_PARTFILE_DELETE:
case EC_OP_PARTFILE_SET_CAT:
	response = Get_EC_Response_PartFile_Cmd(request);
	break;
case EC_OP_SHAREDFILES_RELOAD:
	theApp->sharedfiles->Reload();
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_SHARED_SET_PRIO:
	response = Get_EC_Response_Set_SharedFile_Prio(request);
	break;
case EC_OP_RENAME_FILE: {
	CMD4Hash fileHash = request->GetTagByNameSafe(EC_TAG_KNOWNFILE)->GetMD4Data();
	wxString newName = request->GetTagByNameSafe(EC_TAG_PARTFILE_NAME)->GetStringData();
	// search first in downloadqueue - it might be in known files as well
	CKnownFile* file = theApp->downloadqueue->GetFileByID(fileHash);
	if (!file) {
		file = theApp->knownfiles->FindKnownFileByID(fileHash);
	}
	if (!file) {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("File not found.")"File not found."));
		break;
	}
	if (newName.IsEmpty()) {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid file name.")"Invalid file name."));
		break;
	}

	if (theApp->sharedfiles->RenameFile(file, CPath(newName))) {
		response = new CECPacket(EC_OP_NOOP);
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Unable to rename file.")"Unable to rename file."));
	}

	break;
}
case EC_OP_CLEAR_COMPLETED: {
	ListOfUInts32 toClear;
	for (CECTag::const_iterator it = request->begin(); it != request->end(); ++it) {
		if (it->GetTagName() == EC_TAG_ECID) {
			toClear.push_back(it->GetInt());
		}
	}
	theApp->downloadqueue->ClearCompleted(toClear);
	response = new CECPacket(EC_OP_NOOP);
	break;
}
case EC_OP_CLIENT_SWAP_TO_ANOTHER_FILE: {
	theApp->sharedfiles->Reload();
	uint32 idClient = request->GetTagByNameSafe(EC_TAG_CLIENT)->GetInt();
	CUpDownClient * client = theApp->clientlist->FindClientByECID(idClient);
	CMD4Hash idFile = request->GetTagByNameSafe(EC_TAG_PARTFILE)->GetMD4Data();
	CPartFile * file = theApp->downloadqueue->GetFileByID(idFile);
	if (client && file) {
		client->SwapToAnotherFile( true, false, false, file);
	}
	response = new CECPacket(EC_OP_NOOP);
	break;
}
case EC_OP_SHARED_FILE_SET_COMMENT: {
	CMD4Hash hash = request->GetTagByNameSafe(EC_TAG_KNOWNFILE)->GetMD4Data();
	CKnownFile * file = theApp->sharedfiles->GetFileByID(hash);
	if (file) {
		wxString newComment = request->GetTagByNameSafe(EC_TAG_KNOWNFILE_COMMENT)->GetStringData();
		uint8 newRating = request->GetTagByNameSafe(EC_TAG_KNOWNFILE_RATING)->GetInt();
		CoreNotify_KnownFile_Comment_Set(file, newComment, newRating)MuleNotify::DoNotify(&MuleNotify::KnownFile_Comment_Set, file
, newComment, newRating);
	}
	response = new CECPacket(EC_OP_NOOP);
	break;
}

//
// Server commands
//
case EC_OP_SERVER_ADD:
	response = Get_EC_Response_Server_Add(request);
	break;
case EC_OP_SERVER_DISCONNECT:
case EC_OP_SERVER_CONNECT:
case EC_OP_SERVER_REMOVE:
	response = Get_EC_Response_Server(request);
	break;
case EC_OP_GET_SERVER_LIST: {
		response = new CECPacket(EC_OP_SERVER_LIST);
		if (!thePrefs::GetNetworkED2K()) {
			// Kad only: just send an empty list
			break;
		}
		EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
		std::vector<const CServer*> servers = theApp->serverlist->CopySnapshot();
		for (
			std::vector<const CServer*>::const_iterator it = servers.begin();
			it != servers.end();
			++it
			) {
			response->AddTag(CEC_Server_Tag(*it, detail_level));
		}
	}
	break;
case EC_OP_SERVER_UPDATE_FROM_URL: {
	wxString url = request->GetFirstTagSafe()->GetStringData();

	// Save the new url, and update the UI (if not amuled).
	Notify_ServersURLChanged(url)MuleNotify::DoNotify(&MuleNotify::ServersURLChanged, url);
	thePrefs::SetEd2kServersUrl(url);

	theApp->serverlist->UpdateServerMetFromURL(url);
	response = new CECPacket(EC_OP_NOOP);
	break;
}
case EC_OP_SERVER_SET_STATIC_PRIO: {
	uint32 ecid = request->GetTagByNameSafe(EC_TAG_SERVER)->GetInt();
	CServer * server = theApp->serverlist->GetServerByECID(ecid);
	if (server) {
		const CECTag * staticTag = request->GetTagByName(EC_TAG_SERVER_STATIC);
		if (staticTag) {
			theApp->serverlist->SetStaticServer(server, staticTag->GetInt() > 0);
		}
		const CECTag * prioTag = request->GetTagByName(EC_TAG_SERVER_PRIO);
		if (prioTag) {
			theApp->serverlist->SetServerPrio(server, prioTag->GetInt());
		}
	}
	response = new CECPacket(EC_OP_NOOP);
	break;
}
//
// Friends
//
case EC_OP_FRIEND:
	response = Get_EC_Response_Friend(request);
	break;

//
// IPFilter
//
case EC_OP_IPFILTER_RELOAD:
	NotifyAlways_IPFilter_Reload()MuleNotify::DoNotifyAlways(&MuleNotify::IPFilter_Reload);
	response = new CECPacket(EC_OP_NOOP);
	break;

case EC_OP_IPFILTER_UPDATE: {
	wxString url = request->GetFirstTagSafe()->GetStringData();
	if (url.IsEmpty()) {
		url = thePrefs::IPFilterURL();
	}
	NotifyAlways_IPFilter_Update(url)MuleNotify::DoNotifyAlways(&MuleNotify::IPFilter_Update, url
);
	response = new CECPacket(EC_OP_NOOP);
	break;
}
//
// Search
//
case EC_OP_SEARCH_START:
	response = Get_EC_Response_Search(request);
	break;

case EC_OP_SEARCH_STOP:
	response = Get_EC_Response_Search_Stop(request);
	break;

case EC_OP_SEARCH_RESULTS:
	if ( request->GetDetailLevel() == EC_DETAIL_INC_UPDATE ) {
		response = Get_EC_Response_Search_Results(m_obj_tagmap);
	} else {
		response = Get_EC_Response_Search_Results(request);
	}
	break;

case EC_OP_SEARCH_PROGRESS:
	response = new CECPacket(EC_OP_SEARCH_PROGRESS);
	response->AddTag(CECTag(EC_TAG_SEARCH_STATUS,
		theApp->searchlist->GetSearchProgress()));
	break;

case EC_OP_DOWNLOAD_SEARCH_RESULT:
	response = Get_EC_Response_Search_Results_Download(request);
	break;
//
// Preferences
//
case EC_OP_GET_PREFERENCES:
	response = new CEC_Prefs_Packet(request->GetTagByNameSafe(EC_TAG_SELECT_PREFS)->GetInt(), request->GetDetailLevel());
	break;
case EC_OP_SET_PREFERENCES:
	static_cast<const CEC_Prefs_Packet *>(request)->Apply();
	theApp->glob_prefs->Save();
	if (thePrefs::IsFilteringClients()) {
		theApp->clientlist->FilterQueues();
	}
	if (thePrefs::IsFilteringServers()) {
		theApp->serverlist->FilterServers();
	}
	if (!thePrefs::GetNetworkED2K() && theApp->IsConnectedED2K()) {
		theApp->DisconnectED2K();
	}
	if (!thePrefs::GetNetworkKademlia() && theApp->IsConnectedKad()) {
		theApp->StopKad();
	}
	response = new CECPacket(EC_OP_NOOP);
	break;

case EC_OP_CREATE_CATEGORY:
	if ( request->GetTagCount() == 1 ) {
		CEC_Category_Tag tag(*static_cast<const CEC_Category_Tag*>(request->GetFirstTagSafe()));
		if (tag.Create()) {
			response = new CECPacket(EC_OP_NOOP);
		} else {
			response = new CECPacket(EC_OP_FAILED);
			response->AddTag(CECTag(EC_TAG_CATEGORY, theApp->glob_prefs->GetCatCount() - 1));
			response->AddTag(CECTag(EC_TAG_CATEGORY_PATH, tag.Path()));
		}
		Notify_CategoryAdded()MuleNotify::DoNotify(&MuleNotify::CategoryAdded);
	} else {
		response = new CECPacket(EC_OP_NOOP);
	}
	break;
case EC_OP_UPDATE_CATEGORY:
	if ( request->GetTagCount() == 1 ) {
		CEC_Category_Tag tag(*static_cast<const CEC_Category_Tag*>(request->GetFirstTagSafe()));
		if (tag.Apply()) {
			response = new CECPacket(EC_OP_NOOP);
		} else {
			response = new CECPacket(EC_OP_FAILED);
			response->AddTag(CECTag(EC_TAG_CATEGORY, tag.GetInt()));
			response->AddTag(CECTag(EC_TAG_CATEGORY_PATH, tag.Path()));
		}
		Notify_CategoryUpdate(tag.GetInt())MuleNotify::DoNotify(&MuleNotify::CategoryUpdate, tag.GetInt
());
	} else {
		response = new CECPacket(EC_OP_NOOP);
	}
	break;
case EC_OP_DELETE_CATEGORY:
	if ( request->GetTagCount() == 1 ) {
		uint32 cat = request->GetFirstTagSafe()->GetInt();
		// this does not only update the gui, but actually deletes the cat
		Notify_CategoryDelete(cat)MuleNotify::DoNotify(&MuleNotify::CategoryDelete, cat);
	}
	response = new CECPacket(EC_OP_NOOP);
	break;

//
// Logging
//
case EC_OP_ADDLOGLINE:
	// cppcheck-suppress duplicateBranch
	if (request->GetTagByName(EC_TAG_LOG_TO_STATUS) != NULL__null) {
		AddLogLineC(request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData())theLogger.AddLogLine(L"ExternalConn.cpp", 1683, true, logStandard
, request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData
());
	} else {
		AddLogLineN(request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData())theLogger.AddLogLine(L"ExternalConn.cpp", 1685, false, logStandard
, request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData
());
	}
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_ADDDEBUGLOGLINE:
	// cppcheck-suppress duplicateBranch
	if (request->GetTagByName(EC_TAG_LOG_TO_STATUS) != NULL__null) {
		AddDebugLogLineC(logGeneral, request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData())theLogger.AddLogLine(L"ExternalConn.cpp", 1692, true, logGeneral
, request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData
());
	} else {
		AddDebugLogLineN(logGeneral, request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData())do {} while (false);
	}
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_GET_LOG:
	response = new CECPacket(EC_OP_LOG);
	response->AddTag(CECTag(EC_TAG_STRING, theApp->GetLog(false)));
	break;
case EC_OP_GET_DEBUGLOG:
	response = new CECPacket(EC_OP_DEBUGLOG);
	response->AddTag(CECTag(EC_TAG_STRING, theApp->GetDebugLog(false)));
	break;
case EC_OP_RESET_LOG:
	theApp->GetLog(true);
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_RESET_DEBUGLOG:
	theApp->GetDebugLog(true);
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_GET_LAST_LOG_ENTRY:
	{
		wxString tmp = theApp->GetLog(false);
		if (tmp.Last() == '\n') {
			tmp.RemoveLast();
		}
		response = new CECPacket(EC_OP_LOG);
		response->AddTag(CECTag(EC_TAG_STRING, tmp.AfterLast('\n')));
	}
	break;
case EC_OP_GET_SERVERINFO:
	response = new CECPacket(EC_OP_SERVERINFO);
	response->AddTag(CECTag(EC_TAG_STRING, theApp->GetServerLog(false)));
	break;
case EC_OP_CLEAR_SERVERINFO:
	theApp->GetServerLog(true);
	response = new CECPacket(EC_OP_NOOP);
	break;
//
// Statistics
//
case EC_OP_GET_STATSGRAPHS:
	response = GetStatsGraphs(request);
	break;
case EC_OP_GET_STATSTREE: {
	theApp->m_statistics->UpdateStatsTree();
	response = new CECPacket(EC_OP_STATSTREE);
	CECTag* tree = theStats::GetECStatTree(request->GetTagByNameSafe(EC_TAG_STATTREE_CAPPING)->GetInt());
	if (tree) {
		response->AddTag(*tree);
		delete tree;
	}
	if (request->GetDetailLevel() == EC_DETAIL_WEB) {
		response->AddTag(CECTag(EC_TAG_SERVER_VERSION, wxT(VERSION)L"SVN"));
		response->AddTag(CECTag(EC_TAG_USER_NICK, thePrefs::GetUserNick()));
	}
	break;
}

//
// Kad
//
case EC_OP_KAD_START:
	if (thePrefs::GetNetworkKademlia()) {
		response = new CECPacket(EC_OP_NOOP);
		if ( !Kademlia::CKademlia::IsRunning() ) {
			Kademlia::CKademlia::Start();
			theApp->ShowConnectionState();
		}
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Kad is disabled in preferences.")"Kad is disabled in preferences."));
	}
	break;
case EC_OP_KAD_STOP:
	theApp->StopKad();
	theApp->ShowConnectionState();
	response = new CECPacket(EC_OP_NOOP);
	break;
case EC_OP_KAD_UPDATE_FROM_URL: {
	wxString url = request->GetFirstTagSafe()->GetStringData();

	// Save the new url, and update the UI (if not amuled).
	Notify_NodesURLChanged(url)MuleNotify::DoNotify(&MuleNotify::NodesURLChanged, url);
	thePrefs::SetKadNodesUrl(url);

	theApp->UpdateNotesDat(url);
	response = new CECPacket(EC_OP_NOOP);
	break;
}
case EC_OP_KAD_BOOTSTRAP_FROM_IP:
	if (thePrefs::GetNetworkKademlia()) {
		theApp->BootstrapKad(request->GetTagByNameSafe(EC_TAG_BOOTSTRAP_IP)->GetInt(),
							 request->GetTagByNameSafe(EC_TAG_BOOTSTRAP_PORT)->GetInt());
		theApp->ShowConnectionState();
		response = new CECPacket(EC_OP_NOOP);
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Kad is disabled in preferences.")"Kad is disabled in preferences."));
	}
	break;

//
// Networks
// These requests are currently used only in the text client
//
case EC_OP_CONNECT:
	if (thePrefs::GetNetworkED2K()) {
		response = new CECPacket(EC_OP_STRINGS);
		if (theApp->IsConnectedED2K()) {
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Already connected to eD2k.")"Already connected to eD2k."));
		} else {
			theApp->serverconnect->ConnectToAnyServer();
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Connecting to eD2k...")"Connecting to eD2k..."));
		}
	}
	if (thePrefs::GetNetworkKademlia()) {
		if (!response) {
			response = new CECPacket(EC_OP_STRINGS);
		}
		if (theApp->IsConnectedKad()) {
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Already connected to Kad.")"Already connected to Kad."));
		} else {
			theApp->StartKad();
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Connecting to Kad...")"Connecting to Kad..."));
		}
	}
	if (response) {
		theApp->ShowConnectionState();
	} else {
		response = new CECPacket(EC_OP_FAILED);
		response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("All networks are disabled.")"All networks are disabled."));
	}
	break;
case EC_OP_DISCONNECT:
	if (theApp->IsConnected()) {
		response = new CECPacket(EC_OP_STRINGS);
		if (theApp->IsConnectedED2K()) {
			theApp->serverconnect->Disconnect();
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Disconnected from eD2k.")"Disconnected from eD2k."));
		}
		if (theApp->IsConnectedKad()) {
			theApp->StopKad();
			response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Disconnected from Kad.")"Disconnected from Kad."));
		}
		theApp->ShowConnectionState();
	} else {
		response = new CECPacket(EC_OP_NOOP);
	}
	break;
}
if (!response) {
AddLogLineN(CFormat(_("External Connection: invalid opcode received: %#x")) % request->GetOpCode())theLogger.AddLogLine(L"ExternalConn.cpp", 1846, false, logStandard
, CFormat(wxGetTranslation(("External Connection: invalid opcode received: %#x"
))) % request->GetOpCode());
wxFAILdo { if ( wxTheAssertHandler && (wxOnAssert("ExternalConn.cpp"
, 1847, __FUNCTION__, "\"Assert failure\"", (const char*)__null
), wxTrapInAssert) ) { wxTrapInAssert = false; asm volatile (
"int $3"); } } while ( (void)0, 0 );
response = new CECPacket(EC_OP_FAILED);
response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid opcode (wrong protocol version?)")"Invalid opcode (wrong protocol version?)"));
}
return response;
1852}

1854/*
* Here notification-based EC. Notification will be sorted by priority for possible throttling.
*/

1858/*
* Core general status
*/
1861ECStatusMsgSource::ECStatusMsgSource()
1862{
m_last_ed2k_status_sent = 0xffffffff;
m_last_kad_status_sent = 0xffffffff;
m_server = (void *)0xffffffff;
16
←
Using a fixed address is not portable because that address will probably not be valid in all environments or platforms
1866}

1868uint32 ECStatusMsgSource::GetEd2kStatus()
1869{
if ( theApp->IsConnectedED2K() ) {
return theApp->GetED2KID();
} else if ( theApp->serverconnect->IsConnecting() ) {
return 1;
} else {
return 0;
}
1877}

1879uint32 ECStatusMsgSource::GetKadStatus()
1880{
if ( theApp->IsConnectedKad() ) {
return 1;
} else if ( Kademlia::CKademlia::IsFirewalled() ) {
return 2;
} else if ( Kademlia::CKademlia::IsRunning() ) {
return 3;
}
return 0;
1889}

1891CECPacket *ECStatusMsgSource::GetNextPacket()
1892{
if ( (m_last_ed2k_status_sent != GetEd2kStatus()) ||
(m_last_kad_status_sent != GetKadStatus()) ||
(m_server != theApp->serverconnect->GetCurrentServer()) ) {

m_last_ed2k_status_sent = GetEd2kStatus();
m_last_kad_status_sent = GetKadStatus();
m_server = theApp->serverconnect->GetCurrentServer();

CECPacket *response = new CECPacket(EC_OP_STATS);
response->AddTag(CEC_ConnState_Tag(EC_DETAIL_UPDATE));
return response;
}
return 0;
1906}

1908/*
* Downloading files
1910*/
1911ECPartFileMsgSource::ECPartFileMsgSource()
1912{
for (unsigned int i = 0; i < theApp->downloadqueue->GetFileCount(); i++) {
CPartFile *cur_file = theApp->downloadqueue->GetFileByIndex(i);
PARTFILE_STATUS status = { true, false, false, false, true, cur_file };
m_dirty_status[cur_file->GetFileHash()] = status;
}
1918}

1920void ECPartFileMsgSource::SetDirty(const CPartFile *file)
1921{
CMD4Hash filehash = file->GetFileHash();
if ( m_dirty_status.find(filehash) != m_dirty_status.end() ) {
m_dirty_status[filehash].m_dirty = true;;
}
1926}

1928void ECPartFileMsgSource::SetNew(const CPartFile *file)
1929{
CMD4Hash filehash = file->GetFileHash();
wxASSERT ( m_dirty_status.find(filehash) == m_dirty_status.end() )do { if ( m_dirty_status.find(filehash) == m_dirty_status.end
() ) { } else if ( wxTheAssertHandler && (wxOnAssert(
"ExternalConn.cpp", 1931, __FUNCTION__, "m_dirty_status.find(filehash) == m_dirty_status.end()"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );
PARTFILE_STATUS status = { true, false, false, false, true, file };
m_dirty_status[filehash] = status;
1934}

1936void ECPartFileMsgSource::SetCompleted(const CPartFile *file)
1937{
CMD4Hash filehash = file->GetFileHash();
wxASSERT ( m_dirty_status.find(filehash) != m_dirty_status.end() )do { if ( m_dirty_status.find(filehash) != m_dirty_status.end
() ) { } else if ( wxTheAssertHandler && (wxOnAssert(
"ExternalConn.cpp", 1939, __FUNCTION__, "m_dirty_status.find(filehash) != m_dirty_status.end()"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );

m_dirty_status[filehash].m_finished = true;
1942}

1944void ECPartFileMsgSource::SetRemoved(const CPartFile *file)
1945{
CMD4Hash filehash = file->GetFileHash();
wxASSERT ( m_dirty_status.find(filehash) != m_dirty_status.end() )do { if ( m_dirty_status.find(filehash) != m_dirty_status.end
() ) { } else if ( wxTheAssertHandler && (wxOnAssert(
"ExternalConn.cpp", 1947, __FUNCTION__, "m_dirty_status.find(filehash) != m_dirty_status.end()"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );

m_dirty_status[filehash].m_removed = true;
1950}

1952CECPacket *ECPartFileMsgSource::GetNextPacket()
1953{
for(std::map<CMD4Hash, PARTFILE_STATUS>::iterator it = m_dirty_status.begin();
it != m_dirty_status.end(); it++) {
if ( it->second.m_new || it->second.m_dirty || it->second.m_removed) {
	CMD4Hash filehash = it->first;

	const CPartFile *partfile = it->second.m_file;

	CECPacket *packet = new CECPacket(EC_OP_DLOAD_QUEUE);
	if ( it->second.m_removed ) {
		CECTag tag(EC_TAG_PARTFILE, filehash);
		packet->AddTag(tag);
		m_dirty_status.erase(it);
	} else {
		CEC_PartFile_Tag tag(partfile, it->second.m_new ? EC_DETAIL_FULL : EC_DETAIL_UPDATE);
		packet->AddTag(tag);
	}
	m_dirty_status[filehash].m_new = false;
	m_dirty_status[filehash].m_dirty = false;

	return packet;
}
}
return 0;
1977}

1979/*
* Shared files - similar to downloading
*/
1982ECKnownFileMsgSource::ECKnownFileMsgSource()
1983{
for (unsigned int i = 0; i < theApp->sharedfiles->GetFileCount(); i++) {
const CKnownFile *cur_file = theApp->sharedfiles->GetFileByIndex(i);
KNOWNFILE_STATUS status = { true, false, false, true, cur_file };
m_dirty_status[cur_file->GetFileHash()] = status;
}
1989}

1991void ECKnownFileMsgSource::SetDirty(const CKnownFile *file)
1992{
CMD4Hash filehash = file->GetFileHash();
if ( m_dirty_status.find(filehash) != m_dirty_status.end() ) {
m_dirty_status[filehash].m_dirty = true;;
}
1997}

1999void ECKnownFileMsgSource::SetNew(const CKnownFile *file)
2000{
CMD4Hash filehash = file->GetFileHash();
wxASSERT ( m_dirty_status.find(filehash) == m_dirty_status.end() )do { if ( m_dirty_status.find(filehash) == m_dirty_status.end
() ) { } else if ( wxTheAssertHandler && (wxOnAssert(
"ExternalConn.cpp", 2002, __FUNCTION__, "m_dirty_status.find(filehash) == m_dirty_status.end()"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );
KNOWNFILE_STATUS status = { true, false, false, true, file };
m_dirty_status[filehash] = status;
2005}

2007void ECKnownFileMsgSource::SetRemoved(const CKnownFile *file)
2008{
CMD4Hash filehash = file->GetFileHash();
wxASSERT ( m_dirty_status.find(filehash) != m_dirty_status.end() )do { if ( m_dirty_status.find(filehash) != m_dirty_status.end
() ) { } else if ( wxTheAssertHandler && (wxOnAssert(
"ExternalConn.cpp", 2010, __FUNCTION__, "m_dirty_status.find(filehash) != m_dirty_status.end()"
, (const char*)__null), wxTrapInAssert) ) { wxTrapInAssert = false
; asm volatile ("int $3"); } } while ( (void)0, 0 );

m_dirty_status[filehash].m_removed = true;
2013}

2015CECPacket *ECKnownFileMsgSource::GetNextPacket()
2016{
for(std::map<CMD4Hash, KNOWNFILE_STATUS>::iterator it = m_dirty_status.begin();
it != m_dirty_status.end(); it++) {
if ( it->second.m_new || it->second.m_dirty || it->second.m_removed) {
	CMD4Hash filehash = it->first;

	const CKnownFile *partfile = it->second.m_file;

	CECPacket *packet = new CECPacket(EC_OP_SHARED_FILES);
	if ( it->second.m_removed ) {
		CECTag tag(EC_TAG_PARTFILE, filehash);
		packet->AddTag(tag);
		m_dirty_status.erase(it);
	} else {
		CEC_SharedFile_Tag tag(partfile, it->second.m_new ? EC_DETAIL_FULL : EC_DETAIL_UPDATE);
		packet->AddTag(tag);
	}
	m_dirty_status[filehash].m_new = false;
	m_dirty_status[filehash].m_dirty = false;

	return packet;
}
}
return 0;
2040}

2042/*
* Notification about search status
2044*/
2045ECSearchMsgSource::ECSearchMsgSource()
2046{
2047}

2049CECPacket *ECSearchMsgSource::GetNextPacket()
2050{
if ( m_dirty_status.empty() ) {
return 0;
}

CECPacket *response = new CECPacket(EC_OP_SEARCH_RESULTS);
for(std::map<CMD4Hash, SEARCHFILE_STATUS>::iterator it = m_dirty_status.begin();
it != m_dirty_status.end(); it++) {

if ( it->second.m_new ) {
	response->AddTag(CEC_SearchFile_Tag(it->second.m_file, EC_DETAIL_FULL));
	it->second.m_new = false;
} else if ( it->second.m_dirty ) {
	response->AddTag(CEC_SearchFile_Tag(it->second.m_file, EC_DETAIL_UPDATE));
}

}

return response;
2069}

2071void ECSearchMsgSource::FlushStatus()
2072{
m_dirty_status.clear();
2074}

2076void ECSearchMsgSource::SetDirty(const CSearchFile *file)
2077{
if ( m_dirty_status.count(file->GetFileHash()) ) {
m_dirty_status[file->GetFileHash()].m_dirty = true;
} else {
m_dirty_status[file->GetFileHash()].m_new = true;
m_dirty_status[file->GetFileHash()].m_dirty = true;
m_dirty_status[file->GetFileHash()].m_child_dirty = true;
m_dirty_status[file->GetFileHash()].m_file = file;
}
2086}

2088void ECSearchMsgSource::SetChildDirty(const CSearchFile *file)
2089{
m_dirty_status[file->GetFileHash()].m_child_dirty = true;
2091}

2093/*
* Notification about uploading clients
*/
2096CECPacket *ECClientMsgSource::GetNextPacket()
2097{
return 0;
2099}

2101//
2102// Notification iface per-client
2103//
2104ECNotifier::ECNotifier()
2105{
2106}

2108ECNotifier::~ECNotifier()
2109{
while (m_msg_source.begin() != m_msg_source.end())
Remove_EC_Client(m_msg_source.begin()->first);
2112}

2114CECPacket *ECNotifier::GetNextPacket(ECUpdateMsgSource *msg_source_array[])
2115{
CECPacket *packet = 0;
//
// priority 0 is highest
//
for(int i = 0; i < EC_STATUS_LAST_PRIO; i++) {
if ( (packet = msg_source_array[i]->GetNextPacket()) != 0 ) {
	break;
}
}
return packet;
2126}

2128CECPacket *ECNotifier::GetNextPacket(CECServerSocket *sock)
2129{
//
// OnOutput is called for a first time before
// socket is registered
//
if ( m_msg_source.count(sock) ) {
ECUpdateMsgSource **notifier_array = m_msg_source[sock];
if ( !notifier_array ) {
	return 0;
}
CECPacket *packet = GetNextPacket(notifier_array);
//printf("[EC] next update packet; opcode=%x\n",packet ? packet->GetOpCode() : 0xff);
return packet;
} else {
return 0;
}
2145}

2147//
2148// Interface to notification macros
2149//
2150void ECNotifier::DownloadFile_SetDirty(const CPartFile *file)
2151{
for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
i != m_msg_source.end(); ++i) {
CECServerSocket *sock = i->first;
if ( sock->HaveNotificationSupport() ) {
	ECUpdateMsgSource **notifier_array = i->second;
	static_cast<ECPartFileMsgSource *>(notifier_array[EC_PARTFILE])->SetDirty(file);
}
}
NextPacketToSocket();
2161}

2163void ECNotifier::DownloadFile_RemoveFile(const CPartFile *file)
2164{
for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
i != m_msg_source.end(); ++i) {
ECUpdateMsgSource **notifier_array = i->second;
static_cast<ECPartFileMsgSource *>(notifier_array[EC_PARTFILE])->SetRemoved(file);
}
NextPacketToSocket();
2171}

2173void ECNotifier::DownloadFile_RemoveSource(const CPartFile *)
2174{
// per-partfile source list is not supported (yet), and IMHO quite useless
2176}

2178void ECNotifier::DownloadFile_AddFile(const CPartFile *file)
2179{
for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
i != m_msg_source.end(); ++i) {
ECUpdateMsgSource **notifier_array = i->second;
static_cast<ECPartFileMsgSource *>(notifier_array[EC_PARTFILE])->SetNew(file);
}
NextPacketToSocket();
2186}

2188void ECNotifier::DownloadFile_AddSource(const CPartFile *)
2189{
// per-partfile source list is not supported (yet), and IMHO quite useless
2191}

2193void ECNotifier::SharedFile_AddFile(const CKnownFile *file)
2194{
for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
i != m_msg_source.end(); ++i) {
ECUpdateMsgSource **notifier_array = i->second;
static_cast<ECKnownFileMsgSource *>(notifier_array[EC_KNOWN])->SetNew(file);
}
NextPacketToSocket();
2201}

2203void ECNotifier::SharedFile_RemoveFile(const CKnownFile *file)
2204{
for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
i != m_msg_source.end(); ++i) {
ECUpdateMsgSource **notifier_array = i->second;
static_cast<ECKnownFileMsgSource *>(notifier_array[EC_KNOWN])->SetRemoved(file);
}
NextPacketToSocket();
2211}

2213void ECNotifier::SharedFile_RemoveAllFiles()
2214{
// need to figure out what to do here
2216}

2218void ECNotifier::Add_EC_Client(CECServerSocket *sock)
2219{
ECUpdateMsgSource **notifier_array = new ECUpdateMsgSource *[EC_STATUS_LAST_PRIO];
notifier_array[EC_STATUS] = new ECStatusMsgSource();
15
←
Calling default constructor for 'ECStatusMsgSource'→
notifier_array[EC_SEARCH] = new ECSearchMsgSource();
notifier_array[EC_PARTFILE] = new ECPartFileMsgSource();
notifier_array[EC_CLIENT] = new ECClientMsgSource();
notifier_array[EC_KNOWN] = new ECKnownFileMsgSource();

m_msg_source[sock] = notifier_array;
2228}

2230void ECNotifier::Remove_EC_Client(CECServerSocket *sock)
2231{
if (m_msg_source.count(sock)) {
ECUpdateMsgSource **notifier_array = m_msg_source[sock];

m_msg_source.erase(sock);

for(int i = 0; i < EC_STATUS_LAST_PRIO; i++) {
	delete notifier_array[i];
}
delete [] notifier_array;
}
2242}

2244void ECNotifier::NextPacketToSocket()
2245{
for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
i != m_msg_source.end(); ++i) {
CECServerSocket *sock = i->first;
if ( sock->HaveNotificationSupport() && !sock->DataPending() ) {
	ECUpdateMsgSource **notifier_array = i->second;
	CECPacket *packet = GetNextPacket(notifier_array);
	if ( packet ) {
		//printf("[EC] sending update packet; opcode=%x\n",packet->GetOpCode());
		sock->SendPacket(packet);
	}
}
}
2258}

2260// File_checked_for_headers

←

/usr/include/wx-3.2/wx/translation.h

1	/////////////////////////////////////////////////////////////////////////////
2	// Name: wx/translation.h
3	// Purpose: Internationalization and localisation for wxWidgets
4	// Author: Vadim Zeitlin, Vaclav Slavik,
5	// Michael N. Filippov <michael@idisys.iae.nsk.su>
6	// Created: 2010-04-23
7	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
8	// (c) 2010 Vaclav Slavik <vslavik@fastmail.fm>
9	// Licence: wxWindows licence
10	/////////////////////////////////////////////////////////////////////////////
11
12	#ifndef _WX_TRANSLATION_H_
13	#define _WX_TRANSLATION_H_
14
15	#include "wx/defs.h"
16	#include "wx/string.h"
17
18	#if wxUSE_INTL1
19
20	#include "wx/buffer.h"
21	#include "wx/language.h"
22	#include "wx/hashmap.h"
23	#include "wx/strconv.h"
24	#include "wx/scopedptr.h"
25
26	// ============================================================================
27	// global decls
28	// ============================================================================
29
30	// ----------------------------------------------------------------------------
31	// macros
32	// ----------------------------------------------------------------------------
33
34	// gettext() style macros (notice that xgettext should be invoked with
35	// --keyword="_" --keyword="wxPLURAL:1,2" options
36	// to extract the strings from the sources)
37	#ifndef WXINTL_NO_GETTEXT_MACRO
38	#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
39	#define _(s)wxGetTranslation((s)) wxGetTranslation((s))
40	#else
41	#define _(s)wxGetTranslation((s)) wxGetTranslation(wxASCII_STR(s)wxString::FromAscii(s))
42	#endif
43	#define wxPLURAL(sing, plur, n)wxGetTranslation((sing), (plur), n) wxGetTranslation((sing), (plur), n)
44	#endif
45
46	// wx-specific macro for translating strings in the given context: if you use
47	// them, you need to also add
48	// --keyword="wxGETTEXT_IN_CONTEXT:1c,2" --keyword="wxGETTEXT_IN_CONTEXT_PLURAL:1c,2,3"
49	// options to xgettext invocation.
50	#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
51	#define wxGETTEXT_IN_CONTEXT(c, s)wxGetTranslation((s), wxString(), c) \
52	wxGetTranslation((s), wxString(), c)
53	#else
54	#define wxGETTEXT_IN_CONTEXT(c, s)wxGetTranslation((s), wxString(), c) \
55	wxGetTranslation(wxASCII_STR(s)wxString::FromAscii(s), wxString(), c)
56	#endif
57	#define wxGETTEXT_IN_CONTEXT_PLURAL(c, sing, plur, n)wxGetTranslation((sing), (plur), n, wxString(), c) \
58	wxGetTranslation((sing), (plur), n, wxString(), c)
59
60	// another one which just marks the strings for extraction, but doesn't
61	// perform the translation (use -kwxTRANSLATE with xgettext!)
62	#define wxTRANSLATE(str)str str
63
64	// another one which just marks the strings, with a context, for extraction,
65	// but doesn't perform the translation (use -kwxTRANSLATE_IN_CONTEXT:1c,2 with
66	// xgettext!)
67	#define wxTRANSLATE_IN_CONTEXT(c, str)str str
68
69	// ----------------------------------------------------------------------------
70	// forward decls
71	// ----------------------------------------------------------------------------
72
73	class WXDLLIMPEXP_FWD_BASE wxArrayString;
74	class WXDLLIMPEXP_FWD_BASE wxTranslationsLoader;
75	class WXDLLIMPEXP_FWD_BASE wxLocale;
76
77	class wxPluralFormsCalculator;
78	wxDECLARE_SCOPED_PTR(wxPluralFormsCalculator, wxPluralFormsCalculatorPtr)class wxPluralFormsCalculatorPtr { private: wxPluralFormsCalculator * m_ptr; wxPluralFormsCalculatorPtr(wxPluralFormsCalculatorPtr const &); wxPluralFormsCalculatorPtr & operator=(wxPluralFormsCalculatorPtr const &); public: explicit wxPluralFormsCalculatorPtr(wxPluralFormsCalculator * ptr = __null) : m_ptr(ptr) { } ~wxPluralFormsCalculatorPtr (); void reset(wxPluralFormsCalculator * ptr = __null); wxPluralFormsCalculator release() { wxPluralFormsCalculator ptr = m_ptr; m_ptr = __null ; return ptr; } wxPluralFormsCalculator & operator() const { do { if ( m_ptr != __null ) { } else if ( wxTheAssertHandler && (wxOnAssert("/usr/include/wx-3.2/wx/translation.h" , 78, __FUNCTION__, "m_ptr != __null", (const char)__null), wxTrapInAssert ) ) { wxTrapInAssert = false; asm volatile ("int $3"); } } while ( (void)0, 0 ); return m_ptr; } wxPluralFormsCalculator operator ->() const { do { if ( m_ptr != __null ) { } else if ( wxTheAssertHandler && (wxOnAssert("/usr/include/wx-3.2/wx/translation.h" , 78, __FUNCTION__, "m_ptr != __null", (const char)__null), wxTrapInAssert ) ) { wxTrapInAssert = false; asm volatile ("int $3"); } } while ( (void)0, 0 ); return m_ptr; } wxPluralFormsCalculator get () const { return m_ptr; } void swap(wxPluralFormsCalculatorPtr & ot) { wxPluralFormsCalculator * tmp = ot.m_ptr; ot.m_ptr = m_ptr; m_ptr = tmp; } };
79
80	// ----------------------------------------------------------------------------
81	// wxMsgCatalog corresponds to one loaded message catalog.
82	// ----------------------------------------------------------------------------
83
84	class WXDLLIMPEXP_BASE__attribute__ ((visibility("default"))) wxMsgCatalog
85	{
86	public:
87	// Ctor is protected, because CreateFromXXX functions must be used,
88	// but destruction should be unrestricted
89	#if !wxUSE_UNICODE1
90	~wxMsgCatalog();
91	#endif
92
93	// load the catalog from disk or from data; caller is responsible for
94	// deleting them if not NULL
95	static wxMsgCatalog *CreateFromFile(const wxString& filename,
96	const wxString& domain);
97
98	static wxMsgCatalog *CreateFromData(const wxScopedCharBuffer& data,
99	const wxString& domain);
100
101	// get name of the catalog
102	wxString GetDomain() const { return m_domain; }
103
104	// get the translated string: returns NULL if not found
105	const wxString GetString(const wxString& sz, unsigned n = UINT_MAX(2147483647 2U +1U), const wxString& ct = wxEmptyString) const;
106
107	protected:
108	wxMsgCatalog(const wxString& domain)
109	: m_pNext(NULL__null), m_domain(domain)
110	#if !wxUSE_UNICODE1
111	, m_conv(NULL__null)
112	#endif
113	{}
114
115	private:
116	// variable pointing to the next element in a linked list (or NULL)
117	wxMsgCatalog *m_pNext;
118	friend class wxTranslations;
119
120	wxStringToStringHashMap m_messages; // all messages in the catalog
121	wxString m_domain; // name of the domain
122
123	#if !wxUSE_UNICODE1
124	// the conversion corresponding to this catalog charset if we installed it
125	// as the global one
126	wxCSConv *m_conv;
127	#endif
128
129	wxPluralFormsCalculatorPtr m_pluralFormsCalculator;
130	};
131
132	// ----------------------------------------------------------------------------
133	// wxTranslations: message catalogs
134	// ----------------------------------------------------------------------------
135
136	// this class allows to get translations for strings
137	class WXDLLIMPEXP_BASE__attribute__ ((visibility("default"))) wxTranslations
138	{
139	public:
140	wxTranslations();
141	~wxTranslations();
142
143	// returns current translations object, may return NULL
144	static wxTranslations *Get();
145	// sets current translations object (takes ownership; may be NULL)
146	static void Set(wxTranslations *t);
147
148	// changes loader to non-default one; takes ownership of 'loader'
149	void SetLoader(wxTranslationsLoader *loader);
150
151	void SetLanguage(wxLanguage lang);
152	void SetLanguage(const wxString& lang);
153
154	// get languages available for this app
155	wxArrayString GetAvailableTranslations(const wxString& domain) const;
156
157	#if wxABI_VERSION( 3 * 10000 + 2 * 100 + 99 ) >= 30203
158	// find best available translation language for given domain
159	wxString GetBestAvailableTranslation(const wxString& domain);
160	#endif // wxABI_VERSION >= 3.2.3
161
162	wxString GetBestTranslation(const wxString& domain, wxLanguage msgIdLanguage);
163	wxString GetBestTranslation(const wxString& domain,
164	const wxString& msgIdLanguage = wxASCII_STR("en")wxString::FromAscii("en"));
165
166	#if wxABI_VERSION( 3 * 10000 + 2 * 100 + 99 ) >= 30203
167	// add catalog for the given domain returning true if it could be found by
168	// wxTranslationsLoader
169	bool AddAvailableCatalog(const wxString& domain);
170	#endif // wxABI_VERSION >= 3.2.3
171	#if wxABI_VERSION( 3 * 10000 + 2 * 100 + 99 ) >= 30206
172	bool AddAvailableCatalog(const wxString& domain, wxLanguage msgIdLanguage);
173	#endif // wxABI_VERSION >= 3.2.5
174
175	// add standard wxWidgets catalog ("wxstd")
176	bool AddStdCatalog();
177
178	// add catalog with given domain name and language, looking it up via
179	// wxTranslationsLoader -- unlike AddAvailableCatalog(), this function also
180	// returns true if this catalog is not needed at all because msgIdLanguage
181	// is an acceptable language to use directly
182	bool AddCatalog(const wxString& domain,
183	wxLanguage msgIdLanguage = wxLANGUAGE_ENGLISH_US);
184	#if !wxUSE_UNICODE1
185	bool AddCatalog(const wxString& domain,
186	wxLanguage msgIdLanguage,
187	const wxString& msgIdCharset);
188	#endif
189
190	// check if the given catalog is loaded
191	bool IsLoaded(const wxString& domain) const;
192
193	// access to translations
194	const wxString *GetTranslatedString(const wxString& origString,
195	const wxString& domain = wxEmptyString,
196	const wxString& context = wxEmptyString) const;
197	const wxString *GetTranslatedString(const wxString& origString,
198	unsigned n,
199	const wxString& domain = wxEmptyString,
200	const wxString& context = wxEmptyString) const;
201
202	wxString GetHeaderValue(const wxString& header,
203	const wxString& domain = wxEmptyString) const;
204
205	// this is hack to work around a problem with wxGetTranslation() which
206	// returns const wxString& and not wxString, so when it returns untranslated
207	// string, it needs to have a copy of it somewhere
208	static const wxString& GetUntranslatedString(const wxString& str);
209
210	private:
211	enum Translations
212	{
213	Translations_NotNeeded = -1,
214	Translations_NotFound = 0,
215	Translations_Found = 1
216	};
217
218	Translations DoAddCatalog(const wxString& domain, wxLanguage msgIdLanguage);
219
220	// perform loading of the catalog via m_loader
221	bool LoadCatalog(const wxString& domain, const wxString& lang, const wxString& msgIdLang);
222
223	// find catalog by name in a linked list, return NULL if !found
224	wxMsgCatalog *FindCatalog(const wxString& domain) const;
225
226	// same as Set(), without taking ownership; only for wxLocale
227	static void SetNonOwned(wxTranslations *t);
228	friend class wxLocale;
229
230	wxString DoGetBestAvailableTranslation(const wxString& domain, const wxString& additionalAvailableLanguage);
231
232	private:
233	wxString m_lang;
234	wxTranslationsLoader *m_loader;
235
236	wxMsgCatalog *m_pMsgCat; // pointer to linked list of catalogs
237
238	// In addition to keeping all the catalogs in the linked list, we also
239	// store them in a hash map indexed by the domain name to allow finding
240	// them by name efficiently.
241	WX_DECLARE_HASH_MAP(wxString, wxMsgCatalog , wxStringHash, wxStringEqual, wxMsgCatalogMap)class wxMsgCatalogMap_wxImplementation_Pair { public: typedef wxString first_type; typedef wxMsgCatalog second_type; typedef wxString t1; typedef wxMsgCatalog * t2; typedef const wxString const_t1; typedef const wxMsgCatalog * const_t2; wxMsgCatalogMap_wxImplementation_Pair (const const_t1& f, const const_t2& s) : first(const_cast <t1&>(f)), second(const_cast<t2&>(s)) {} t1 first; t2 second; }; class wxMsgCatalogMap_wxImplementation_KeyEx { typedef wxString key_type; typedef wxMsgCatalogMap_wxImplementation_Pair pair_type; typedef const key_type const_key_type; typedef const pair_type const_pair_type; typedef const_key_type& const_key_reference ; typedef const_pair_type& const_pair_reference; public: wxMsgCatalogMap_wxImplementation_KeyEx () { } const_key_reference operator()( const_pair_reference pair ) const { return pair.first; }}; class wxMsgCatalogMap_wxImplementation_HashTable : protected _wxHashTableBase2 { public: typedef wxString key_type ; typedef wxMsgCatalogMap_wxImplementation_Pair value_type; typedef wxStringHash hasher; typedef wxStringEqual key_equal; typedef size_t size_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef const value_type* const_pointer ; typedef value_type& reference; typedef const value_type & const_reference; typedef const wxString const_key_type; typedef const wxMsgCatalogMap_wxImplementation_Pair const_mapped_type ; public: typedef wxMsgCatalogMap_wxImplementation_KeyEx key_extractor ; typedef wxMsgCatalogMap_wxImplementation_HashTable Self; protected : _wxHashTable_NodeBase** m_table; size_t m_tableBuckets; size_t m_items; hasher m_hasher; key_equal m_equals; key_extractor m_getKey ; public: struct Node:public _wxHashTable_NodeBase { public: Node ( const value_type& value ) : m_value( value ) {} Node* next () { return static_cast<Node>(m_next); } value_type m_value ; }; protected: static void DeleteNode( _wxHashTable_NodeBase node ) { delete static_cast<Node>(node); } public: class Iterator { public: Node m_node; Self* m_ht; Iterator() : m_node (__null), m_ht(__null) {} Iterator( Node* node, const Self* ht ) : m_node(node), m_ht(const_cast<Self>(ht)) {} bool operator ==( const Iterator& it ) const { return m_node == it.m_node ; } bool operator !=( const Iterator& it ) const { return m_node != it.m_node; } protected: Node GetNextNode() { size_type bucket = GetBucketForNode(m_ht,m_node); for( size_type i = bucket + 1; i < m_ht->m_tableBuckets; ++i ) { if( m_ht->m_table [i] ) return static_cast<Node>(m_ht->m_table[i]); } return __null; } void PlusPlus() { Node next = m_node->next (); m_node = next ? next : GetNextNode(); } }; friend class Iterator ; public: class iterator : public Iterator { public: iterator () : Iterator() {} iterator( Node* node, Self* ht ) : Iterator ( node, ht ) {} iterator& operator++() { PlusPlus(); return this; } iterator operator++(int) { iterator it=this;PlusPlus ();return it; } reference operator () const { return m_node-> m_value; } pointer operator ->() const { return &(m_node ->m_value); } }; class const_iterator : public Iterator { public : const_iterator() : Iterator() {} const_iterator(iterator i) : Iterator(i) {} const_iterator( Node node, const Self* ht ) : Iterator(node, const_cast<Self>(ht)) {} const_iterator & operator++() { PlusPlus();return this; } const_iterator operator++(int) { const_iterator it=this;PlusPlus();return it ; } const_reference operator () const { return m_node->m_value ; } const_pointer operator ->() const { return &(m_node ->m_value); } }; wxMsgCatalogMap_wxImplementation_HashTable ( size_type sz = 10, const hasher& hfun = hasher(), const key_equal& k_eq = key_equal(), const key_extractor& k_ex = key_extractor() ) : m_tableBuckets( GetNextPrime( (unsigned long) sz ) ), m_items( 0 ), m_hasher( hfun ), m_equals( k_eq ), m_getKey( k_ex ) { m_table = (_wxHashTable_NodeBase*)AllocTable (m_tableBuckets); } wxMsgCatalogMap_wxImplementation_HashTable ( const Self& ht ) : m_table(__null), m_tableBuckets( 0 ) , m_items( ht.m_items ), m_hasher( ht.m_hasher ), m_equals( ht .m_equals ), m_getKey( ht.m_getKey ) { HashCopy( ht ); } const Self& operator=( const Self& ht ) { if (&ht != this ) { clear(); m_hasher = ht.m_hasher; m_equals = ht.m_equals; m_getKey = ht.m_getKey; m_items = ht.m_items; HashCopy( ht ); } return this; } ~wxMsgCatalogMap_wxImplementation_HashTable() { clear (); FreeTable(m_table); } hasher hash_funct() { return m_hasher ; } key_equal key_eq() { return m_equals; } void clear() { DeleteNodes (m_tableBuckets, m_table, DeleteNode); m_items = 0; } size_type size() const { return m_items; } size_type max_size() const { return size_type(-1); } bool empty() const { return size() == 0; } const_iterator end() const { return const_iterator(__null , this); } iterator end() { return iterator(__null, this); } const_iterator begin() const { return const_iterator(static_cast<Node> (GetFirstNode(m_tableBuckets, m_table)), this); } iterator begin () { return iterator(static_cast<Node>(GetFirstNode(m_tableBuckets , m_table)), this); } size_type erase( const const_key_type& key ) { _wxHashTable_NodeBase** node = GetNodePtr(key); if( ! node ) return 0; --m_items; _wxHashTable_NodeBase* temp = (node )->m_next; delete static_cast<Node>(node); (node) = temp; if( never_shrink( m_tableBuckets, m_items ) ) ResizeTable ( GetPreviousPrime( (unsigned long) m_tableBuckets ) - 1 ); return 1; } protected: static size_type GetBucketForNode( Self* ht, Node* node ) { return ht->m_hasher( ht->m_getKey( node ->m_value ) ) % ht->m_tableBuckets; } static Node* CopyNode ( Node* node ) { return new Node( node ); } Node GetOrCreateNode ( const value_type& value, bool& created ) { const const_key_type & key = m_getKey( value ); size_t bucket = m_hasher( key ) % m_tableBuckets; Node* node = static_cast<Node>(m_table [bucket]); while( node ) { if( m_equals( m_getKey( node->m_value ), key ) ) { created = false; return node; } node = node-> next(); } created = true; return CreateNode( value, bucket); } Node CreateNode( const value_type& value, size_t bucket ) { Node* node = new Node( value ); node->m_next = m_table [bucket]; m_table[bucket] = node; ++m_items; if( grow_lf70( m_tableBuckets , m_items ) ) ResizeTable( m_tableBuckets ); return node; } void CreateNode( const value_type& value ) { CreateNode(value , m_hasher( m_getKey(value) ) % m_tableBuckets ); } _wxHashTable_NodeBase GetNodePtr(const const_key_type& key) const { size_t bucket = m_hasher( key ) % m_tableBuckets; _wxHashTable_NodeBase node = &m_table[bucket]; while( node ) { if (m_equals(m_getKey (static_cast<Node>(node)->m_value), key)) return node ; node = &(node)->m_next; } return __null; } Node* GetNode ( const const_key_type& key ) const { size_t bucket = m_hasher ( key ) % m_tableBuckets; Node* node = static_cast<Node> (m_table[bucket]); while( node ) { if( m_equals( m_getKey( node ->m_value ), key ) ) return node; node = node->next(); } return __null; } void ResizeTable( size_t newSize ) { newSize = GetNextPrime( (unsigned long)newSize ); _wxHashTable_NodeBase * srcTable = m_table; size_t srcBuckets = m_tableBuckets; m_table = (_wxHashTable_NodeBase*)AllocTable( newSize ); m_tableBuckets = newSize; CopyHashTable( srcTable, srcBuckets, this, m_table , (BucketFromNode)GetBucketForNode, (ProcessNode)&DummyProcessNode ); FreeTable(srcTable); } void HashCopy( const Self& ht ) { ResizeTable( ht.size() ); CopyHashTable( ht.m_table, ht.m_tableBuckets , (_wxHashTableBase2)this, m_table, (BucketFromNode)GetBucketForNode , (ProcessNode)CopyNode ); } }; class wxMsgCatalogMap:public wxMsgCatalogMap_wxImplementation_HashTable { public: typedef wxMsgCatalog * mapped_type; class Insert_Result { public: typedef iterator first_type; typedef bool second_type ; typedef iterator t1; typedef bool t2; typedef const iterator const_t1; typedef const bool const_t2; Insert_Result(const const_t1 & f, const const_t2& s) : first(const_cast<t1& >(f)), second(const_cast<t2&>(s)) {} t1 first; t2 second; }; explicit wxMsgCatalogMap( size_type hint = 100, hasher hf = hasher(), key_equal eq = key_equal() ) : wxMsgCatalogMap_wxImplementation_HashTable ( hint, hf, eq, wxMsgCatalogMap_wxImplementation_KeyEx() ) {} mapped_type& operator[]( const const_key_type& key ) { bool created; return GetOrCreateNode( wxMsgCatalogMap_wxImplementation_Pair ( key, mapped_type() ), created)->m_value.second; } const_iterator find( const const_key_type& key ) const { return const_iterator ( GetNode( key ), this ); } iterator find( const const_key_type & key ) { return iterator( GetNode( key ), this ); } Insert_Result insert( const value_type& v ) { bool created; Node node = GetOrCreateNode( wxMsgCatalogMap_wxImplementation_Pair( v. first, v.second ), created); return Insert_Result(iterator(node , this), created); } size_type erase( const key_type& k ) { return wxMsgCatalogMap_wxImplementation_HashTable::erase( k ); } void erase( const iterator& it ) { erase( (it).first ); } size_type count( const const_key_type& key ) { return GetNode( key ) ? 1u : 0u; } };
242	wxMsgCatalogMap m_catalogMap;
243	};
244
245
246	// abstraction of translations discovery and loading
247	class WXDLLIMPEXP_BASE__attribute__ ((visibility("default"))) wxTranslationsLoader
248	{
249	public:
250	wxTranslationsLoader() {}
251	virtual ~wxTranslationsLoader() {}
252
253	virtual wxMsgCatalog *LoadCatalog(const wxString& domain,
254	const wxString& lang) = 0;
255
256	virtual wxArrayString GetAvailableTranslations(const wxString& domain) const = 0;
257	};
258
259
260	// standard wxTranslationsLoader implementation, using filesystem
261	class WXDLLIMPEXP_BASE__attribute__ ((visibility("default"))) wxFileTranslationsLoader
262	: public wxTranslationsLoader
263	{
264	public:
265	static void AddCatalogLookupPathPrefix(const wxString& prefix);
266
267	virtual wxMsgCatalog *LoadCatalog(const wxString& domain,
268	const wxString& lang) wxOVERRIDEoverride;
269
270	virtual wxArrayString GetAvailableTranslations(const wxString& domain) const wxOVERRIDEoverride;
271	};
272
273
274	#ifdef __WINDOWS__
275	// loads translations from win32 resources
276	class WXDLLIMPEXP_BASE__attribute__ ((visibility("default"))) wxResourceTranslationsLoader
277	: public wxTranslationsLoader
278	{
279	public:
280	virtual wxMsgCatalog *LoadCatalog(const wxString& domain,
281	const wxString& lang) wxOVERRIDEoverride;
282
283	virtual wxArrayString GetAvailableTranslations(const wxString& domain) const wxOVERRIDEoverride;
284
285	protected:
286	// returns resource type to use for translations
287	virtual wxString GetResourceType() const { return wxASCII_STR("MOFILE")wxString::FromAscii("MOFILE"); }
288
289	// returns module to load resources from
290	virtual WXHINSTANCE GetModule() const { return NULL__null; }
291	};
292	#endif // __WINDOWS__
293
294
295	// ----------------------------------------------------------------------------
296	// global functions
297	// ----------------------------------------------------------------------------
298
299	// get the translation of the string in the current locale
300	inline const wxString& wxGetTranslation(const wxString& str,
301	const wxString& domain = wxString(),
302	const wxString& context = wxString())
303	{
304	wxTranslations *trans = wxTranslations::Get();
305	const wxString *transStr = trans ? trans->GetTranslatedString(str, domain, context)
306	: NULL__null;
307	if ( transStr )
308	return *transStr;
309	else
310	// NB: this function returns reference to a string, so we have to keep
311	// a copy of it somewhere
312	return wxTranslations::GetUntranslatedString(str);
313	}
314
315	inline const wxString& wxGetTranslation(const wxString& str1,
316	const wxString& str2,
317	unsigned n,
318	const wxString& domain = wxString(),
319	const wxString& context = wxString())
320	{
321	wxTranslations *trans = wxTranslations::Get();
322	const wxString *transStr = trans ? trans->GetTranslatedString(str1, n, domain, context)
323	: NULL__null;
324	if ( transStr )
325	return *transStr;
326	else
327	// NB: this function returns reference to a string, so we have to keep
328	// a copy of it somewhere
329	return n == 1
330	? wxTranslations::GetUntranslatedString(str1)
331	: wxTranslations::GetUntranslatedString(str2);
332	}
333
334	#ifdef wxNO_IMPLICIT_WXSTRING_ENCODING
335
336	/*
337	* It must always be possible to call wxGetTranslation() with const
338	* char* arguments.
339	*/
340	inline const wxString& wxGetTranslation(const char *str,
341	const char *domain = "",
342	const char *context = "") {
343	const wxMBConv &conv = wxConvWhateverWorkswxGet_wxConvWhateverWorks();
344	return wxGetTranslation(wxString(str, conv), wxString(domain, conv),
345	wxString(context, conv));
346	}
347
348	inline const wxString& wxGetTranslation(const char *str1,
349	const char *str2,
350	unsigned n,
351	const char *domain = "",
352	const char *context = "") {
353	const wxMBConv &conv = wxConvWhateverWorkswxGet_wxConvWhateverWorks();
354	return wxGetTranslation(wxString(str1, conv), wxString(str2, conv), n,
355	wxString(domain, conv),
356	wxString(context, conv));
357	}
358
359	#endif // wxNO_IMPLICIT_WXSTRING_ENCODING
360
361	#else // !wxUSE_INTL
362
363	// the macros should still be defined - otherwise compilation would fail
364
365	#if !defined(WXINTL_NO_GETTEXT_MACRO)
366	#if !defined(_)
367	#ifndef wxNO_IMPLICIT_WXSTRING_ENCODING
368	#define _(s)wxGetTranslation((s)) (s)
369	#else
370	#define _(s)wxGetTranslation((s)) wxASCII_STR(s)wxString::FromAscii(s)
371	#endif
372	#endif
373	#define wxPLURAL(sing, plur, n)wxGetTranslation((sing), (plur), n) ((n) == 1 ? (sing) : (plur))
374	#define wxGETTEXT_IN_CONTEXT(c, s)wxGetTranslation((s), wxString(), c) (s)
375	#define wxGETTEXT_IN_CONTEXT_PLURAL(c, sing, plur, n)wxGetTranslation((sing), (plur), n, wxString(), c) wxPLURAL(sing, plur, n)wxGetTranslation((sing), (plur), n)
376	#endif
377
378	#define wxTRANSLATE(str)str str
379	#define wxTRANSLATE_IN_CONTEXT(c, str)str str
380
381	// NB: we use a template here in order to avoid using
382	// wxLocale::GetUntranslatedString() above, which would be required if
383	// we returned const wxString&; this way, the compiler should be able to
384	// optimize wxGetTranslation() away
385
386	template<typename TString>
387	inline TString wxGetTranslation(TString str)
388	{ return str; }
389
390	template<typename TString, typename TDomain>
391	inline TString wxGetTranslation(TString str, TDomain WXUNUSED(domain))
392	{ return str; }
393
394	template<typename TString, typename TDomain, typename TContext>
395	inline TString wxGetTranslation(TString str, TDomain WXUNUSED(domain), TContext WXUNUSED(context))
396	{ return str; }
397
398	template<typename TString, typename TDomain>
399	inline TString wxGetTranslation(TString str1, TString str2, size_t n)
400	{ return n == 1 ? str1 : str2; }
401
402	template<typename TString, typename TDomain>
403	inline TString wxGetTranslation(TString str1, TString str2, size_t n,
404	TDomain WXUNUSED(domain))
405	{ return n == 1 ? str1 : str2; }
406
407	template<typename TString, typename TDomain, typename TContext>
408	inline TString wxGetTranslation(TString str1, TString str2, size_t n,
409	TDomain WXUNUSED(domain),
410	TContext WXUNUSED(context))
411	{ return n == 1 ? str1 : str2; }
412
413	#endif // wxUSE_INTL/!wxUSE_INTL
414
415	// define this one just in case it occurs somewhere (instead of preferred
416	// wxTRANSLATE) too
417	#if !defined(WXINTL_NO_GETTEXT_MACRO)
418	#if !defined(gettext_noop)
419	#define gettext_noop(str)(str) (str)
420	#endif
421	#if !defined(N_)
422	#define N_(s)(s) (s)
423	#endif
424	#endif
425
426	#endif // _WX_TRANSLATION_H_