src/ExternalConn.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 Kry ( elkry@sourceforge.net / http://www.amule.org )
   5 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   6 // Copyright (c) 2008 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 //
  26
  27 #ifdef HAVE_CONFIG_H
  28         #include "config.h"             // Needed for VERSION
  29 #endif
  30
  31 #include <ec/cpp/ECMuleSocket.h>                // Needed for CECSocket
  32
  33 #include <common/Format.h>              // Needed for CFormat
  34
  35 #include <common/ClientVersion.h>
  36 #include <common/MD5Sum.h>
  37
  38 #include "ExternalConn.h"       // Interface declarations
  39 #include "updownclient.h"       // Needed for CUpDownClient
  40 #include "Server.h"             // Needed for CServer
  41 #include "ServerList.h"         // Needed for CServerList
  42 #include "PartFile.h"           // Needed for CPartFile
  43 #include "ServerConnect.h"      // Needed for CServerConnect
  44 #include "UploadQueue.h"        // Needed for CUploadQueue
  45 #include "amule.h"              // Needed for theApp
  46 #include "SearchList.h"         // Needed for GetSearchResults
  47 #include "IPFilter.h"           // Needed for CIPFilter
  48 #include "ClientList.h"
  49 #include "Preferences.h"        // Needed for CPreferences
  50 #include "Logger.h"
  51 #include "GuiEvents.h"          // Needed for Notify_* macros
  52 #include "Statistics.h"         // Needed for theStats
  53 #include "KnownFileList.h"      // Needed for CKnownFileList
  54 #include "RandomFunctions.h"
  55 #include "kademlia/kademlia/Kademlia.h"
  56 #include "kademlia/kademlia/UDPFirewallTester.h"
  57
  58
  59 //-------------------- File_Encoder --------------------
  60
  61
  62 /*
  63  * Encode 'obtained parts' info to be sent to remote gui
  64  */
  65 class CKnownFile_Encoder {
  66         // number of sources for each part for progress bar colouring
  67         RLE_Data m_enc_data;
  68 protected:
  69         const CKnownFile *m_file;
  70 public:
  71         CKnownFile_Encoder(const CKnownFile *file = 0) { m_file = file; }
  72
  73         virtual ~CKnownFile_Encoder() {}
  74
  75         virtual void Encode(CECTag *parent_tag);
  76
  77         virtual void ResetEncoder()
  78         {
  79                 m_enc_data.ResetEncoder();
  80         }
  81
  82         virtual void SetShared() { }
  83         virtual bool IsShared() { return true; }
  84         virtual bool IsDownload() { return m_file->IsPartFile(); }
  85         const CKnownFile * GetFile() { return m_file; }
  86 };
  87
  88 /*!
  89  * PartStatus strings and gap lists are quite long - RLE encoding will help.
  90  *
  91  * Instead of sending each time full part-status string, send
  92  * RLE encoded difference from previous one.
  93  *
  94  * PartFileEncoderData class is used for decode only,
  95  * while CPartFile_Encoder is used for encode only.
  96  */
  97 class CPartFile_Encoder : public CKnownFile_Encoder {
  98         // blocks requested for download
  99         RLE_Data m_req_status;
 100         // gap list
 101         RLE_Data m_gap_status;
 102         // source names
 103         SourcenameItemMap m_sourcenameItemMap;
 104         // counter for unique source name ids
 105         int m_sourcenameID;
 106         // not all part files are shared (only when at least one part is complete)
 107         bool m_shared;
 108
 109         // cast inherited member to CPartFile
 110         CPartFile * m_PartFile() { wxASSERT(m_file->IsCPartFile()); return (CPartFile *)m_file; }
 111 public:
 112         // encoder side
 113         CPartFile_Encoder(const CPartFile *file = 0) : CKnownFile_Encoder(file)
 114         {
 115                 m_sourcenameID = 0;
 116                 m_shared = false;
 117         }
 118
 119         virtual ~CPartFile_Encoder() {}
 120
 121         // encode - take data from m_file
 122         virtual void Encode(CECTag *parent_tag);
 123
 124         // Encoder may reset history if full info requested
 125         virtual void ResetEncoder();
 126
 127         virtual void SetShared() { m_shared = true; }
 128         virtual bool IsShared() { return m_shared; }
 129         virtual bool IsDownload() { return true; }
 130 };
 131
 132 class CFileEncoderMap : public std::map<uint32, CKnownFile_Encoder*> {
 133         typedef std::set<uint32> IDSet;
 134 public:
 135         ~CFileEncoderMap();
 136         void UpdateEncoders();
 137 };
 138
 139 CFileEncoderMap::~CFileEncoderMap()
 140 {
 141         // DeleteContents() causes infinite recursion here!
 142         for (iterator it = begin(); it != end(); it++) {
 143                 delete it->second;
 144         }
 145 }
 146
 147 // Check if encoder contains files that are no longer used
 148 // or if we have new files without encoder yet.
 149 void CFileEncoderMap::UpdateEncoders()
 150 {
 151         IDSet curr_files, dead_files;
 152         // Downloads
 153         std::vector<CPartFile*> downloads;
 154         theApp->downloadqueue->CopyFileList(downloads);
 155         for (uint32 i = downloads.size(); i--;) {
 156                 uint32 id = downloads[i]->ECID();
 157                 curr_files.insert(id);
 158                 if (!count(id)) {
 159                         (*this)[id] = new CPartFile_Encoder(downloads[i]);
 160                 }
 161         }
 162         // Shares
 163         std::vector<CKnownFile*> shares;
 164         theApp->sharedfiles->CopyFileList(shares);
 165         for (uint32 i = shares.size(); i--;) {
 166                 uint32 id = shares[i]->ECID();
 167                 if (shares[i]->IsPartFile()) {  // we already have it
 168                         (*this)[id]->SetShared();
 169                         continue;
 170                 }
 171                 curr_files.insert(id);
 172                 if (!count(id)) {
 173                         (*this)[id] = new CKnownFile_Encoder(shares[i]);
 174                 }
 175         }
 176         // Check for removed files, and store them in a set for deletion.
 177         // (std::map documentation is unclear if a construct like
 178         //              iterator to_del = it++; erase(to_del) ;
 179         // works or invalidates it too.)
 180         for (iterator it = begin(); it != end(); it++) {
 181                 if (!curr_files.count(it->first)) {
 182                         dead_files.insert(it->first);
 183                 }
 184         }
 185         // then delete them
 186         for (IDSet::iterator it = dead_files.begin(); it != dead_files.end(); it++) {
 187                 iterator it2 = find(*it);
 188                 delete it2->second;
 189                 erase(it2);
 190         }
 191 }
 192
 193
 194 //-------------------- CECServerSocket --------------------
 195
 196 class CECServerSocket : public CECMuleSocket
 197 {
 198 public:
 199         CECServerSocket(ECNotifier *notifier);
 200         virtual ~CECServerSocket();
 201
 202         virtual const CECPacket *OnPacketReceived(const CECPacket *packet, uint32 trueSize);
 203         virtual void OnLost();
 204
 205         virtual void WriteDoneAndQueueEmpty();
 206 private:
 207         ECNotifier *m_ec_notifier;
 208
 209         const CECPacket *Authenticate(const CECPacket *);
 210
 211         enum {
 212                 CONN_INIT,
 213                 CONN_SALT_SENT,
 214                 CONN_ESTABLISHED,
 215                 CONN_FAILED
 216         } m_conn_state;
 217
 218         uint64_t m_passwd_salt;
 219         CLoggerAccess m_LoggerAccess;
 220         CFileEncoderMap m_FileEncoder;
 221         CObjTagMap              m_obj_tagmap;
 222         CECPacket *ProcessRequest2(const CECPacket *request);
 223
 224         virtual bool IsAuthorized() { return m_conn_state == CONN_ESTABLISHED; }
 225 };
 226
 227
 228 CECServerSocket::CECServerSocket(ECNotifier *notifier)
 229 :
 230 CECMuleSocket(true),
 231 m_conn_state(CONN_INIT),
 232 m_passwd_salt(GetRandomUint64())
 233 {
 234         wxASSERT(theApp->ECServerHandler);
 235         theApp->ECServerHandler->AddSocket(this);
 236         m_ec_notifier = notifier;
 237 }
 238
 239
 240 CECServerSocket::~CECServerSocket()
 241 {
 242         wxASSERT(theApp->ECServerHandler);
 243         theApp->ECServerHandler->RemoveSocket(this);
 244 }
 245
 246
 247 const CECPacket *CECServerSocket::OnPacketReceived(const CECPacket *packet, uint32 trueSize)
 248 {
 249         packet->DebugPrint(true, trueSize);
 250
 251         const CECPacket *reply = NULL;
 252
 253         if (m_conn_state == CONN_FAILED) {
 254                 // Client didn't close the socket when authentication failed.
 255                 AddLogLineM(false, _("Client sent packet after authentication failed."));
 256                 CloseSocket();
 257         }
 258
 259         if (m_conn_state != CONN_ESTABLISHED) {
 260                 // This is called twice:
 261                 // 1) send salt
 262                 // 2) verify password
 263                 reply = Authenticate(packet);
 264         } else {
 265                 reply = ProcessRequest2(packet);
 266         }
 267         return reply;
 268 }
 269
 270
 271 void CECServerSocket::OnLost()
 272 {
 273         AddLogLineM(false,_("External connection closed."));
 274         theApp->ECServerHandler->m_ec_notifier->Remove_EC_Client(this);
 275         DestroySocket();
 276 }
 277
 278 void CECServerSocket::WriteDoneAndQueueEmpty()
 279 {
 280         if ( HaveNotificationSupport() && (m_conn_state == CONN_ESTABLISHED) ) {
 281                 CECPacket *packet = m_ec_notifier->GetNextPacket(this);
 282                 if ( packet ) {
 283                         SendPacket(packet);
 284                 }
 285         } else {
 286                 //printf("[EC] %p: WriteDoneAndQueueEmpty but notification disabled\n", this);
 287         }
 288 }
 289
 290 //-------------------- ExternalConn --------------------
 291
 292 enum
 293 {       // id for sockets
 294         SERVER_ID = 1000
 295 };
 296
 297
 298 BEGIN_EVENT_TABLE(ExternalConn, wxEvtHandler)
 299         EVT_SOCKET(SERVER_ID, ExternalConn::OnServerEvent)
 300 END_EVENT_TABLE()
 301
 302
 303 ExternalConn::ExternalConn(amuleIPV4Address addr, wxString *msg)
 304 {
 305         wxString msgLocal;
 306         m_ECServer = NULL;
 307         // Are we allowed to accept External Connections?
 308         if ( thePrefs::AcceptExternalConnections() ) {
 309                 // We must have a valid password, otherwise we will not allow EC connections
 310                 if (thePrefs::ECPassword().IsEmpty()) {
 311                         *msg += wxT("External connections disabled due to empty password!\n");
 312                         AddLogLineM(true, _("External connections disabled due to empty password!"));
 313                         return;
 314                 }
 315
 316                 // Create the socket
 317                 m_ECServer = new wxSocketServer(addr, wxSOCKET_REUSEADDR);
 318                 m_ECServer->SetEventHandler(*this, SERVER_ID);
 319                 m_ECServer->SetNotify(wxSOCKET_CONNECTION_FLAG);
 320                 m_ECServer->Notify(true);
 321
 322                 int port = addr.Service();
 323                 wxString ip = addr.IPAddress();
 324                 if (m_ECServer->Ok()) {
 325                         msgLocal = wxT("*** TCP socket (ECServer) listening on ") + ip +
 326                                 wxString::Format(wxT(":%d"), port);
 327                         *msg += msgLocal + wxT("\n");
 328                         AddLogLineM(false, msgLocal);
 329                 } else {
 330                         msgLocal = wxT("Could not listen for external connections at ") + ip +
 331                                 wxString::Format(wxT(":%d!"), port);
 332                         *msg += msgLocal + wxT("\n");
 333                         AddLogLineM(false, msgLocal);
 334                 }
 335         } else {
 336                 *msg += wxT("External connections disabled in config file\n");
 337                 AddLogLineM(false,_("External connections disabled in config file"));
 338         }
 339         m_ec_notifier = new ECNotifier();
 340 }
 341
 342
 343 ExternalConn::~ExternalConn()
 344 {
 345         KillAllSockets();
 346         delete m_ECServer;
 347         delete m_ec_notifier;
 348 }
 349
 350
 351 void ExternalConn::AddSocket(CECServerSocket *s)
 352 {
 353         wxASSERT(s);
 354         socket_list.insert(s);
 355 }
 356
 357
 358 void ExternalConn::RemoveSocket(CECServerSocket *s)
 359 {
 360         wxASSERT(s);
 361         socket_list.erase(s);
 362 }
 363
 364
 365 void ExternalConn::KillAllSockets()
 366 {
 367         AddDebugLogLineM(false, logGeneral,
 368                 CFormat(wxT("ExternalConn::KillAllSockets(): %d sockets to destroy.")) %
 369                         socket_list.size());
 370         SocketSet::iterator it = socket_list.begin();
 371         while (it != socket_list.end()) {
 372                 CECServerSocket *s = *(it++);
 373                 s->Close();
 374                 s->Destroy();
 375         }
 376 }
 377
 378
 379 void ExternalConn::OnServerEvent(wxSocketEvent& WXUNUSED(event))
 380 {
 381         CECServerSocket *sock = new CECServerSocket(m_ec_notifier);
 382         // Accept new connection if there is one in the pending
 383         // connections queue, else exit. We use Accept(FALSE) for
 384         // non-blocking accept (although if we got here, there
 385         // should ALWAYS be a pending connection).
 386         if ( m_ECServer->AcceptWith(*sock, false) ) {
 387                 AddLogLineM(false, _("New external connection accepted"));
 388         } else {
 389                 delete sock;
 390                 AddLogLineM(false, _("ERROR: couldn't accept a new external connection"));
 391         }
 392
 393 }
 394
 395 //
 396 // Authentication
 397 //
 398 const CECPacket *CECServerSocket::Authenticate(const CECPacket *request)
 399 {
 400         CECPacket *response;
 401
 402         if (request == NULL) {
 403                 return new CECPacket(EC_OP_AUTH_FAIL);
 404         }
 405
 406         // Password must be specified if we are to allow remote connections
 407         if ( thePrefs::ECPassword().IsEmpty() ) {
 408                 AddLogLineM(true, _("External connection refused due to empty password in preferences!"));
 409
 410                 return new CECPacket(EC_OP_AUTH_FAIL);
 411         }
 412
 413         if ((m_conn_state == CONN_INIT) && (request->GetOpCode() == EC_OP_AUTH_REQ) ) {
 414                 const CECTag *clientName = request->GetTagByName(EC_TAG_CLIENT_NAME);
 415                 const CECTag *clientVersion = request->GetTagByName(EC_TAG_CLIENT_VERSION);
 416
 417                 AddLogLineM(false, CFormat( _("Connecting client: %s %s") )
 418                         % ( clientName ? clientName->GetStringData() : wxString(_("Unknown")) )
 419                         % ( clientVersion ? clientVersion->GetStringData() : wxString(_("Unknown version")) ) );
 420                 const CECTag *protocol = request->GetTagByName(EC_TAG_PROTOCOL_VERSION);
 421 #ifdef EC_VERSION_ID
 422                 // For SVN versions, both client and server must use SVNDATE, and they must be the same
 423                 CMD4Hash vhash;
 424                 if (!vhash.Decode(wxT(EC_VERSION_ID))) {
 425                         response = new CECPacket(EC_OP_AUTH_FAIL);
 426                         response->AddTag(CECTag(EC_TAG_STRING, wxT("Fatal error, version hash is not a valid MD4-hash.")));
 427                 } else if (!request->GetTagByName(EC_TAG_VERSION_ID) || request->GetTagByNameSafe(EC_TAG_VERSION_ID)->GetMD4Data() != vhash) {
 428                         response = new CECPacket(EC_OP_AUTH_FAIL);
 429                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Incorrect EC version ID, there might be binary incompatibility. Use core and remote from same snapshot.")));
 430 #else
 431                 // For release versions, we don't want to allow connections from any arbitrary SVN client.
 432                 if (request->GetTagByName(EC_TAG_VERSION_ID)) {
 433                         response = new CECPacket(EC_OP_AUTH_FAIL);
 434                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("You cannot connect to a release version from an arbitrary SVN version! *sigh* possible crash prevented")));
 435 #endif
 436                 } else if (protocol != NULL) {
 437                         uint16 proto_version = protocol->GetInt();
 438                         if (proto_version == EC_CURRENT_PROTOCOL_VERSION) {
 439                                 response = new CECPacket(EC_OP_AUTH_SALT);
 440                                 response->AddTag(CECTag(EC_TAG_PASSWD_SALT, m_passwd_salt));
 441                                 m_conn_state = CONN_SALT_SENT;
 442                         } else {
 443                                 response = new CECPacket(EC_OP_AUTH_FAIL);
 444                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid protocol version.") + wxString::Format(wxT("( %i != %i )"),proto_version,EC_CURRENT_PROTOCOL_VERSION)));
 445                         }
 446                 } else {
 447                         response = new CECPacket(EC_OP_AUTH_FAIL);
 448                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Missing protocol version tag.")));
 449                 }
 450         } else if ((m_conn_state == CONN_SALT_SENT) && (request->GetOpCode() == EC_OP_AUTH_PASSWD)) {
 451                 const CECTag *passwd = request->GetTagByName(EC_TAG_PASSWD_HASH);
 452                 CMD4Hash passh;
 453
 454                 if (!passh.Decode(thePrefs::ECPassword())) {
 455                         wxString err = wxTRANSLATE("Authentication failed: invalid hash specified as EC password.");
 456                         AddLogLineM(false, wxString(wxGetTranslation(err)) + wxT(" ") + thePrefs::ECPassword());
 457                         response = new CECPacket(EC_OP_AUTH_FAIL);
 458                         response->AddTag(CECTag(EC_TAG_STRING, err));
 459                 } else {
 460                         wxString saltHash = MD5Sum(CFormat(wxT("%lX")) % m_passwd_salt).GetHash();
 461                         wxString saltStr = CFormat(wxT("%lX")) % m_passwd_salt;
 462
 463                         passh.Decode(MD5Sum(thePrefs::ECPassword().Lower() + saltHash).GetHash());
 464
 465                         if (passwd && passwd->GetMD4Data() == passh) {
 466                                 response = new CECPacket(EC_OP_AUTH_OK);
 467                                 response->AddTag(CECTag(EC_TAG_SERVER_VERSION, wxT(VERSION)));
 468                         } else {
 469                                 wxString err;
 470                                 if (passwd) {
 471                                         err = wxTRANSLATE("Authentication failed: wrong password.");
 472                                 } else {
 473                                         err = wxTRANSLATE("Authentication failed: missing password.");
 474                                 }
 475
 476                                 response = new CECPacket(EC_OP_AUTH_FAIL);
 477                                 response->AddTag(CECTag(EC_TAG_STRING, err));
 478                                 AddLogLineM(false, wxGetTranslation(err));
 479                         }
 480                 }
 481         } else {
 482                 response = new CECPacket(EC_OP_AUTH_FAIL);
 483                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid request, please authenticate first.")));
 484         }
 485
 486         if (response->GetOpCode() == EC_OP_AUTH_OK) {
 487                 m_conn_state = CONN_ESTABLISHED;
 488                 AddLogLineM(false, _("Access granted."));
 489                 // Establish notification handler if client supports it
 490                 if (HaveNotificationSupport()) {
 491                         theApp->ECServerHandler->m_ec_notifier->Add_EC_Client(this);
 492                 }
 493         } else if (response->GetOpCode() == EC_OP_AUTH_FAIL) {
 494                 // Log message sent to client
 495                 if (response->GetFirstTagSafe()->IsString()) {
 496                         AddLogLineM(false, CFormat(_("Sent error message \"%s\" to client.")) % wxGetTranslation(response->GetFirstTagSafe()->GetStringData()));
 497                 }
 498                 // Access denied!
 499                 AddLogLineM(false, _("Unauthorized access attempt. Connection closed."));
 500                 m_conn_state = CONN_FAILED;
 501         }
 502
 503         return response;
 504 }
 505
 506 // Make a Logger tag (if there are any logging messages) and add it to the response
 507 static void AddLoggerTag(CECPacket *response, CLoggerAccess &LoggerAccess)
 508 {
 509         if (LoggerAccess.HasString()) {
 510                 CECEmptyTag tag(EC_TAG_STATS_LOGGER_MESSAGE);
 511                 // Tag structure is fix: tag carries nothing, inside are the strings
 512                 // maximum of 200 log lines per message
 513                 int entries = 0;
 514                 wxString line;
 515                 while (entries < 200 && LoggerAccess.GetString(line)) {
 516                         tag.AddTag(CECTag(EC_TAG_STRING, line));
 517                         entries++;
 518                 }
 519                 response->AddTag(tag);
 520                 //printf("send Log tag %d %d\n", FirstEntry, entries);
 521         }
 522 }
 523
 524 static CECPacket *Get_EC_Response_StatRequest(const CECPacket *request, CLoggerAccess &LoggerAccess)
 525 {
 526         CECPacket *response = new CECPacket(EC_OP_STATS);
 527
 528         switch (request->GetDetailLevel()) {
 529                 case EC_DETAIL_FULL:
 530                         response->AddTag(CECTag(EC_TAG_STATS_UP_OVERHEAD, (uint32)theStats::GetUpOverheadRate()));
 531                         response->AddTag(CECTag(EC_TAG_STATS_DOWN_OVERHEAD, (uint32)theStats::GetDownOverheadRate()));
 532                         response->AddTag(CECTag(EC_TAG_STATS_BANNED_COUNT, /*(uint32)*/theStats::GetBannedCount()));
 533                         AddLoggerTag(response, LoggerAccess);
 534                 case EC_DETAIL_WEB:
 535                 case EC_DETAIL_CMD:
 536                         response->AddTag(CECTag(EC_TAG_STATS_UL_SPEED, (uint32)theStats::GetUploadRate()));
 537                         response->AddTag(CECTag(EC_TAG_STATS_DL_SPEED, (uint32)(theStats::GetDownloadRate())));
 538                         response->AddTag(CECTag(EC_TAG_STATS_UL_SPEED_LIMIT, (uint32)(thePrefs::GetMaxUpload()*1024.0)));
 539                         response->AddTag(CECTag(EC_TAG_STATS_DL_SPEED_LIMIT, (uint32)(thePrefs::GetMaxDownload()*1024.0)));
 540                         response->AddTag(CECTag(EC_TAG_STATS_UL_QUEUE_LEN, /*(uint32)*/theStats::GetWaitingUserCount()));
 541                         response->AddTag(CECTag(EC_TAG_STATS_TOTAL_SRC_COUNT, /*(uint32)*/theStats::GetFoundSources()));
 542                         // User/Filecounts
 543                         {
 544                                 uint32 totaluser = 0, totalfile = 0;
 545                                 theApp->serverlist->GetUserFileStatus( totaluser, totalfile );
 546                                 response->AddTag(CECTag(EC_TAG_STATS_ED2K_USERS, totaluser));
 547                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_USERS, Kademlia::CKademlia::GetKademliaUsers()));
 548                                 response->AddTag(CECTag(EC_TAG_STATS_ED2K_FILES, totalfile));
 549                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_FILES, Kademlia::CKademlia::GetKademliaFiles()));
 550                         }
 551                         // Kad stats
 552                         if (Kademlia::CKademlia::IsConnected()) {
 553                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_FIREWALLED_UDP, Kademlia::CUDPFirewallTester::IsFirewalledUDP(true)));
 554                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_SOURCES, Kademlia::CKademlia::GetIndexed()->m_totalIndexSource));
 555                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_KEYWORDS, Kademlia::CKademlia::GetIndexed()->m_totalIndexKeyword));
 556                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_NOTES, Kademlia::CKademlia::GetIndexed()->m_totalIndexNotes));
 557                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_INDEXED_LOAD, Kademlia::CKademlia::GetIndexed()->m_totalIndexLoad));
 558                                 response->AddTag(CECTag(EC_TAG_STATS_KAD_IP_ADRESS, wxUINT32_SWAP_ALWAYS(Kademlia::CKademlia::GetPrefs()->GetIPAddress())));
 559                                 response->AddTag(CECTag(EC_TAG_STATS_BUDDY_STATUS, theApp->clientlist->GetBuddyStatus()));
 560                                 uint32 BuddyIP = 0;
 561                                 uint16 BuddyPort = 0;
 562                                 CUpDownClient * Buddy = theApp->clientlist->GetBuddy();
 563                                 if (Buddy) {
 564                                         BuddyIP = Buddy->GetIP();
 565                                         BuddyPort = Buddy->GetUDPPort();
 566                                 }
 567                                 response->AddTag(CECTag(EC_TAG_STATS_BUDDY_IP, BuddyIP));
 568                                 response->AddTag(CECTag(EC_TAG_STATS_BUDDY_PORT, BuddyPort));
 569                         }
 570                 case EC_DETAIL_UPDATE:
 571                 case EC_DETAIL_INC_UPDATE:
 572                         break;
 573         };
 574
 575         return response;
 576 }
 577
 578 static CECPacket *Get_EC_Response_GetSharedFiles(const CECPacket *request, CFileEncoderMap &encoders)
 579 {
 580         wxASSERT(request->GetOpCode() == EC_OP_GET_SHARED_FILES);
 581
 582         CECPacket *response = new CECPacket(EC_OP_SHARED_FILES);
 583
 584         EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
 585         //
 586         // request can contain list of queried items
 587         CTagSet<uint32, EC_TAG_KNOWNFILE> queryitems(request);
 588
 589         encoders.UpdateEncoders();
 590
 591         for (uint32 i = 0; i < theApp->sharedfiles->GetFileCount(); ++i) {
 592                 CKnownFile *cur_file = (CKnownFile *)theApp->sharedfiles->GetFileByIndex(i);
 593
 594                 if ( !cur_file || (!queryitems.empty() && !queryitems.count(cur_file->ECID())) ) {
 595                         continue;
 596                 }
 597
 598                 CEC_SharedFile_Tag filetag(cur_file, detail_level);
 599                 CKnownFile_Encoder *enc = encoders[cur_file->ECID()];
 600                 if ( detail_level != EC_DETAIL_UPDATE ) {
 601                         enc->ResetEncoder();
 602                 }
 603                 enc->Encode(&filetag);
 604                 response->AddTag(filetag);
 605         }
 606         return response;
 607 }
 608
 609 static CECPacket *Get_EC_Response_GetUpdate(CFileEncoderMap &encoders, CObjTagMap &tagmap)
 610 {
 611         CECPacket *response = new CECPacket(EC_OP_SHARED_FILES);
 612
 613         encoders.UpdateEncoders();
 614         for (CFileEncoderMap::iterator it = encoders.begin(); it != encoders.end(); ++it) {
 615                 const CKnownFile *cur_file = it->second->GetFile();
 616                 CValueMap &valuemap = tagmap.GetValueMap(cur_file->ECID());
 617                 if (cur_file->IsCPartFile()) {
 618                         CEC_PartFile_Tag filetag((const CPartFile*) cur_file, EC_DETAIL_INC_UPDATE, &valuemap);
 619                         // Add information if partfile is shared
 620                         filetag.AddTag(EC_TAG_PARTFILE_SHARED, it->second->IsShared(), &valuemap);
 621
 622                         CPartFile_Encoder * enc = (CPartFile_Encoder *) encoders[cur_file->ECID()];
 623                         enc->Encode(&filetag);
 624                         response->AddTag(filetag);
 625                 } else {
 626                         CEC_SharedFile_Tag filetag(cur_file, EC_DETAIL_INC_UPDATE, &valuemap);
 627                         CKnownFile_Encoder * enc = encoders[cur_file->ECID()];
 628                         enc->Encode(&filetag);
 629                         response->AddTag(filetag);
 630                 }
 631         }
 632         return response;
 633 }
 634
 635 static CECPacket *Get_EC_Response_GetClientQueue(const CECPacket *request, CObjTagMap &tagmap, int op)
 636 {
 637         CECPacket *response = new CECPacket(op);
 638
 639         EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
 640
 641         //
 642         // request can contain list of queried items
 643         // (not for incremental update of course)
 644         CTagSet<uint32, EC_TAG_CLIENT> queryitems(request);
 645
 646         const CClientPtrList& clients = (op == EC_OP_WAIT_QUEUE)        ? theApp->uploadqueue->GetWaitingList()
 647                                                                                                                                 : theApp->uploadqueue->GetUploadingList();
 648         CClientPtrList::const_iterator it = clients.begin();
 649         for (; it != clients.end(); ++it) {
 650                 CUpDownClient* cur_client = *it;
 651
 652                 if (!cur_client) {      // shouldn't happen
 653                         continue;
 654                 }
 655                 if (!queryitems.empty() && !queryitems.count(cur_client->ECID())) {
 656                         continue;
 657                 }
 658                 CValueMap *valuemap = NULL;
 659                 if (detail_level == EC_DETAIL_INC_UPDATE) {
 660                         valuemap = &tagmap.GetValueMap(cur_client->ECID());
 661                 }
 662                 CEC_UpDownClient_Tag cli_tag(cur_client, detail_level, valuemap);
 663
 664                 response->AddTag(cli_tag);
 665         }
 666
 667         return response;
 668 }
 669
 670
 671 static CECPacket *Get_EC_Response_GetDownloadQueue(const CECPacket *request, CFileEncoderMap &encoders)
 672 {
 673         CECPacket *response = new CECPacket(EC_OP_DLOAD_QUEUE);
 674
 675         EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
 676         //
 677         // request can contain list of queried items
 678         CTagSet<uint32, EC_TAG_PARTFILE> queryitems(request);
 679
 680         encoders.UpdateEncoders();
 681
 682         for (unsigned int i = 0; i < theApp->downloadqueue->GetFileCount(); i++) {
 683                 CPartFile *cur_file = theApp->downloadqueue->GetFileByIndex(i);
 684
 685                 if ( !queryitems.empty() && !queryitems.count(cur_file->ECID()) ) {
 686                         continue;
 687                 }
 688
 689                 CEC_PartFile_Tag filetag(cur_file, detail_level);
 690
 691                 CPartFile_Encoder * enc = (CPartFile_Encoder *) encoders[cur_file->ECID()];
 692                 if ( detail_level != EC_DETAIL_UPDATE ) {
 693                         enc->ResetEncoder();
 694                 }
 695                 enc->Encode(&filetag);
 696
 697                 response->AddTag(filetag);
 698         }
 699         return response;
 700 }
 701
 702
 703 static CECPacket *Get_EC_Response_PartFile_Cmd(const CECPacket *request)
 704 {
 705         CECPacket *response = NULL;
 706
 707         // request can contain multiple files.
 708         for (CECPacket::const_iterator it1 = request->begin(); it1 != request->end(); it1++) {
 709                 const CECTag &hashtag = *it1;
 710
 711                 wxASSERT(hashtag.GetTagName() == EC_TAG_PARTFILE);
 712
 713                 CMD4Hash hash = hashtag.GetMD4Data();
 714                 CPartFile *pfile = theApp->downloadqueue->GetFileByID( hash );
 715
 716                 if ( !pfile ) {
 717                         AddLogLineM(false,CFormat(_("Remote PartFile command failed: FileHash not found: %s")) % hash.Encode());
 718                         response = new CECPacket(EC_OP_FAILED);
 719                         response->AddTag(CECTag(EC_TAG_STRING, CFormat(wxString(wxTRANSLATE("FileHash not found: %s"))) % hash.Encode()));
 720                         //return response;
 721                         break;
 722                 }
 723                 switch (request->GetOpCode()) {
 724                         case EC_OP_PARTFILE_SWAP_A4AF_THIS:
 725                                 if ((pfile->GetStatus(false) == PS_READY) ||
 726                                         (pfile->GetStatus(false) == PS_EMPTY)) {
 727                                         CPartFile::SourceSet::const_iterator it = pfile->GetA4AFList().begin();
 728                                         while ( it != pfile->GetA4AFList().end() ) {
 729                                                 CUpDownClient *cur_source = *it++;
 730
 731                                                 cur_source->SwapToAnotherFile(true, false, false, pfile);
 732                                         }
 733                                 }
 734                                 break;
 735                         case EC_OP_PARTFILE_SWAP_A4AF_THIS_AUTO:
 736                                 pfile->SetA4AFAuto(!pfile->IsA4AFAuto());
 737                                 break;
 738                         case EC_OP_PARTFILE_SWAP_A4AF_OTHERS:
 739                                 if ((pfile->GetStatus(false) == PS_READY) ||
 740                                     (pfile->GetStatus(false) == PS_EMPTY)) {
 741                                         CPartFile::SourceSet::const_iterator it = pfile->GetSourceList().begin();
 742                                         while ( it != pfile->GetSourceList().end() ) {
 743                                                 CUpDownClient* cur_source = *it++;
 744
 745                                                 cur_source->SwapToAnotherFile(false, false, false, NULL);
 746                                         }
 747                                 }
 748                                 break;
 749                         case EC_OP_PARTFILE_PAUSE:
 750                                 pfile->PauseFile();
 751                                 break;
 752                         case EC_OP_PARTFILE_RESUME:
 753                                 pfile->ResumeFile();
 754                                 pfile->SavePartFile();
 755                                 break;
 756                         case EC_OP_PARTFILE_STOP:
 757                                 pfile->StopFile();
 758                                 break;
 759                         case EC_OP_PARTFILE_PRIO_SET: {
 760                                         uint8 prio = hashtag.GetFirstTagSafe()->GetInt();
 761                                         if ( prio == PR_AUTO ) {
 762                                                 pfile->SetAutoDownPriority(1);
 763                                         } else {
 764                                                 pfile->SetAutoDownPriority(0);
 765                                                 pfile->SetDownPriority(prio);
 766                                         }
 767                                 }
 768                                 break;
 769                         case EC_OP_PARTFILE_DELETE:
 770                                 if ( thePrefs::StartNextFile() && (pfile->GetStatus() != PS_PAUSED) ) {
 771                                         theApp->downloadqueue->StartNextFile(pfile);
 772                                 }
 773                                 pfile->Delete();
 774                                 break;
 775
 776                         case EC_OP_PARTFILE_SET_CAT:
 777                                 pfile->SetCategory(hashtag.GetFirstTagSafe()->GetInt());
 778                                 break;
 779
 780                         default:
 781                                 response = new CECPacket(EC_OP_FAILED);
 782                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("OOPS! OpCode processing error!")));
 783                                 break;
 784                 }
 785         }
 786         if (!response) {
 787                 response = new CECPacket(EC_OP_NOOP);
 788         }
 789         return response;
 790 }
 791
 792 static CECPacket *Get_EC_Response_Server_Add(const CECPacket *request)
 793 {
 794         CECPacket *response = NULL;
 795
 796         const CECTag *srv_tag = request->GetFirstTagSafe();
 797
 798         wxString full_addr = srv_tag->GetTagByName(EC_TAG_SERVER_ADDRESS)->GetStringData();
 799         wxString name = srv_tag->GetTagByName(EC_TAG_SERVER_NAME)->GetStringData();
 800
 801         wxString s_ip = full_addr.Left(full_addr.Find(':'));
 802         wxString s_port = full_addr.Mid(full_addr.Find(':') + 1);
 803
 804         long port = StrToULong(s_port);
 805         CServer* toadd = new CServer(port, s_ip);
 806         toadd->SetListName(name.IsEmpty() ? full_addr : name);
 807
 808         if ( theApp->AddServer(toadd, true) ) {
 809                 response = new CECPacket(EC_OP_NOOP);
 810         } else {
 811                 response = new CECPacket(EC_OP_FAILED);
 812                 response->AddTag(CECTag(EC_TAG_STRING, _("Server not added")));
 813                 delete toadd;
 814         }
 815
 816         return response;
 817 }
 818
 819 static CECPacket *Get_EC_Response_Server(const CECPacket *request)
 820 {
 821         CECPacket *response = NULL;
 822         const CECTag *srv_tag = request->GetFirstTagSafe();
 823         CServer *srv = 0;
 824         if ( srv_tag ) {
 825                 srv = theApp->serverlist->GetServerByIPTCP(srv_tag->GetIPv4Data().IP(), srv_tag->GetIPv4Data().m_port);
 826                 // server tag passed, but server not found
 827                 if ( !srv ) {
 828                         response = new CECPacket(EC_OP_FAILED);
 829                         response->AddTag(CECTag(EC_TAG_STRING,
 830                                                 CFormat(wxString(wxTRANSLATE("server not found: %s"))) % srv_tag->GetIPv4Data().StringIP()));
 831                         return response;
 832                 }
 833         }
 834         switch (request->GetOpCode()) {
 835                 case EC_OP_SERVER_DISCONNECT:
 836                         theApp->serverconnect->Disconnect();
 837                         response = new CECPacket(EC_OP_NOOP);
 838                         break;
 839                 case EC_OP_SERVER_REMOVE:
 840                         if ( srv ) {
 841                                 theApp->serverlist->RemoveServer(srv);
 842                                 response = new CECPacket(EC_OP_NOOP);
 843                         } else {
 844                                 response = new CECPacket(EC_OP_FAILED);
 845                                 response->AddTag(CECTag(EC_TAG_STRING,
 846                                                         wxTRANSLATE("need to define server to be removed")));
 847                         }
 848                         break;
 849                 case EC_OP_SERVER_CONNECT:
 850                         if (thePrefs::GetNetworkED2K()) {
 851                                 if ( srv ) {
 852                                         theApp->serverconnect->ConnectToServer(srv);
 853                                         response = new CECPacket(EC_OP_NOOP);
 854                                 } else {
 855                                         theApp->serverconnect->ConnectToAnyServer();
 856                                         response = new CECPacket(EC_OP_NOOP);
 857                                 }
 858                         } else {
 859                                 response = new CECPacket(EC_OP_FAILED);
 860                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("eD2k is disabled in preferences.")));
 861                         }
 862                         break;
 863         }
 864         if (!response) {
 865                 response = new CECPacket(EC_OP_FAILED);
 866                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("OOPS! OpCode processing error!")));
 867         }
 868         return response;
 869 }
 870
 871 static CECPacket *Get_EC_Response_Search_Results(const CECPacket *request)
 872 {
 873         CECPacket *response = new CECPacket(EC_OP_SEARCH_RESULTS);
 874
 875         EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
 876         //
 877         // request can contain list of queried items
 878         CTagSet<uint32, EC_TAG_SEARCHFILE> queryitems(request);
 879
 880         const CSearchResultList& list = theApp->searchlist->GetSearchResults(0xffffffff);
 881         CSearchResultList::const_iterator it = list.begin();
 882         while (it != list.end()) {
 883                 CSearchFile* sf = *it++;
 884                 if ( !queryitems.empty() && !queryitems.count(sf->ECID()) ) {
 885                         continue;
 886                 }
 887                 response->AddTag(CEC_SearchFile_Tag(sf, detail_level));
 888         }
 889         return response;
 890 }
 891
 892 static CECPacket *Get_EC_Response_Search_Results(CObjTagMap &tagmap)
 893 {
 894         CECPacket *response = new CECPacket(EC_OP_SEARCH_RESULTS);
 895
 896         const CSearchResultList& list = theApp->searchlist->GetSearchResults(0xffffffff);
 897         CSearchResultList::const_iterator it = list.begin();
 898         while (it != list.end()) {
 899                 CSearchFile* sf = *it++;
 900                 CValueMap &valuemap = tagmap.GetValueMap(sf->ECID());
 901                 response->AddTag(CEC_SearchFile_Tag(sf, EC_DETAIL_INC_UPDATE, &valuemap));
 902                 /* Here we could add the children, if amulegui were able to merge them.
 903                 if (sf->HasChildren()) {
 904                         const CSearchResultList& children = sf->GetChildren();
 905                         for (size_t i = 0; i < children.size(); ++i) {
 906                                 CSearchFile* sfc = children.at(i);
 907                                 CValueMap &valuemap1 = tagmap.GetValueMap(sfc->ECID());
 908                                 response->AddTag(CEC_SearchFile_Tag(sfc, EC_DETAIL_INC_UPDATE, &valuemap1));
 909                         }
 910                 }
 911                 */
 912         }
 913         return response;
 914 }
 915
 916 static CECPacket *Get_EC_Response_Search_Results_Download(const CECPacket *request)
 917 {
 918         CECPacket *response = new CECPacket(EC_OP_STRINGS);
 919         for (CECPacket::const_iterator it = request->begin(); it != request->end(); it++) {
 920                 const CECTag &tag = *it;
 921                 CMD4Hash hash = tag.GetMD4Data();
 922                 uint8 category = tag.GetFirstTagSafe()->GetInt();
 923                 theApp->searchlist->AddFileToDownloadByHash(hash, category);
 924         }
 925         return response;
 926 }
 927
 928 static CECPacket *Get_EC_Response_Search_Stop(const CECPacket *WXUNUSED(request))
 929 {
 930         CECPacket *reply = new CECPacket(EC_OP_MISC_DATA);
 931         theApp->searchlist->StopGlobalSearch();
 932         return reply;
 933 }
 934
 935 static CECPacket *Get_EC_Response_Search(const CECPacket *request)
 936 {
 937         wxString response;
 938
 939         CEC_Search_Tag *search_request = (CEC_Search_Tag *)request->GetFirstTagSafe();
 940         theApp->searchlist->RemoveResults(0xffffffff);
 941
 942         CSearchList::CSearchParams params;
 943         params.searchString     = search_request->SearchText();
 944         params.typeText         = search_request->SearchFileType();
 945         params.extension        = search_request->SearchExt();
 946         params.minSize          = search_request->MinSize();
 947         params.maxSize          = search_request->MaxSize();
 948         params.availability     = search_request->Avail();
 949
 950
 951         EC_SEARCH_TYPE search_type = search_request->SearchType();
 952         SearchType core_search_type = LocalSearch;
 953         switch (search_type) {
 954                 case EC_SEARCH_GLOBAL:
 955                         core_search_type = GlobalSearch;
 956                 case EC_SEARCH_KAD:
 957                         if (core_search_type != GlobalSearch) { // Not a global search obviously
 958                                 core_search_type = KadSearch;
 959                         }
 960                 case EC_SEARCH_LOCAL: {
 961                         uint32 search_id = 0xffffffff;
 962                         wxString error = theApp->searchlist->StartNewSearch(&search_id, core_search_type, params);
 963                         if (!error.IsEmpty()) {
 964                                 response = error;
 965                         } else {
 966                                 response = wxTRANSLATE("Search in progress. Refetch results in a moment!");
 967                         }
 968                         break;
 969                 }
 970                 case EC_SEARCH_WEB:
 971                                 response = wxTRANSLATE("WebSearch from remote interface makes no sense.");
 972                         break;
 973         }
 974
 975         CECPacket *reply = new CECPacket(EC_OP_FAILED);
 976         // error or search in progress
 977         reply->AddTag(CECTag(EC_TAG_STRING, response));
 978
 979         return reply;
 980 }
 981
 982 static CECPacket *Get_EC_Response_Set_SharedFile_Prio(const CECPacket *request)
 983 {
 984         CECPacket *response = new CECPacket(EC_OP_NOOP);
 985         for (CECPacket::const_iterator it = request->begin(); it != request->end(); it++) {
 986                 const CECTag &tag = *it;
 987                 CMD4Hash hash = tag.GetMD4Data();
 988                 uint8 prio = tag.GetFirstTagSafe()->GetInt();
 989                 CKnownFile* cur_file = theApp->sharedfiles->GetFileByID(hash);
 990                 if ( !cur_file ) {
 991                         continue;
 992                 }
 993                 if (prio == PR_AUTO) {
 994                         cur_file->SetAutoUpPriority(1);
 995                         cur_file->UpdateAutoUpPriority();
 996                 } else {
 997                         cur_file->SetAutoUpPriority(0);
 998                         cur_file->SetUpPriority(prio);
 999                 }
1000                 Notify_SharedFilesUpdateItem(cur_file);
1001         }
1002
1003         return response;
1004 }
1005
1006 static CECPacket *Get_EC_Response_Kad_Connect(const CECPacket *request)
1007 {
1008         CECPacket *response;
1009         if (thePrefs::GetNetworkKademlia()) {
1010                 response = new CECPacket(EC_OP_NOOP);
1011                 if ( !Kademlia::CKademlia::IsRunning() ) {
1012                         Kademlia::CKademlia::Start();
1013                         theApp->ShowConnectionState();
1014                 }
1015                 const CECTag *addrtag = request->GetFirstTagSafe();
1016                 if ( addrtag ) {
1017                         uint32 ip = addrtag->GetIPv4Data().IP();
1018                         uint16 port = addrtag->GetIPv4Data().m_port;
1019                         Kademlia::CKademlia::Bootstrap(ip, port, true);
1020                 }
1021         } else {
1022                 response = new CECPacket(EC_OP_FAILED);
1023                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Kad is disabled in preferences.")));
1024         }
1025
1026         return response;
1027 }
1028
1029 void CPartFile_Encoder::Encode(CECTag *parent)
1030 {
1031         //
1032         // Source part frequencies
1033         //
1034         CKnownFile_Encoder::Encode(parent);
1035
1036         //
1037         // Gaps
1038         //
1039         const CGapList& gaplist = m_PartFile()->GetNewGapList();
1040         const size_t gap_list_size = gaplist.size();
1041         ArrayOfUInts64 gaps;
1042         gaps.reserve(gap_list_size * 2);
1043
1044         for (CGapList::const_iterator curr_pos = gaplist.begin();
1045                         curr_pos != gaplist.end(); ++curr_pos) {
1046                 gaps.push_back(curr_pos.start());
1047                 gaps.push_back(curr_pos.end());
1048         }
1049
1050         int gap_enc_size = 0;
1051         bool changed;
1052         const uint8 *gap_enc_data = m_gap_status.Encode(gaps, gap_enc_size, changed);
1053         if (changed) {
1054                 parent->AddTag(CECTag(EC_TAG_PARTFILE_GAP_STATUS, gap_enc_size, (void *)gap_enc_data));
1055         }
1056         delete[] gap_enc_data;
1057
1058         //
1059         // Requested blocks
1060         //
1061         ArrayOfUInts64 req_buffer;
1062         const CPartFile::CReqBlockPtrList& requestedblocks = m_PartFile()->GetRequestedBlockList();
1063         CPartFile::CReqBlockPtrList::const_iterator curr_pos2 = requestedblocks.begin();
1064
1065         for ( ; curr_pos2 != requestedblocks.end(); ++curr_pos2 ) {
1066                 Requested_Block_Struct* block = *curr_pos2;
1067                 req_buffer.push_back(block->StartOffset);
1068                 req_buffer.push_back(block->EndOffset);
1069         }
1070         int req_enc_size = 0;
1071         const uint8 *req_enc_data = m_req_status.Encode(req_buffer, req_enc_size, changed);
1072         if (changed) {
1073                 parent->AddTag(CECTag(EC_TAG_PARTFILE_REQ_STATUS, req_enc_size, (void *)req_enc_data));
1074         }
1075         delete[] req_enc_data;
1076
1077         //
1078         // Source names
1079         //
1080         // First count occurrence of all source names
1081         //
1082         CECEmptyTag sourceNames(EC_TAG_PARTFILE_SOURCE_NAMES);
1083         typedef std::map<wxString, int> strIntMap;
1084         strIntMap nameMap;
1085         const CPartFile::SourceSet &sources = m_PartFile()->GetSourceList();
1086         for (CPartFile::SourceSet::const_iterator it = sources.begin(); it != sources.end(); ++it) {
1087                 CUpDownClient *cur_src = *it;
1088                 if (cur_src->GetRequestFile() != m_file || cur_src->GetClientFilename().Length() == 0) {
1089                         continue;
1090                 }
1091                 const wxString &name = cur_src->GetClientFilename();
1092                 strIntMap::iterator itm = nameMap.find(name);
1093                 if (itm == nameMap.end()) {
1094                         nameMap[name] = 1;
1095                 } else {
1096                         itm->second++;
1097                 }
1098         }
1099         //
1100         // Go through our last list
1101         //
1102         for (SourcenameItemMap::iterator it1 = m_sourcenameItemMap.begin(); it1 != m_sourcenameItemMap.end();) {
1103                 SourcenameItemMap::iterator it2 = it1++;
1104                 strIntMap::iterator itm = nameMap.find(it2->second.name);
1105                 if (itm == nameMap.end()) {
1106                         // name doesn't exist anymore, tell client to forget it
1107                         CECTag tag(EC_TAG_PARTFILE_SOURCE_NAMES, it2->first);
1108                         tag.AddTag(CECIntTag(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS, 0));
1109                         sourceNames.AddTag(tag);
1110                         // and forget it
1111                         m_sourcenameItemMap.erase(it2);
1112                 } else {
1113                         // update count if it changed
1114                         if (it2->second.count != itm->second) {
1115                                 CECTag tag(EC_TAG_PARTFILE_SOURCE_NAMES, it2->first);
1116                                 tag.AddTag(CECIntTag(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS, itm->second));
1117                                 sourceNames.AddTag(tag);
1118                                 it2->second.count = itm->second;
1119                         }
1120                         // remove it from nameMap so that only new names are left there
1121                         nameMap.erase(itm);
1122                 }
1123         }
1124         //
1125         // Add new names
1126         //
1127         for (strIntMap::iterator it3 = nameMap.begin(); it3 != nameMap.end(); it3++) {
1128                 int id = ++m_sourcenameID;
1129                 CECIntTag tag(EC_TAG_PARTFILE_SOURCE_NAMES, id);
1130                 tag.AddTag(CECTag(EC_TAG_PARTFILE_SOURCE_NAMES, it3->first));
1131                 tag.AddTag(CECIntTag(EC_TAG_PARTFILE_SOURCE_NAMES_COUNTS, it3->second));
1132                 sourceNames.AddTag(tag);
1133                 // remember it
1134                 m_sourcenameItemMap[id] = SourcenameItem(it3->first, it3->second);
1135         }
1136         if (sourceNames.HasChildTags()) {
1137                 parent->AddTag(sourceNames);
1138         }
1139
1140 }
1141
1142 void CPartFile_Encoder::ResetEncoder()
1143 {
1144         CKnownFile_Encoder::ResetEncoder();
1145         m_gap_status.ResetEncoder();
1146         m_req_status.ResetEncoder();
1147 }
1148
1149 void CKnownFile_Encoder::Encode(CECTag *parent)
1150 {
1151         //
1152         // Source part frequencies
1153         //
1154         // Reference to the availability list
1155         const ArrayOfUInts16& list = m_file->IsPartFile() ?
1156                 ((CPartFile*)m_file)->m_SrcpartFrequency :
1157                 m_file->m_AvailPartFrequency;
1158         // Don't add tag if available parts aren't populated yet.
1159         if (!list.empty()) {
1160                 int part_enc_size;
1161                 bool changed;
1162                 const uint8 *part_enc_data = m_enc_data.Encode(list, part_enc_size, changed);
1163                 if (changed) {
1164                         parent->AddTag(CECTag(EC_TAG_PARTFILE_PART_STATUS, part_enc_size, part_enc_data));
1165                 }
1166                 delete[] part_enc_data;
1167         }
1168 }
1169
1170 static CECPacket *GetStatsGraphs(const CECPacket *request)
1171 {
1172         CECPacket *response = NULL;
1173
1174         switch (request->GetDetailLevel()) {
1175                 case EC_DETAIL_WEB:
1176                 case EC_DETAIL_FULL: {
1177                         double dTimestamp = 0.0;
1178                         if (request->GetTagByName(EC_TAG_STATSGRAPH_LAST) != NULL) {
1179                                 dTimestamp = request->GetTagByName(EC_TAG_STATSGRAPH_LAST)->GetDoubleData();
1180                         }
1181                         uint16 nScale = request->GetTagByNameSafe(EC_TAG_STATSGRAPH_SCALE)->GetInt();
1182                         uint16 nMaxPoints = request->GetTagByNameSafe(EC_TAG_STATSGRAPH_WIDTH)->GetInt();
1183                         uint32 *graphData;
1184                         unsigned int numPoints = theApp->m_statistics->GetHistoryForWeb(nMaxPoints, (double)nScale, &dTimestamp, &graphData);
1185                         if (numPoints) {
1186                                 response = new CECPacket(EC_OP_STATSGRAPHS);
1187                                 response->AddTag(CECTag(EC_TAG_STATSGRAPH_DATA, 4 * numPoints * sizeof(uint32), graphData));
1188                                 delete [] graphData;
1189                                 response->AddTag(CECTag(EC_TAG_STATSGRAPH_LAST, dTimestamp));
1190                         } else {
1191                                 response = new CECPacket(EC_OP_FAILED);
1192                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("No points for graph.")));
1193                         }
1194                         break;
1195                 }
1196                 case EC_DETAIL_INC_UPDATE:
1197                 case EC_DETAIL_UPDATE:
1198                 case EC_DETAIL_CMD:
1199                         // No graphs
1200                         response = new CECPacket(EC_OP_FAILED);
1201                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Your client is not configured for this detail level.")));
1202                         break;
1203         }
1204         if (!response) {
1205                 response = new CECPacket(EC_OP_FAILED);
1206                 // Unknown reason
1207         }
1208
1209         return response;
1210 }
1211
1212 CECPacket *CECServerSocket::ProcessRequest2(const CECPacket *request)
1213 {
1214
1215         if ( !request ) {
1216                 return 0;
1217         }
1218
1219         CECPacket *response = NULL;
1220
1221         switch (request->GetOpCode()) {
1222                 //
1223                 // Misc commands
1224                 //
1225                 case EC_OP_SHUTDOWN:
1226                         if (!theApp->IsOnShutDown()) {
1227                                 response = new CECPacket(EC_OP_NOOP);
1228                                 AddLogLineM(true, _("External Connection: shutdown requested"));
1229 #ifndef AMULE_DAEMON
1230                                 {
1231                                         wxCloseEvent evt;
1232                                         evt.SetCanVeto(false);
1233                                         theApp->ShutDown(evt);
1234                                 }
1235 #else
1236                                 theApp->ExitMainLoop();
1237 #endif
1238                         } else {
1239                                 response = new CECPacket(EC_OP_FAILED);
1240                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Already shutting down.")));
1241                         }
1242                         break;
1243                 case EC_OP_ADD_LINK:
1244                         for (CECPacket::const_iterator it = request->begin(); it != request->end(); it++) {
1245                                 const CECTag &tag = *it;
1246                                 wxString link = tag.GetStringData();
1247                                 int category = 0;
1248                                 const CECTag *cattag = tag.GetTagByName(EC_TAG_PARTFILE_CAT);
1249                                 if (cattag) {
1250                                         category = cattag->GetInt();
1251                                 }
1252                                 AddLogLineM(true, CFormat(_("ExternalConn: adding link '%s'.")) % link);
1253                                 if ( theApp->downloadqueue->AddLink(link, category) ) {
1254                                         response = new CECPacket(EC_OP_NOOP);
1255                                 } else {
1256                                         // Error messages are printed by the add function.
1257                                         response = new CECPacket(EC_OP_FAILED);
1258                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid link or already on list.")));
1259                                 }
1260                         }
1261                         break;
1262                 //
1263                 // Status requests
1264                 //
1265                 case EC_OP_STAT_REQ:
1266                         response = Get_EC_Response_StatRequest(request, m_LoggerAccess);
1267                         response->AddTag(CEC_ConnState_Tag(request->GetDetailLevel()));
1268                         break;
1269                 case EC_OP_GET_CONNSTATE:
1270                         response = new CECPacket(EC_OP_MISC_DATA);
1271                         response->AddTag(CEC_ConnState_Tag(request->GetDetailLevel()));
1272                         break;
1273                 //
1274                 //
1275                 //
1276                 case EC_OP_GET_SHARED_FILES:
1277                         if ( request->GetDetailLevel() != EC_DETAIL_INC_UPDATE ) {
1278                                 response = Get_EC_Response_GetSharedFiles(request, m_FileEncoder);
1279                         }
1280                         break;
1281                 case EC_OP_GET_DLOAD_QUEUE:
1282                         if ( request->GetDetailLevel() != EC_DETAIL_INC_UPDATE ) {
1283                                 response = Get_EC_Response_GetDownloadQueue(request, m_FileEncoder);
1284                         }
1285                         break;
1286                 //
1287                 // This will evolve into an update-all for inc tags
1288                 //
1289                 case EC_OP_GET_UPDATE:
1290                         if ( request->GetDetailLevel() == EC_DETAIL_INC_UPDATE ) {
1291                                 response = Get_EC_Response_GetUpdate(m_FileEncoder, m_obj_tagmap);
1292                         }
1293                         break;
1294                 case EC_OP_GET_ULOAD_QUEUE:
1295                         response = Get_EC_Response_GetClientQueue(request, m_obj_tagmap, EC_OP_ULOAD_QUEUE);
1296                         break;
1297                 case EC_OP_GET_WAIT_QUEUE:
1298                         response = Get_EC_Response_GetClientQueue(request, m_obj_tagmap, EC_OP_WAIT_QUEUE);
1299                         break;
1300                 case EC_OP_PARTFILE_REMOVE_NO_NEEDED:
1301                 case EC_OP_PARTFILE_REMOVE_FULL_QUEUE:
1302                 case EC_OP_PARTFILE_REMOVE_HIGH_QUEUE:
1303                 case EC_OP_PARTFILE_CLEANUP_SOURCES:
1304                 case EC_OP_PARTFILE_SWAP_A4AF_THIS:
1305                 case EC_OP_PARTFILE_SWAP_A4AF_THIS_AUTO:
1306                 case EC_OP_PARTFILE_SWAP_A4AF_OTHERS:
1307                 case EC_OP_PARTFILE_PAUSE:
1308                 case EC_OP_PARTFILE_RESUME:
1309                 case EC_OP_PARTFILE_STOP:
1310                 case EC_OP_PARTFILE_PRIO_SET:
1311                 case EC_OP_PARTFILE_DELETE:
1312                 case EC_OP_PARTFILE_SET_CAT:
1313                         response = Get_EC_Response_PartFile_Cmd(request);
1314                         break;
1315                 case EC_OP_SHAREDFILES_RELOAD:
1316                         theApp->sharedfiles->Reload();
1317                         response = new CECPacket(EC_OP_NOOP);
1318                         break;
1319                 case EC_OP_SHARED_SET_PRIO:
1320                         response = Get_EC_Response_Set_SharedFile_Prio(request);
1321                         break;
1322                 case EC_OP_RENAME_FILE: {
1323                         CMD4Hash fileHash = request->GetTagByNameSafe(EC_TAG_KNOWNFILE)->GetMD4Data();
1324                         CKnownFile* file = theApp->knownfiles->FindKnownFileByID(fileHash);
1325                         wxString newName = request->GetTagByNameSafe(EC_TAG_PARTFILE_NAME)->GetStringData();
1326                         if (!file) {
1327                                 file = theApp->downloadqueue->GetFileByID(fileHash);
1328                         }
1329                         if (!file) {
1330                                 response = new CECPacket(EC_OP_FAILED);
1331                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("File not found.")));
1332                                 break;
1333                         }
1334                         if (newName.IsEmpty()) {
1335                                 response = new CECPacket(EC_OP_FAILED);
1336                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid file name.")));
1337                                 break;
1338                         }
1339
1340                         if (theApp->sharedfiles->RenameFile(file, CPath(newName))) {
1341                                 response = new CECPacket(EC_OP_NOOP);
1342                         } else {
1343                                 response = new CECPacket(EC_OP_FAILED);
1344                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Unable to rename file.")));
1345                         }
1346
1347                         break;
1348                 }
1349
1350
1351                 //
1352                 // Server commands
1353                 //
1354                 case EC_OP_SERVER_ADD:
1355                         response = Get_EC_Response_Server_Add(request);
1356                         break;
1357                 case EC_OP_SERVER_DISCONNECT:
1358                 case EC_OP_SERVER_CONNECT:
1359                 case EC_OP_SERVER_REMOVE:
1360                         response = Get_EC_Response_Server(request);
1361                         break;
1362                 case EC_OP_GET_SERVER_LIST: {
1363                                 response = new CECPacket(EC_OP_SERVER_LIST);
1364                                 if (!thePrefs::GetNetworkED2K()) {
1365                                         // Kad only: just send an empty list
1366                                         break;
1367                                 }
1368                                 EC_DETAIL_LEVEL detail_level = request->GetDetailLevel();
1369                                 std::vector<const CServer*> servers = theApp->serverlist->CopySnapshot();
1370                                 for (
1371                                         std::vector<const CServer*>::const_iterator it = servers.begin();
1372                                         it != servers.end();
1373                                         ++it
1374                                         ) {
1375                                         response->AddTag(CEC_Server_Tag(*it, detail_level));
1376                                 }
1377                         }
1378                         break;
1379                 case EC_OP_SERVER_UPDATE_FROM_URL: {
1380                         wxString url = request->GetFirstTagSafe()->GetStringData();
1381
1382                         // Save the new url, and update the UI (if not amuled).
1383                         Notify_ServersURLChanged(url);
1384                         thePrefs::SetEd2kServersUrl(url);
1385
1386                         theApp->serverlist->UpdateServerMetFromURL(url);
1387                         response = new CECPacket(EC_OP_NOOP);
1388                         break;
1389                 }
1390                 //
1391                 // IPFilter
1392                 //
1393                 case EC_OP_IPFILTER_RELOAD:
1394                         theApp->ipfilter->Reload();
1395                         response = new CECPacket(EC_OP_NOOP);
1396                         break;
1397
1398                 case EC_OP_IPFILTER_UPDATE: {
1399                         wxString url = request->GetFirstTagSafe()->GetStringData();
1400                         if (url == wxEmptyString) {
1401                                 url = thePrefs::IPFilterURL();
1402                         }
1403                         theApp->ipfilter->Update(url);
1404                         response = new CECPacket(EC_OP_NOOP);
1405                         break;
1406                 }
1407                 //
1408                 // Search
1409                 //
1410                 case EC_OP_SEARCH_START:
1411                         response = Get_EC_Response_Search(request);
1412                         break;
1413
1414                 case EC_OP_SEARCH_STOP:
1415                         response = Get_EC_Response_Search_Stop(request);
1416                         break;
1417
1418                 case EC_OP_SEARCH_RESULTS:
1419                         if ( request->GetDetailLevel() == EC_DETAIL_INC_UPDATE ) {
1420                                 response = Get_EC_Response_Search_Results(m_obj_tagmap);
1421                         } else {
1422                                 response = Get_EC_Response_Search_Results(request);
1423                         }
1424                         break;
1425
1426                 case EC_OP_SEARCH_PROGRESS:
1427                         response = new CECPacket(EC_OP_SEARCH_PROGRESS);
1428                         response->AddTag(CECTag(EC_TAG_SEARCH_STATUS,
1429                                 theApp->searchlist->GetSearchProgress()));
1430                         break;
1431
1432                 case EC_OP_DOWNLOAD_SEARCH_RESULT:
1433                         response = Get_EC_Response_Search_Results_Download(request);
1434                         break;
1435                 //
1436                 // Preferences
1437                 //
1438                 case EC_OP_GET_PREFERENCES:
1439                         response = new CEC_Prefs_Packet(request->GetTagByNameSafe(EC_TAG_SELECT_PREFS)->GetInt(), request->GetDetailLevel());
1440                         break;
1441                 case EC_OP_SET_PREFERENCES:
1442                         ((CEC_Prefs_Packet *)request)->Apply();
1443                         theApp->glob_prefs->Save();
1444                         if (thePrefs::IsFilteringClients()) {
1445                                 theApp->clientlist->FilterQueues();
1446                         }
1447                         if (thePrefs::IsFilteringServers()) {
1448                                 theApp->serverlist->FilterServers();
1449                         }
1450                         if (!thePrefs::GetNetworkED2K() && theApp->IsConnectedED2K()) {
1451                                 theApp->DisconnectED2K();
1452                         }
1453                         if (!thePrefs::GetNetworkKademlia() && theApp->IsConnectedKad()) {
1454                                 theApp->StopKad();
1455                         }
1456                         response = new CECPacket(EC_OP_NOOP);
1457                         break;
1458
1459                 case EC_OP_CREATE_CATEGORY:
1460                         if ( request->GetTagCount() == 1 ) {
1461                                 CEC_Category_Tag *tag = (CEC_Category_Tag *)request->GetFirstTagSafe();
1462                                 if (tag->Create()) {
1463                                         response = new CECPacket(EC_OP_NOOP);
1464                                 } else {
1465                                         response = new CECPacket(EC_OP_FAILED);
1466                                         response->AddTag(CECTag(EC_TAG_CATEGORY, theApp->glob_prefs->GetCatCount() - 1));
1467                                         response->AddTag(CECTag(EC_TAG_CATEGORY_PATH, tag->Path()));
1468                                 }
1469                                 Notify_CategoryAdded();
1470                         } else {
1471                                 response = new CECPacket(EC_OP_NOOP);
1472                         }
1473                         break;
1474                 case EC_OP_UPDATE_CATEGORY:
1475                         if ( request->GetTagCount() == 1 ) {
1476                                 CEC_Category_Tag *tag = (CEC_Category_Tag *)request->GetFirstTagSafe();
1477                                 if (tag->Apply()) {
1478                                         response = new CECPacket(EC_OP_NOOP);
1479                                 } else {
1480                                         response = new CECPacket(EC_OP_FAILED);
1481                                         response->AddTag(CECTag(EC_TAG_CATEGORY, tag->GetInt()));
1482                                         response->AddTag(CECTag(EC_TAG_CATEGORY_PATH, tag->Path()));
1483                                 }
1484                                 Notify_CategoryUpdate(tag->GetInt());
1485                         } else {
1486                                 response = new CECPacket(EC_OP_NOOP);
1487                         }
1488                         break;
1489                 case EC_OP_DELETE_CATEGORY:
1490                         if ( request->GetTagCount() == 1 ) {
1491                                 uint32 cat = request->GetFirstTagSafe()->GetInt();
1492                                 // this noes not only update the gui, but actually deletes the cat
1493                                 Notify_CategoryDelete(cat);
1494                         }
1495                         response = new CECPacket(EC_OP_NOOP);
1496                         break;
1497
1498                 //
1499                 // Logging
1500                 //
1501                 case EC_OP_ADDLOGLINE:
1502                         AddLogLineM( (request->GetTagByName(EC_TAG_LOG_TO_STATUS) != NULL), request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData() );
1503                         response = new CECPacket(EC_OP_NOOP);
1504                         break;
1505                 case EC_OP_ADDDEBUGLOGLINE:
1506                         AddDebugLogLineM( (request->GetTagByName(EC_TAG_LOG_TO_STATUS) != NULL), logGeneral, request->GetTagByNameSafe(EC_TAG_STRING)->GetStringData() );
1507                         response = new CECPacket(EC_OP_NOOP);
1508                         break;
1509                 case EC_OP_GET_LOG:
1510                         response = new CECPacket(EC_OP_LOG);
1511                         response->AddTag(CECTag(EC_TAG_STRING, theApp->GetLog(false)));
1512                         break;
1513                 case EC_OP_GET_DEBUGLOG:
1514                         response = new CECPacket(EC_OP_DEBUGLOG);
1515                         response->AddTag(CECTag(EC_TAG_STRING, theApp->GetDebugLog(false)));
1516                         break;
1517                 case EC_OP_RESET_LOG:
1518                         theApp->GetLog(true);
1519                         response = new CECPacket(EC_OP_NOOP);
1520                         break;
1521                 case EC_OP_RESET_DEBUGLOG:
1522                         theApp->GetDebugLog(true);
1523                         response = new CECPacket(EC_OP_NOOP);
1524                         break;
1525                 case EC_OP_GET_LAST_LOG_ENTRY:
1526                         {
1527                                 wxString tmp = theApp->GetLog(false);
1528                                 if (tmp.Last() == '\n') {
1529                                         tmp.RemoveLast();
1530                                 }
1531                                 response = new CECPacket(EC_OP_LOG);
1532                                 response->AddTag(CECTag(EC_TAG_STRING, tmp.AfterLast('\n')));
1533                         }
1534                         break;
1535                 case EC_OP_GET_SERVERINFO:
1536                         response = new CECPacket(EC_OP_SERVERINFO);
1537                         response->AddTag(CECTag(EC_TAG_STRING, theApp->GetServerLog(false)));
1538                         break;
1539                 case EC_OP_CLEAR_SERVERINFO:
1540                         theApp->GetServerLog(true);
1541                         response = new CECPacket(EC_OP_NOOP);
1542                         break;
1543                 //
1544                 // Statistics
1545                 //
1546                 case EC_OP_GET_STATSGRAPHS:
1547                         response = GetStatsGraphs(request);
1548                         break;
1549                 case EC_OP_GET_STATSTREE: {
1550                         theApp->m_statistics->UpdateStatsTree();
1551                         response = new CECPacket(EC_OP_STATSTREE);
1552                         CECTag* tree = theStats::GetECStatTree(request->GetTagByNameSafe(EC_TAG_STATTREE_CAPPING)->GetInt());
1553                         if (tree) {
1554                                 response->AddTag(*tree);
1555                                 delete tree;
1556                         }
1557                         if (request->GetDetailLevel() == EC_DETAIL_WEB) {
1558                                 response->AddTag(CECTag(EC_TAG_SERVER_VERSION, wxT(VERSION)));
1559                                 response->AddTag(CECTag(EC_TAG_USER_NICK, thePrefs::GetUserNick()));
1560                         }
1561                         break;
1562                 }
1563
1564                 //
1565                 // Kad
1566                 //
1567                 case EC_OP_KAD_START:
1568                         response = Get_EC_Response_Kad_Connect(request);
1569                         break;
1570                 case EC_OP_KAD_STOP:
1571                         theApp->StopKad();
1572                         response = new CECPacket(EC_OP_NOOP);
1573                         break;
1574                 case EC_OP_KAD_UPDATE_FROM_URL: {
1575                         wxString url = request->GetFirstTagSafe()->GetStringData();
1576
1577                         // Save the new url, and update the UI (if not amuled).
1578                         Notify_NodesURLChanged(url);
1579                         thePrefs::SetKadNodesUrl(url);
1580
1581                         theApp->UpdateNotesDat(url);
1582                         response = new CECPacket(EC_OP_NOOP);
1583                         break;
1584                 }
1585                 case EC_OP_KAD_BOOTSTRAP_FROM_IP:
1586                         theApp->BootstrapKad(request->GetTagByNameSafe(EC_TAG_BOOTSTRAP_IP)->GetInt(),
1587                                              request->GetTagByNameSafe(EC_TAG_BOOTSTRAP_PORT)->GetInt());
1588                         response = new CECPacket(EC_OP_NOOP);
1589                         break;
1590
1591                 //
1592                 // Networks
1593                 //
1594                 case EC_OP_CONNECT:
1595                         if (thePrefs::GetNetworkED2K()) {
1596                                 response = new CECPacket(EC_OP_STRINGS);
1597                                 if (theApp->IsConnectedED2K()) {
1598                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Already connected to eD2k.")));
1599                                 } else {
1600                                         theApp->serverconnect->ConnectToAnyServer();
1601                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Connecting to eD2k...")));
1602                                 }
1603                         }
1604                         if (thePrefs::GetNetworkKademlia()) {
1605                                 if (!response) {
1606                                         response = new CECPacket(EC_OP_STRINGS);
1607                                 }
1608                                 if (theApp->IsConnectedKad()) {
1609                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Already connected to Kad.")));
1610                                 } else {
1611                                         theApp->StartKad();
1612                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Connecting to Kad...")));
1613                                 }
1614                         }
1615                         if (!response) {
1616                                 response = new CECPacket(EC_OP_FAILED);
1617                                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("All networks are disabled.")));
1618                         }
1619                         break;
1620                 case EC_OP_DISCONNECT:
1621                         if (theApp->IsConnected()) {
1622                                 response = new CECPacket(EC_OP_STRINGS);
1623                                 if (theApp->IsConnectedED2K()) {
1624                                         theApp->serverconnect->Disconnect();
1625                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Disconnected from eD2k.")));
1626                                 }
1627                                 if (theApp->IsConnectedKad()) {
1628                                         theApp->StopKad();
1629                                         response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Disconnected from Kad.")));
1630                                 }
1631                         } else {
1632                                 response = new CECPacket(EC_OP_NOOP);
1633                         }
1634                         break;
1635         }
1636         if (!response) {
1637                 AddLogLineM(false, wxString::Format(_("External Connection: invalid opcode received: %#x"), request->GetOpCode()));
1638                 wxFAIL;
1639                 response = new CECPacket(EC_OP_FAILED);
1640                 response->AddTag(CECTag(EC_TAG_STRING, wxTRANSLATE("Invalid opcode (wrong protocol version?)")));
1641         }
1642         return response;
1643 }
1644
1645 /*
1646  * Here notification-based EC. Notification will be sorted by priority for possible throttling.
1647  */
1648
1649 /*
1650  * Core general status
1651  */
1652 ECStatusMsgSource::ECStatusMsgSource()
1653 {
1654         m_last_ed2k_status_sent = 0xffffffff;
1655         m_last_kad_status_sent = 0xffffffff;
1656         m_server = (void *)0xffffffff;
1657 }
1658
1659 uint32 ECStatusMsgSource::GetEd2kStatus()
1660 {
1661         if ( theApp->IsConnectedED2K() ) {
1662                 return theApp->GetED2KID();
1663         } else if ( theApp->serverconnect->IsConnecting() ) {
1664                 return 1;
1665         } else {
1666                 return 0;
1667         }
1668 }
1669
1670 uint32 ECStatusMsgSource::GetKadStatus()
1671 {
1672         if ( theApp->IsConnectedKad() ) {
1673                 return 1;
1674         } else if ( Kademlia::CKademlia::IsFirewalled() ) {
1675                 return 2;
1676         } else if ( Kademlia::CKademlia::IsRunning() ) {
1677                 return 3;
1678         }
1679         return 0;
1680 }
1681
1682 CECPacket *ECStatusMsgSource::GetNextPacket()
1683 {
1684         if ( (m_last_ed2k_status_sent != GetEd2kStatus()) ||
1685                 (m_last_kad_status_sent != GetKadStatus()) ||
1686                 (m_server != theApp->serverconnect->GetCurrentServer()) ) {
1687
1688                 m_last_ed2k_status_sent = GetEd2kStatus();
1689                 m_last_kad_status_sent = GetKadStatus();
1690                 m_server = theApp->serverconnect->GetCurrentServer();
1691
1692                 CECPacket *response = new CECPacket(EC_OP_STATS);
1693                 response->AddTag(CEC_ConnState_Tag(EC_DETAIL_UPDATE));
1694                 return response;
1695         }
1696         return 0;
1697 }
1698
1699 /*
1700  * Downloading files
1701 */
1702 ECPartFileMsgSource::ECPartFileMsgSource()
1703 {
1704         for (unsigned int i = 0; i < theApp->downloadqueue->GetFileCount(); i++) {
1705                 CPartFile *cur_file = theApp->downloadqueue->GetFileByIndex(i);
1706                 PARTFILE_STATUS status = { true, false, false, false, true, cur_file };
1707                 m_dirty_status[cur_file->GetFileHash()] = status;
1708         }
1709 }
1710
1711 void ECPartFileMsgSource::SetDirty(CPartFile *file)
1712 {
1713         CMD4Hash filehash = file->GetFileHash();
1714         if ( m_dirty_status.find(filehash) != m_dirty_status.end() ) {
1715                 m_dirty_status[filehash].m_dirty = true;;
1716         }
1717 }
1718
1719 void ECPartFileMsgSource::SetNew(CPartFile *file)
1720 {
1721         CMD4Hash filehash = file->GetFileHash();
1722         wxASSERT ( m_dirty_status.find(filehash) == m_dirty_status.end() );
1723         PARTFILE_STATUS status = { true, false, false, false, true, file };
1724         m_dirty_status[filehash] = status;
1725 }
1726
1727 void ECPartFileMsgSource::SetCompleted(CPartFile *file)
1728 {
1729         CMD4Hash filehash = file->GetFileHash();
1730         wxASSERT ( m_dirty_status.find(filehash) != m_dirty_status.end() );
1731
1732         m_dirty_status[filehash].m_finished = true;
1733 }
1734
1735 void ECPartFileMsgSource::SetRemoved(CPartFile *file)
1736 {
1737         CMD4Hash filehash = file->GetFileHash();
1738         wxASSERT ( m_dirty_status.find(filehash) != m_dirty_status.end() );
1739
1740         m_dirty_status[filehash].m_removed = true;
1741 }
1742
1743 CECPacket *ECPartFileMsgSource::GetNextPacket()
1744 {
1745         for(std::map<CMD4Hash, PARTFILE_STATUS>::iterator it = m_dirty_status.begin();
1746                 it != m_dirty_status.end(); it++) {
1747                 if ( it->second.m_new || it->second.m_dirty || it->second.m_removed) {
1748                         CMD4Hash filehash = it->first;
1749
1750                         CPartFile *partfile = it->second.m_file;
1751
1752                         CECPacket *packet = new CECPacket(EC_OP_DLOAD_QUEUE);
1753                         if ( it->second.m_removed ) {
1754                                 CECTag tag(EC_TAG_PARTFILE, filehash);
1755                                 packet->AddTag(tag);
1756                                 m_dirty_status.erase(it);
1757                         } else {
1758                                 CEC_PartFile_Tag tag(partfile, it->second.m_new ? EC_DETAIL_FULL : EC_DETAIL_UPDATE);
1759                                 packet->AddTag(tag);
1760                         }
1761                         m_dirty_status[filehash].m_new = false;
1762                         m_dirty_status[filehash].m_dirty = false;
1763
1764                         return packet;
1765                 }
1766         }
1767         return 0;
1768 }
1769
1770 /*
1771  * Shared files - similar to downloading
1772  */
1773 ECKnownFileMsgSource::ECKnownFileMsgSource()
1774 {
1775         for (unsigned int i = 0; i < theApp->sharedfiles->GetFileCount(); i++) {
1776                 CKnownFile *cur_file = (CKnownFile *)theApp->sharedfiles->GetFileByIndex(i);
1777                 KNOWNFILE_STATUS status = { true, false, false, true, cur_file };
1778                 m_dirty_status[cur_file->GetFileHash()] = status;
1779         }
1780 }
1781
1782 void ECKnownFileMsgSource::SetDirty(CKnownFile *file)
1783 {
1784         CMD4Hash filehash = file->GetFileHash();
1785         if ( m_dirty_status.find(filehash) != m_dirty_status.end() ) {
1786                 m_dirty_status[filehash].m_dirty = true;;
1787         }
1788 }
1789
1790 void ECKnownFileMsgSource::SetNew(CKnownFile *file)
1791 {
1792         CMD4Hash filehash = file->GetFileHash();
1793         wxASSERT ( m_dirty_status.find(filehash) == m_dirty_status.end() );
1794         KNOWNFILE_STATUS status = { true, false, false, true, file };
1795         m_dirty_status[filehash] = status;
1796 }
1797
1798 void ECKnownFileMsgSource::SetRemoved(CKnownFile *file)
1799 {
1800         CMD4Hash filehash = file->GetFileHash();
1801         wxASSERT ( m_dirty_status.find(filehash) != m_dirty_status.end() );
1802
1803         m_dirty_status[filehash].m_removed = true;
1804 }
1805
1806 CECPacket *ECKnownFileMsgSource::GetNextPacket()
1807 {
1808         for(std::map<CMD4Hash, KNOWNFILE_STATUS>::iterator it = m_dirty_status.begin();
1809                 it != m_dirty_status.end(); it++) {
1810                 if ( it->second.m_new || it->second.m_dirty || it->second.m_removed) {
1811                         CMD4Hash filehash = it->first;
1812
1813                         CKnownFile *partfile = it->second.m_file;
1814
1815                         CECPacket *packet = new CECPacket(EC_OP_SHARED_FILES);
1816                         if ( it->second.m_removed ) {
1817                                 CECTag tag(EC_TAG_PARTFILE, filehash);
1818                                 packet->AddTag(tag);
1819                                 m_dirty_status.erase(it);
1820                         } else {
1821                                 CEC_SharedFile_Tag tag(partfile, it->second.m_new ? EC_DETAIL_FULL : EC_DETAIL_UPDATE);
1822                                 packet->AddTag(tag);
1823                         }
1824                         m_dirty_status[filehash].m_new = false;
1825                         m_dirty_status[filehash].m_dirty = false;
1826
1827                         return packet;
1828                 }
1829         }
1830         return 0;
1831 }
1832
1833 /*
1834  * Notification about search status
1835 */
1836 ECSearchMsgSource::ECSearchMsgSource()
1837 {
1838 }
1839
1840 CECPacket *ECSearchMsgSource::GetNextPacket()
1841 {
1842         if ( m_dirty_status.empty() ) {
1843                 return 0;
1844         }
1845
1846         CECPacket *response = new CECPacket(EC_OP_SEARCH_RESULTS);
1847         for(std::map<CMD4Hash, SEARCHFILE_STATUS>::iterator it = m_dirty_status.begin();
1848                 it != m_dirty_status.end(); it++) {
1849
1850                 if ( it->second.m_new ) {
1851                         response->AddTag(CEC_SearchFile_Tag(it->second.m_file, EC_DETAIL_FULL));
1852                         it->second.m_new = false;
1853                 } else if ( it->second.m_dirty ) {
1854                         response->AddTag(CEC_SearchFile_Tag(it->second.m_file, EC_DETAIL_UPDATE));
1855                 }
1856
1857         }
1858
1859         return response;
1860 }
1861
1862 void ECSearchMsgSource::FlushStatus()
1863 {
1864         m_dirty_status.clear();
1865 }
1866
1867 void ECSearchMsgSource::SetDirty(CSearchFile *file)
1868 {
1869         if ( m_dirty_status.count(file->GetFileHash()) ) {
1870                 m_dirty_status[file->GetFileHash()].m_dirty = true;
1871         } else {
1872                 m_dirty_status[file->GetFileHash()].m_new = true;
1873                 m_dirty_status[file->GetFileHash()].m_dirty = true;
1874                 m_dirty_status[file->GetFileHash()].m_child_dirty = true;
1875                 m_dirty_status[file->GetFileHash()].m_file = file;
1876         }
1877 }
1878
1879 void ECSearchMsgSource::SetChildDirty(CSearchFile *file)
1880 {
1881         m_dirty_status[file->GetFileHash()].m_child_dirty = true;
1882 }
1883
1884 /*
1885  * Notification about uploading clients
1886  */
1887 CECPacket *ECClientMsgSource::GetNextPacket()
1888 {
1889         return 0;
1890 }
1891
1892 //
1893 // Notification iface per-client
1894 //
1895 ECNotifier::ECNotifier()
1896 {
1897 }
1898
1899 ECNotifier::~ECNotifier()
1900 {
1901         while (m_msg_source.begin() != m_msg_source.end())
1902                 Remove_EC_Client(m_msg_source.begin()->first);
1903 }
1904
1905 CECPacket *ECNotifier::GetNextPacket(ECUpdateMsgSource *msg_source_array[])
1906 {
1907         CECPacket *packet = 0;
1908         //
1909         // priority 0 is highest
1910         //
1911         for(int i = 0; i < EC_STATUS_LAST_PRIO; i++) {
1912                 if ( (packet = msg_source_array[i]->GetNextPacket()) != 0 ) {
1913                         break;
1914                 }
1915         }
1916         return packet;
1917 }
1918
1919 CECPacket *ECNotifier::GetNextPacket(CECServerSocket *sock)
1920 {
1921         //
1922         // OnOutput is called for a first time before
1923         // socket is registered
1924         //
1925         if ( m_msg_source.count(sock) ) {
1926                 ECUpdateMsgSource **notifier_array = m_msg_source[sock];
1927                 if ( !notifier_array ) {
1928                         return 0;
1929                 }
1930                 CECPacket *packet = GetNextPacket(notifier_array);
1931                 printf("[EC] next update packet; opcode=%x\n",packet ? packet->GetOpCode() : 0xff);
1932                 return packet;
1933         } else {
1934                 return 0;
1935         }
1936 }
1937
1938 //
1939 // Interface to notification macros
1940 //
1941 void ECNotifier::DownloadFile_SetDirty(CPartFile *file)
1942 {
1943         for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
1944                 i != m_msg_source.end(); i++) {
1945                 CECServerSocket *sock = i->first;
1946                 if ( sock->HaveNotificationSupport() ) {
1947                         ECUpdateMsgSource **notifier_array = i->second;
1948                         ((ECPartFileMsgSource *)notifier_array[EC_PARTFILE])->SetDirty(file);
1949                 }
1950         }
1951         NextPacketToSocket();
1952 }
1953
1954 void ECNotifier::DownloadFile_RemoveFile(CPartFile *file)
1955 {
1956         for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
1957                 i != m_msg_source.end(); i++) {
1958                 ECUpdateMsgSource **notifier_array = i->second;
1959                 ((ECPartFileMsgSource *)notifier_array[EC_PARTFILE])->SetRemoved(file);
1960         }
1961         NextPacketToSocket();
1962 }
1963
1964 void ECNotifier::DownloadFile_RemoveSource(CPartFile *)
1965 {
1966         // per-partfile source list is not supported (yet), and IMHO quite useless
1967 }
1968
1969 void ECNotifier::DownloadFile_AddFile(CPartFile *file)
1970 {
1971         for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
1972                 i != m_msg_source.end(); i++) {
1973                 ECUpdateMsgSource **notifier_array = i->second;
1974                 ((ECPartFileMsgSource *)notifier_array[EC_PARTFILE])->SetNew(file);
1975         }
1976         NextPacketToSocket();
1977 }
1978
1979 void ECNotifier::DownloadFile_AddSource(CPartFile *)
1980 {
1981         // per-partfile source list is not supported (yet), and IMHO quite useless
1982 }
1983
1984 void ECNotifier::SharedFile_AddFile(CKnownFile *file)
1985 {
1986         for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
1987                 i != m_msg_source.end(); i++) {
1988                 ECUpdateMsgSource **notifier_array = i->second;
1989                 ((ECKnownFileMsgSource *)notifier_array[EC_KNOWN])->SetNew(file);
1990         }
1991         NextPacketToSocket();
1992 }
1993
1994 void ECNotifier::SharedFile_RemoveFile(CKnownFile *file)
1995 {
1996         for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
1997                 i != m_msg_source.end(); i++) {
1998                 ECUpdateMsgSource **notifier_array = i->second;
1999                 ((ECKnownFileMsgSource *)notifier_array[EC_KNOWN])->SetRemoved(file);
2000         }
2001         NextPacketToSocket();
2002 }
2003
2004 void ECNotifier::SharedFile_RemoveAllFiles()
2005 {
2006         // need to figure out what to do here
2007 }
2008
2009 void ECNotifier::Add_EC_Client(CECServerSocket *sock)
2010 {
2011         ECUpdateMsgSource **notifier_array = new ECUpdateMsgSource *[EC_STATUS_LAST_PRIO];
2012         notifier_array[EC_STATUS] = new ECStatusMsgSource();
2013         notifier_array[EC_SEARCH] = new ECSearchMsgSource();
2014         notifier_array[EC_PARTFILE] = new ECPartFileMsgSource();
2015         notifier_array[EC_CLIENT] = new ECClientMsgSource();
2016         notifier_array[EC_KNOWN] = new ECKnownFileMsgSource();
2017
2018         m_msg_source[sock] = notifier_array;
2019 }
2020
2021 void ECNotifier::Remove_EC_Client(CECServerSocket *sock)
2022 {
2023         if (m_msg_source.count(sock)) {
2024                 ECUpdateMsgSource **notifier_array = m_msg_source[sock];
2025
2026                 m_msg_source.erase(sock);
2027
2028                 for(int i = 0; i < EC_STATUS_LAST_PRIO; i++) {
2029                         delete notifier_array[i];
2030                 }
2031                 delete [] notifier_array;
2032         }
2033 }
2034
2035 void ECNotifier::NextPacketToSocket()
2036 {
2037         for(std::map<CECServerSocket *, ECUpdateMsgSource **>::iterator i = m_msg_source.begin();
2038                 i != m_msg_source.end(); i++) {
2039                 CECServerSocket *sock = i->first;
2040                 if ( sock->HaveNotificationSupport() && !sock->DataPending() ) {
2041                         ECUpdateMsgSource **notifier_array = i->second;
2042                         CECPacket *packet = GetNextPacket(notifier_array);
2043                         if ( packet ) {
2044                                 printf("[EC] sending update packet; opcode=%x\n",packet->GetOpCode());
2045                                 sock->SendPacket(packet);
2046                         }
2047                 }
2048         }
2049 }
2050
2051 // File_checked_for_headers