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