?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update Wiki URL
[amule.git] / src / BaseClient.cpp
blob075eb58eaead6af9d9fd47536d05dafecc6d538d
1 //
2 // This file is part of the aMule Project.
3 //
4 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
5 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
6 //
7 // Any parts of this program derived from the xMule, lMule or eMule project,
8 // or contributed by third-party developers are copyrighted by their
9 // respective authors.
10 //
11 // This program is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation; either version 2 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 //
25
26 #include <wx/wx.h>
27 #include <wx/mstream.h>
28 #include <wx/tokenzr.h>
29
30 #include "updownclient.h" // Needed for CUpDownClient
31 #include "SharedFileList.h" // Needed for CSharedFileList
32
33 #include <protocol/Protocols.h>
34 #include <protocol/ed2k/Client2Client/TCP.h>
35 #include <protocol/ed2k/ClientSoftware.h>
36 #include <protocol/kad/Client2Client/UDP.h>
37 #include <protocol/kad2/Constants.h>
38 #include <protocol/kad2/Client2Client/TCP.h>
39 #include <protocol/kad2/Client2Client/UDP.h>
40
41 #include <common/ClientVersion.h>
42
43 #include <tags/ClientTags.h>
44
45 #include <zlib.h> // Needed for inflateEnd
46
47 #include <common/Format.h> // Needed for CFormat
48
49 #include "SearchList.h" // Needed for CSearchList
50 #include "DownloadQueue.h" // Needed for CDownloadQueue
51 #include "UploadQueue.h" // Needed for CUploadQueue
52 #include "IPFilter.h" // Needed for CIPFilter
53 #include "ServerConnect.h" // Needed for CServerConnect
54 #include "ClientCredits.h" // Needed for CClientCredits
55 #include "ClientCreditsList.h" // Needed for CClientCreditsList
56 #include "Server.h" // Needed for CServer
57 #include "Preferences.h" // Needed for CPreferences
58 #include "MemFile.h" // Needed for CMemFile
59 #include "Packet.h" // Needed for CPacket
60 #include "Friend.h" // Needed for CFriend
61 #include "ClientList.h" // Needed for CClientList
62 #ifndef AMULE_DAEMON
63 #include "amuleDlg.h" // Needed for CamuleDlg
64 #include "CaptchaDialog.h" // Needed for CCaptchaDialog
65 #include "CaptchaGenerator.h"
66 #include "ChatWnd.h" // Needed for CChatWnd
67 #endif
68 #include "amule.h" // Needed for theApp
69 #include "PartFile.h" // Needed for CPartFile
70 #include "ClientTCPSocket.h" // Needed for CClientTCPSocket
71 #include "ListenSocket.h" // Needed for CListenSocket
72 #include "FriendList.h" // Needed for CFriendList
73 #include "Statistics.h" // Needed for theStats
74 #include "ClientUDPSocket.h"
75 #include "Logger.h"
76 #include "DataToText.h" // Needed for GetSoftName()
77 #include "GuiEvents.h" // Needed for Notify_
78 #include "ServerList.h" // For CServerList
79
80 #include "kademlia/kademlia/Kademlia.h"
81 #include "kademlia/kademlia/Prefs.h"
82 #include "kademlia/kademlia/Search.h"
83 #include "kademlia/kademlia/UDPFirewallTester.h"
84 #include "kademlia/routing/RoutingZone.h"
85
86
87 //#define __PACKET_DEBUG__
88
89
90 // some client testing variables
91 static wxString crash_name = wxT("[Invalid User Name]");
92 static wxString empty_name = wxT("[Empty User Name]");
93
94 // members of CUpDownClient
95 // which are used by down and uploading functions
96
97
98 CUpDownClient::CUpDownClient(CClientTCPSocket* sender)
99 {
100 #ifdef __DEBUG__
101 m_socket = NULL;
102 SetSocket(sender);
103 #else
104 m_socket = sender;
105 #endif
106 Init();
107 }
108
109 CUpDownClient::CUpDownClient(uint16 in_port, uint32 in_userid, uint32 in_serverip, uint16 in_serverport, CPartFile* in_reqfile, bool ed2kID, bool checkfriend)
110 {
111 m_socket = NULL;
112 Init();
113 m_nUserPort = in_port;
114
115 if(ed2kID && !IsLowID(in_userid)) {
116 SetUserIDHybrid( wxUINT32_SWAP_ALWAYS(in_userid) );
117 } else {
118 SetUserIDHybrid( in_userid);
119 }
120
121 //If highID and ED2K source, incoming ID and IP are equal..
122 //If highID and Kad source, incoming IP needs swap for the IP
123
124 if (!HasLowID()) {
125 if (ed2kID) {
126 m_nConnectIP = in_userid;
127 } else {
128 m_nConnectIP = wxUINT32_SWAP_ALWAYS(in_userid);
129 }
130 // Will be on right endianess now
131 m_FullUserIP = m_nConnectIP;
132 }
133
134 m_dwServerIP = in_serverip;
135 m_nServerPort = in_serverport;
136 SetRequestFile( in_reqfile );
137 ReGetClientSoft();
138
139 if (checkfriend) {
140 if ((m_Friend = theApp->friendlist->FindFriend(CMD4Hash(), m_dwUserIP, m_nUserPort)) != NULL){
141 m_Friend->LinkClient(CCLIENTREF(this, wxT("CUpDownClient::CUpDownClient m_Friend->LinkClient")));
142 } else{
143 // avoid that an unwanted client instance keeps a friend slot
144 m_bFriendSlot = false;
145 }
146 }
147
148 }
149
150 void CUpDownClient::Init()
151 {
152 m_linked = 0;
153 #ifdef DEBUG_ZOMBIE_CLIENTS
154 m_linkedDebug = false;
155 #endif
156 m_bAddNextConnect = false;
157 credits = NULL;
158 m_byChatstate = MS_NONE;
159 m_nKadState = KS_NONE;
160 m_nChatCaptchaState = CA_NONE;
161 m_cShowDR = 0;
162 m_reqfile = NULL; // No file required yet
163 m_nTransferredUp = 0;
164 m_cSendblock = 0;
165 m_cAsked = 0;
166 msReceivedPrev = 0;
167 kBpsDown = 0.0;
168 bytesReceivedCycle = 0;
169 m_nServerPort = 0;
170 m_iFileListRequested = 0;
171 m_dwLastUpRequest = 0;
172 m_bEmuleProtocol = false;
173 m_bCompleteSource = false;
174 m_bFriendSlot = false;
175 m_bCommentDirty = false;
176 m_bReaskPending = false;
177 m_bUDPPending = false;
178 m_nUserPort = 0;
179 m_nPartCount = 0;
180 m_dwLastAskedTime = 0;
181 m_nDownloadState = DS_NONE;
182 m_dwUploadTime = 0;
183 m_nTransferredDown = 0;
184 m_nUploadState = US_NONE;
185 m_dwLastBlockReceived = 0;
186 m_bUnicodeSupport = false;
187
188 m_fSentOutOfPartReqs = 0;
189 m_nCurQueueSessionPayloadUp = 0;
190 m_addedPayloadQueueSession = 0;
191 m_nUpDatarate = 0;
192 m_nSumForAvgUpDataRate = 0;
193
194 m_nRemoteQueueRank = 0;
195 m_nOldRemoteQueueRank = 0;
196 m_dwLastSourceRequest = 0;
197 m_dwLastSourceAnswer = 0;
198 m_dwLastAskedForSources = 0;
199
200 m_SecureIdentState = IS_UNAVAILABLE;
201 m_dwLastSignatureIP = 0;
202
203 m_byInfopacketsReceived = IP_NONE;
204
205 m_bIsHybrid = false;
206 m_bIsML = false;
207 m_Friend = NULL;
208 m_iRating = 0;
209 m_nCurSessionUp = 0;
210 m_clientSoft=SO_UNKNOWN;
211
212 m_bRemoteQueueFull = false;
213 m_HasValidHash = false;
214 SetWaitStartTime();
215
216 m_fHashsetRequesting = 0;
217 m_fSharedDirectories = 0;
218 m_lastPartAsked = 0xffff;
219 m_nUpCompleteSourcesCount= 0;
220 m_waitingPosition = 0;
221 m_score = 0;
222 m_lastRefreshedDLDisplay = 0;
223 m_bHelloAnswerPending = false;
224 m_fSentCancelTransfer = 0;
225 m_Aggressiveness = 0;
226 m_LastFileRequest = 0;
227
228 m_clientState = CS_NEW;
229
230 ClearHelloProperties();
231
232 m_pReqFileAICHHash = NULL;
233 m_fSupportsAICH = 0;
234 m_fAICHRequested = 0;
235 m_fSupportsLargeFiles = 0;
236 m_fExtMultiPacket = 0;
237 m_fIsSpammer = 0;
238
239 m_dwUserIP = 0;
240 m_nConnectIP = 0;
241 m_dwServerIP = 0;
242
243 m_fNeedOurPublicIP = false;
244 m_bHashsetRequested = false;
245
246 m_lastDownloadingPart = 0;
247
248 m_uploadingfile = NULL;
249
250 m_OSInfo_sent = false;
251
252 /* Kad stuff */
253 SetBuddyID(NULL);
254 m_nBuddyIP = 0;
255 m_nBuddyPort = 0;
256 m_nUserIDHybrid = 0;
257
258 m_nSourceFrom = SF_NONE;
259
260 if (m_socket) {
261 SetIP(m_socket->GetPeerInt());
262 } else {
263 SetIP(0);
264 }
265
266 /* Statistics */
267 m_lastClientSoft = (uint32)(-1);
268 m_lastClientVersion = 0;
269
270 /* Creation time (for buddies timeout) */
271 m_nCreationTime = ::GetTickCount();
272
273 m_MaxBlockRequests = STANDARD_BLOCKS_REQUEST; // Safe starting amount
274
275 m_last_block_start = 0;
276 m_lastaverage = 0;
277
278 SetLastBuddyPingPongTime();
279 m_fRequestsCryptLayer = 0;
280 m_fSupportsCryptLayer = 0;
281 m_fRequiresCryptLayer = 0;
282 m_fSupportsSourceEx2 = 0;
283 m_fSupportsCaptcha = 0;
284 m_fDirectUDPCallback = 0;
285 m_dwDirectCallbackTimeout = 0;
286
287 m_hasbeenobfuscatinglately = false;
288
289 m_cCaptchasSent = 0;
290 m_cMessagesReceived = 0;
291 m_cMessagesSent = 0;
292
293 }
294
295
296 CUpDownClient::~CUpDownClient()
297 {
298 #ifdef __DEBUG__
299 if (!connection_reason.IsEmpty()) {
300 AddDebugLogLineN(logClient, wxT("Client to check for ") + connection_reason + wxT(" was deleted without connection."));
301 }
302 #endif
303
304
305 if (m_lastClientSoft == SO_UNKNOWN) {
306 theStats::RemoveUnknownClient();
307 } else if (m_lastClientSoft != (uint32)(-1)) {
308 theStats::RemoveKnownClient(m_lastClientSoft, m_lastClientVersion, m_lastOSInfo);
309 }
310
311 // Indicate that we are not anymore on stats
312 m_lastClientSoft = (uint32)(-1);
313
314 // The socket should have been removed in Safe_Delete, but it
315 // doesn't hurt to have an extra check.
316 if (m_socket) {
317 m_socket->Safe_Delete();
318 // Paranoia
319 SetSocket(NULL);
320 }
321
322 ClearUploadBlockRequests();
323 ClearDownloadBlockRequests();
324
325 DeleteContents(m_WaitingPackets_list);
326
327 // Allow detection of deleted clients that didn't go through Safe_Delete
328 m_clientState = CS_DYING;
329 }
330
331
332 void CUpDownClient::ClearHelloProperties()
333 {
334 m_nUDPPort = 0;
335 m_byUDPVer = 0;
336 m_byDataCompVer = 0;
337 m_byEmuleVersion = 0;
338 m_bySourceExchange1Ver = 0;
339 m_byAcceptCommentVer = 0;
340 m_byExtendedRequestsVer = 0;
341 m_byCompatibleClient = 0;
342 m_nKadPort = 0;
343 m_bySupportSecIdent = 0;
344 m_bSupportsPreview = 0;
345 m_nClientVersion = 0;
346 m_fSharedDirectories = 0;
347 m_bMultiPacket = 0;
348 m_fOsInfoSupport = 0;
349 m_fValueBasedTypeTags = 0;
350 SecIdentSupRec = 0;
351 m_byKadVersion = 0;
352 m_fRequestsCryptLayer = 0;
353 m_fSupportsCryptLayer = 0;
354 m_fRequiresCryptLayer = 0;
355 m_fSupportsSourceEx2 = 0;
356 m_fSupportsCaptcha = 0;
357 m_fDirectUDPCallback = 0;
358 m_bIsHybrid = false;
359 m_bIsML = false;
360 m_fNoViewSharedFiles = true; // that's a sensible default to assume until we get the real value
361 m_bUnicodeSupport = false;
362 }
363
364 bool CUpDownClient::ProcessHelloPacket(const byte* pachPacket, uint32 nSize)
365 {
366 const CMemFile data(pachPacket,nSize);
367 uint8 hashsize = data.ReadUInt8();
368 if ( 16 != hashsize ) {
369 /*
370 * Hint: We can not accept other sizes here because:
371 * - the magic number is spread all over the source
372 * - the answer packet lacks the size field
373 */
374 throw wxString(wxT("Invalid Hello packet: Other userhash sizes than 16 are not implemented"));
375 }
376 // eMule 0.42: reset all client properties; a client may not send a particular emule tag any longer
377 ClearHelloProperties();
378
379 return ProcessHelloTypePacket(data);
380 }
381
382 void CUpDownClient::Safe_Delete()
383 {
384 // Because we are delaying the deletion, we might end up trying to delete
385 // it twice, however, this is normal and shouldn't trigger any failures
386 if ( m_clientState == CS_DYING ) {
387 return;
388 }
389
390 // If called from background, post an event to process it in main thread
391 if (!wxThread::IsMain()) {
392 CoreNotify_Client_Delete(CCLIENTREF(this, wxT("CUpDownClient::Safe_Delete CoreNotify_Client_Delete")));
393 return;
394 }
395
396 m_clientState = CS_DYING;
397
398 // Make sure client doesn't get deleted until this method is finished
399 CClientRef ref(CCLIENTREF(this, wxT("CUpDownClient::Safe_Delete reflocker")));
400
401 // Close the socket to avoid any more connections and related events
402 if ( m_socket ) {
403 m_socket->Safe_Delete();
404 // Paranoia
405 SetSocket(NULL);
406 }
407
408 // Remove the client from the clientlist if we still have it
409 if ( theApp->clientlist ) {
410 theApp->clientlist->RemoveClient( this );
411 }
412
413 // Doing what RemoveClient used to do. Just to be sure...
414 if (theApp->uploadqueue) {
415 theApp->uploadqueue->RemoveFromUploadQueue(this);
416 theApp->uploadqueue->RemoveFromWaitingQueue(this);
417 }
418 if (theApp->downloadqueue) {
419 theApp->downloadqueue->RemoveSource(this);
420 }
421
422 // For security, remove it from the lists unconditionally.
423 Notify_SharedCtrlRemoveClient(ECID(), (CKnownFile*)NULL);
424 Notify_SourceCtrlRemoveSource(ECID(), (CPartFile*)NULL);
425
426 if (IsAICHReqPending()){
427 m_fAICHRequested = FALSE;
428 CAICHHashSet::ClientAICHRequestFailed(this);
429 }
430
431 if (m_Friend) {
432 m_Friend->UnLinkClient(); // this notifies
433 m_Friend = NULL;
434 }
435
436 if (m_iRating>0 || !m_strComment.IsEmpty()) {
437 m_iRating = 0;
438 m_strComment.Clear();
439 if (m_reqfile) {
440 m_reqfile->UpdateFileRatingCommentAvail();
441 }
442 }
443
444 // Ensure that source-counts gets updated in case
445 // of a source not on the download-queue
446 SetRequestFile( NULL );
447
448 SetUploadFileID(NULL);
449
450 delete m_pReqFileAICHHash;
451 m_pReqFileAICHHash = NULL;
452
453 #ifdef DEBUG_ZOMBIE_CLIENTS
454 if (m_linked > 1) {
455 AddLogLineC(CFormat(wxT("Client %d still linked in %d places: %s")) % ECID() % (m_linked - 1) % GetLinkedFrom());
456 m_linkedDebug = true;
457 }
458 #endif
459 }
460
461
462 bool CUpDownClient::ProcessHelloAnswer(const byte* pachPacket, uint32 nSize)
463 {
464 const CMemFile data(pachPacket,nSize);
465 bool bIsMule = ProcessHelloTypePacket(data);
466 m_bHelloAnswerPending = false;
467 return bIsMule;
468 }
469
470 bool CUpDownClient::ProcessHelloTypePacket(const CMemFile& data)
471 {
472 uint32 dwEmuleTags = 0;
473
474 CMD4Hash hash = data.ReadHash();
475 SetUserHash( hash );
476 SetUserIDHybrid( data.ReadUInt32() );
477 uint16 nUserPort = data.ReadUInt16(); // hmm clientport is sent twice - why?
478 uint32 tagcount = data.ReadUInt32();
479 for (uint32 i = 0;i < tagcount; i++){
480 CTag temptag(data, true);
481 switch(temptag.GetNameID()){
482 case CT_NAME:
483 m_Username = temptag.GetStr();
484 break;
485
486 case CT_VERSION:
487 m_nClientVersion = temptag.GetInt();
488 break;
489
490 case ET_MOD_VERSION:
491 if (temptag.IsStr()) {
492 m_strModVersion = temptag.GetStr();
493 } else if (temptag.IsInt()) {
494 m_strModVersion = CFormat(wxT("ModID=%u")) % temptag.GetInt();
495 } else {
496 m_strModVersion = wxT("ModID=<Unknown>");
497 }
498
499 break;
500
501 case CT_PORT:
502 nUserPort = temptag.GetInt();
503 break;
504
505 case CT_EMULE_UDPPORTS:
506 // 16 KAD Port
507 // 16 UDP Port
508 SetKadPort((temptag.GetInt() >> 16) & 0xFFFF);
509 m_nUDPPort = temptag.GetInt() & 0xFFFF;
510 dwEmuleTags |= 1;
511 #ifdef __PACKET_DEBUG__
512 AddLogLineNS(CFormat(wxT("Hello type packet processing with eMule ports UDP=%i KAD=%i")) % m_nUDPPort % m_nKadPort);
513 #endif
514 break;
515
516 case CT_EMULE_BUDDYIP:
517 // 32 BUDDY IP
518 m_nBuddyIP = temptag.GetInt();
519 #ifdef __PACKET_DEBUG__
520 AddLogLineNS(CFormat(wxT("Hello type packet processing with eMule BuddyIP=%u (%s)")) % m_nBuddyIP % Uint32toStringIP(m_nBuddyIP));
521 #endif
522 break;
523
524 case CT_EMULE_BUDDYUDP:
525 // 16 --Reserved for future use--
526 // 16 BUDDY Port
527 m_nBuddyPort = (uint16)temptag.GetInt();
528 #ifdef __PACKET_DEBUG__
529 AddLogLineNS(CFormat(wxT("Hello type packet processing with eMule BuddyPort=%u")) % m_nBuddyPort);
530 #endif
531 break;
532
533 case CT_EMULE_MISCOPTIONS1: {
534 // 3 AICH Version (0 = not supported)
535 // 1 Unicode
536 // 4 UDP version
537 // 4 Data compression version
538 // 4 Secure Ident
539 // 4 Source Exchange
540 // 4 Ext. Requests
541 // 4 Comments
542 // 1 PeerCache supported
543 // 1 No 'View Shared Files' supported
544 // 1 MultiPacket
545 // 1 Preview
546 uint32 flags = temptag.GetInt();
547 m_fSupportsAICH = (flags >> (4*7+1)) & 0x07;
548 m_bUnicodeSupport = (flags >> 4*7) & 0x01;
549 m_byUDPVer = (flags >> 4*6) & 0x0f;
550 m_byDataCompVer = (flags >> 4*5) & 0x0f;
551 m_bySupportSecIdent = (flags >> 4*4) & 0x0f;
552 m_bySourceExchange1Ver = (flags >> 4*3) & 0x0f;
553 m_byExtendedRequestsVer = (flags >> 4*2) & 0x0f;
554 m_byAcceptCommentVer = (flags >> 4*1) & 0x0f;
555 m_fNoViewSharedFiles = (flags >> 1*2) & 0x01;
556 m_bMultiPacket = (flags >> 1*1) & 0x01;
557 m_fSupportsPreview = (flags >> 1*0) & 0x01;
558 dwEmuleTags |= 2;
559 #ifdef __PACKET_DEBUG__
560 AddLogLineNS(wxT("Hello type packet processing with eMule Misc Options:"));
561 AddLogLineNS(CFormat(wxT("m_byUDPVer = %i")) % m_byUDPVer);
562 AddLogLineNS(CFormat(wxT("m_byDataCompVer = %i")) % m_byDataCompVer);
563 AddLogLineNS(CFormat(wxT("m_bySupportSecIdent = %i")) % m_bySupportSecIdent);
564 AddLogLineNS(CFormat(wxT("m_bySourceExchangeVer = %i")) % m_bySourceExchange1Ver);
565 AddLogLineNS(CFormat(wxT("m_byExtendedRequestsVer = %i")) % m_byExtendedRequestsVer);
566 AddLogLineNS(CFormat(wxT("m_byAcceptCommentVer = %i")) % m_byAcceptCommentVer);
567 AddLogLineNS(CFormat(wxT("m_fNoViewSharedFiles = %i")) % m_fNoViewSharedFiles);
568 AddLogLineNS(CFormat(wxT("m_bMultiPacket = %i")) % m_bMultiPacket);
569 AddLogLineNS(CFormat(wxT("m_fSupportsPreview = %i")) % m_fSharedDirectories);
570 AddLogLineNS(wxT("That's all."));
571 #endif
572 SecIdentSupRec += 1;
573 break;
574 }
575
576 case CT_EMULE_MISCOPTIONS2:
577 // 19 Reserved
578 // 1 Direct UDP Callback supported and available
579 // 1 Supports ChatCaptchas
580 // 1 Supports SourceExachnge2 Packets, ignores SX1 Packet Version
581 // 1 Requires CryptLayer
582 // 1 Requests CryptLayer
583 // 1 Supports CryptLayer
584 // 1 Reserved (ModBit)
585 // 1 Ext Multipacket (Hash+Size instead of Hash)
586 // 1 Large Files (includes support for 64bit tags)
587 // 4 Kad Version - will go up to version 15 only (may need to add another field at some point in the future)
588 m_fDirectUDPCallback = (temptag.GetInt() >> 12) & 0x01;
589 m_fSupportsCaptcha = (temptag.GetInt() >> 11) & 0x01;
590 m_fSupportsSourceEx2 = (temptag.GetInt() >> 10) & 0x01;
591 m_fRequiresCryptLayer = (temptag.GetInt() >> 9) & 0x01;
592 m_fRequestsCryptLayer = (temptag.GetInt() >> 8) & 0x01;
593 m_fSupportsCryptLayer = (temptag.GetInt() >> 7) & 0x01;
594 // reserved 1
595 m_fExtMultiPacket = (temptag.GetInt() >> 5) & 0x01;
596 m_fSupportsLargeFiles = (temptag.GetInt() >> 4) & 0x01;
597 m_byKadVersion = (temptag.GetInt() >> 0) & 0x0f;
598 dwEmuleTags |= 8;
599
600 m_fRequestsCryptLayer &= m_fSupportsCryptLayer;
601 m_fRequiresCryptLayer &= m_fRequestsCryptLayer;
602
603 #ifdef __PACKET_DEBUG__
604 AddLogLineNS(wxT("Hello type packet processing with eMule Misc Options 2:"));
605 AddLogLineNS(CFormat(wxT(" m_fDirectUDPCallback = %i")) % m_fDirectUDPCallback);
606 AddLogLineNS(CFormat(wxT(" m_fSupportsCaptcha = %i")) % m_fSupportsCaptcha);
607 AddLogLineNS(CFormat(wxT(" m_fSupportsSourceEx2 = %i")) % m_fSupportsSourceEx2);
608 AddLogLineNS(CFormat(wxT(" m_fRequiresCryptLayer = %i")) % m_fRequiresCryptLayer);
609 AddLogLineNS(CFormat(wxT(" m_fRequestsCryptLayer = %i")) % m_fRequestsCryptLayer);
610 AddLogLineNS(CFormat(wxT(" m_fSupportsCryptLayer = %i")) % m_fSupportsCryptLayer);
611 AddLogLineNS(CFormat(wxT(" m_fExtMultiPacket = %i")) % m_fExtMultiPacket);
612 AddLogLineNS(CFormat(wxT(" m_fSupportsLargeFiles = %i")) % m_fSupportsLargeFiles);
613 AddLogLineNS(CFormat(wxT(" KadVersion = %u")) % m_byKadVersion);
614 AddLogLineNS(wxT("That's all."));
615 #endif
616 break;
617
618 // Special tag for Compat. Clients Misc options.
619 case CT_EMULECOMPAT_OPTIONS:
620 // 1 Operative System Info
621 // 1 Value-based-type int tags (experimental!)
622 m_fValueBasedTypeTags = (temptag.GetInt() >> 1*1) & 0x01;
623 m_fOsInfoSupport = (temptag.GetInt() >> 1*0) & 0x01;
624 break;
625
626 case CT_EMULE_VERSION:
627 // 8 Compatible Client ID
628 // 7 Mjr Version (Doesn't really matter..)
629 // 7 Min Version (Only need 0-99)
630 // 3 Upd Version (Only need 0-5)
631 // 7 Bld Version (Only need 0-99)
632 m_byCompatibleClient = (temptag.GetInt() >> 24);
633 m_nClientVersion = temptag.GetInt() & 0x00ffffff;
634 m_byEmuleVersion = 0x99;
635 m_fSharedDirectories = 1;
636 dwEmuleTags |= 4;
637 break;
638 }
639 }
640
641 m_nUserPort = nUserPort;
642 m_dwServerIP = data.ReadUInt32();
643 m_nServerPort = data.ReadUInt16();
644 // Hybrid now has an extra uint32.. What is it for?
645 // Also, many clients seem to send an extra 6? These are not eDonkeys or Hybrids..
646 if ( data.GetLength() - data.GetPosition() == sizeof(uint32) ) {
647 uint32 test = data.ReadUInt32();
648 /*if (test == 'KDLM') below kdlm is converted to ascii values.
649 This fixes a warning with gcc 3.4.
650 K=4b D=44 L=4c M=4d
651 */
652 if (test == 0x4b444c4d) { //if it's == "KDLM"
653 m_bIsML=true;
654 } else{
655 m_bIsHybrid = true;
656 m_fSharedDirectories = 1;
657 }
658 }
659
660 if (m_socket) {
661 SetIP(m_socket->GetPeerInt());
662 } else {
663 throw wxString(wxT("Huh, socket failure. Avoided crash this time."));
664 }
665
666 if (thePrefs::AddServersFromClient()) {
667 CServer* addsrv = new CServer(m_nServerPort, Uint32toStringIP(m_dwServerIP));
668 addsrv->SetListName(addsrv->GetAddress());
669 if (!theApp->AddServer(addsrv)) {
670 delete addsrv;
671 }
672 }
673
674 //(a)If this is a highID user, store the ID in the Hybrid format.
675 //(b)Some older clients will not send a ID, these client are HighID users that are not connected to a server.
676 //(c)Kad users with a *.*.*.0 IPs will look like a lowID user they are actually a highID user.. They can be detected easily
677 //because they will send a ID that is the same as their IP..
678 if(!HasLowID() || m_nUserIDHybrid == 0 || m_nUserIDHybrid == m_dwUserIP ) {
679 SetUserIDHybrid(wxUINT32_SWAP_ALWAYS(m_dwUserIP));
680 }
681
682 // get client credits
683 CClientCredits* pFoundCredits = theApp->clientcredits->GetCredit(m_UserHash);
684 if (credits == NULL){
685 credits = pFoundCredits;
686 if (!theApp->clientlist->ComparePriorUserhash(m_dwUserIP, m_nUserPort, pFoundCredits)){
687 AddDebugLogLineN( logClient, CFormat( wxT("Client: %s (%s) Banreason: Userhash changed (Found in TrackedClientsList)") ) % GetUserName() % GetFullIP() );
688 Ban();
689 }
690 } else if (credits != pFoundCredits){
691 // userhash change ok, however two hours "waittime" before it can be used
692 credits = pFoundCredits;
693 AddDebugLogLineN( logClient, CFormat( wxT("Client: %s (%s) Banreason: Userhash changed") ) % GetUserName() % GetFullIP() );
694 Ban();
695 }
696
697 if ((m_Friend = theApp->friendlist->FindFriend(m_UserHash, m_dwUserIP, m_nUserPort)) != NULL){
698 m_Friend->LinkClient(CCLIENTREF(this, wxT("CUpDownClient::ProcessHelloTypePacket m_Friend->LinkClient")));
699 } else{
700 // avoid that an unwanted client instance keeps a friend slot
701 SetFriendSlot(false);
702 }
703
704
705 ReGetClientSoft();
706
707 m_byInfopacketsReceived |= IP_EDONKEYPROTPACK;
708
709 // check if at least CT_EMULEVERSION was received, all other tags are optional
710 bool bIsMule = (dwEmuleTags & 0x04) == 0x04;
711 if (bIsMule) {
712 m_bEmuleProtocol = true;
713 m_byInfopacketsReceived |= IP_EMULEPROTPACK;
714 }
715
716 if (GetKadPort() && GetKadVersion() > 1) {
717 Kademlia::CKademlia::Bootstrap(wxUINT32_SWAP_ALWAYS(GetIP()), GetKadPort());
718 }
719
720 return bIsMule;
721 }
722
723
724 bool CUpDownClient::SendHelloPacket()
725 {
726 if (m_socket == NULL) {
727 wxFAIL;
728 return true;
729 }
730
731 // if IP is filtered, don't greet him but disconnect...
732 if (theApp->ipfilter->IsFiltered(m_socket->GetPeerInt())) {
733 if (Disconnected(wxT("IPFilter"))) {
734 Safe_Delete();
735 return false;
736 }
737 return true;
738 }
739
740 CMemFile data(128);
741 data.WriteUInt8(16); // size of userhash
742 SendHelloTypePacket(&data);
743
744 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_HELLO);
745 theStats::AddUpOverheadOther(packet->GetPacketSize());
746 SendPacket(packet,true);
747 m_bHelloAnswerPending = true;
748 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_HELLO to ") + GetFullIP() );
749 return true;
750 }
751
752 void CUpDownClient::SendMuleInfoPacket(bool bAnswer, bool OSInfo) {
753
754 if (m_socket == NULL){
755 wxFAIL;
756 return;
757 }
758
759 CPacket* packet = NULL;
760 CMemFile data;
761
762 data.WriteUInt8(CURRENT_VERSION_SHORT);
763
764 if (OSInfo) {
765
766 // Special MuleInfo packet for clients supporting it.
767 // This means aMule >= 2.0.0 and Hydranode
768
769 // Violently mark it as special Mule Info packet
770 // Sending this makes non-supporting-osinfo clients to refuse to read this
771 // packet. Anyway, this packet should NEVER get to non-supporting clients.
772
773 data.WriteUInt8(/*EMULE_PROTOCOL*/ 0xFF);
774
775 data.WriteUInt32(1); // One Tag (OS_INFO)
776
777 CTagString tag1(ET_OS_INFO,theApp->GetOSType());
778 tag1.WriteTagToFile(&data);
779
780 m_OSInfo_sent = true; // So we don't send it again
781
782 } else {
783
784 // Normal MuleInfo packet
785
786 // Kry - There's no point on upgrading to VBT tags here
787 // as no client supporting it uses mule info packet.
788
789 data.WriteUInt8(EMULE_PROTOCOL);
790
791 // Tag number
792 data.WriteUInt32(9);
793
794 CTagInt32 tag1(ET_COMPRESSION,1);
795 tag1.WriteTagToFile(&data);
796 CTagInt32 tag2(ET_UDPVER,4);
797 tag2.WriteTagToFile(&data);
798 CTagInt32 tag3(ET_UDPPORT, thePrefs::GetEffectiveUDPPort());
799 tag3.WriteTagToFile(&data);
800 CTagInt32 tag4(ET_SOURCEEXCHANGE,3);
801 tag4.WriteTagToFile(&data);
802 CTagInt32 tag5(ET_COMMENTS,1);
803 tag5.WriteTagToFile(&data);
804 CTagInt32 tag6(ET_EXTENDEDREQUEST,2);
805 tag6.WriteTagToFile(&data);
806
807 uint32 dwTagValue = (theApp->CryptoAvailable() ? 3 : 0);
808 // Kry - Needs the preview code from eMule
809 /*
810 // set 'Preview supported' only if 'View Shared Files' allowed
811 if (thePrefs::CanSeeShares() != vsfaNobody) {
812 dwTagValue |= 128;
813 }
814 */
815 CTagInt32 tag7(ET_FEATURES, dwTagValue);
816 tag7.WriteTagToFile(&data);
817
818 CTagInt32 tag8(ET_COMPATIBLECLIENT,SO_AMULE);
819 tag8.WriteTagToFile(&data);
820
821 // Support for tag ET_MOD_VERSION
822 wxString mod_name(MOD_VERSION_LONG);
823 CTagString tag9(ET_MOD_VERSION, mod_name);
824 tag9.WriteTagToFile(&data);
825 // Maella end
826
827 }
828
829 packet = new CPacket(data, OP_EMULEPROT, (bAnswer ? OP_EMULEINFOANSWER : OP_EMULEINFO));
830
831 if (m_socket) {
832 theStats::AddUpOverheadOther(packet->GetPacketSize());
833 SendPacket(packet,true,true);
834
835 #ifdef __DEBUG__
836 if (!bAnswer) {
837 if (!OSInfo) {
838 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_EMULEINFO to ") + GetFullIP() );
839 } else {
840 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_EMULEINFO/OS_INFO to ") + GetFullIP() );
841 }
842 } else {
843 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_EMULEINFOANSWER to ") + GetFullIP() );
844 }
845 #endif
846 }
847 }
848
849 bool CUpDownClient::ProcessMuleInfoPacket(const byte* pachPacket, uint32 nSize)
850 {
851 uint8 protocol_version;
852
853 const CMemFile data(pachPacket,nSize);
854
855 // The version number part of this packet will soon be useless since
856 // it is only able to go to v.99. Why the version is a uint8 and why
857 // it was not done as a tag like the eDonkey hello packet is not known.
858 // Therefore, sooner or later, we are going to have to switch over to
859 // using the eDonkey hello packet to set the version. No sense making
860 // a third value sent for versions.
861 uint8 mule_version = data.ReadUInt8();
862 protocol_version = data.ReadUInt8();
863 uint32 tagcount = data.ReadUInt32();
864 if (protocol_version == 0xFF) {
865 // OS Info supporting clients sending a recycled Mule info packet
866 for (uint32 i = 0;i < tagcount; i++){
867 CTag temptag(data, true);
868 switch(temptag.GetNameID()){
869 case ET_OS_INFO:
870 // Special tag, only supporting clients (aMule/Hydranode)
871 // It was recycled from a mod's tag, so if the other side
872 // is not supporting OS Info, we're seriously fucked up :)
873 m_sClientOSInfo = temptag.GetStr();
874
875 // If we didn't send our OSInfo to this client, just send it
876 if (!m_OSInfo_sent) {
877 SendMuleInfoPacket(false,true);
878 }
879
880 UpdateStats();
881
882 break;
883
884 // Your ad... er... I mean TAG, here
885
886 default:
887 break;
888 }
889 }
890 } else {
891 // Old eMule sending tags
892 m_byCompatibleClient = 0;
893 m_byEmuleVersion = mule_version;
894
895 if( m_byEmuleVersion == 0x2B ) {
896 m_byEmuleVersion = 0x22;
897 }
898
899 if (!(m_bEmuleProtocol = (protocol_version == EMULE_PROTOCOL))) {
900 return false;
901 }
902
903 for (uint32 i = 0;i < tagcount; i++){
904 CTag temptag(data, false);
905 switch(temptag.GetNameID()){
906 case ET_COMPRESSION:
907 // Bits 31- 8: 0 - reserved
908 // Bits 7- 0: data compression version
909 m_byDataCompVer = temptag.GetInt();
910 break;
911
912 case ET_UDPPORT:
913 // Bits 31-16: 0 - reserved
914 // Bits 15- 0: UDP port
915 m_nUDPPort = temptag.GetInt();
916 break;
917
918 case ET_UDPVER:
919 // Bits 31- 8: 0 - reserved
920 // Bits 7- 0: UDP protocol version
921 m_byUDPVer = temptag.GetInt();
922 break;
923
924 case ET_SOURCEEXCHANGE:
925 // Bits 31- 8: 0 - reserved
926 // Bits 7- 0: source exchange protocol version
927 m_bySourceExchange1Ver = temptag.GetInt();
928 break;
929
930 case ET_COMMENTS:
931 // Bits 31- 8: 0 - reserved
932 // Bits 7- 0: comments version
933 m_byAcceptCommentVer = temptag.GetInt();
934 break;
935
936 case ET_EXTENDEDREQUEST:
937 // Bits 31- 8: 0 - reserved
938 // Bits 7- 0: extended requests version
939 m_byExtendedRequestsVer = temptag.GetInt();
940 break;
941
942 case ET_COMPATIBLECLIENT:
943 // Bits 31- 8: 0 - reserved
944 // Bits 7- 0: compatible client ID
945 m_byCompatibleClient = temptag.GetInt();
946 break;
947
948 case ET_FEATURES:
949 // Bits 31- 8: 0 - reserved
950 // Bit 7: Preview
951 // Bit 6- 0: secure identification
952 m_bySupportSecIdent = temptag.GetInt() & 3;
953 m_bSupportsPreview = (temptag.GetInt() & 128) > 0;
954 SecIdentSupRec += 2;
955 break;
956
957 case ET_MOD_VERSION:
958 if (temptag.IsStr()) {
959 m_strModVersion = temptag.GetStr();
960 } else if (temptag.IsInt()) {
961 m_strModVersion = CFormat(wxT("ModID=%u")) % temptag.GetInt();
962 } else {
963 m_strModVersion = wxT("ModID=<Unknown>");
964 }
965
966 break;
967
968 default:
969 AddDebugLogLineN( logPacketErrors,
970 CFormat( wxT("Unknown Mule tag (%s) from client: %s") )
971 % temptag.GetFullInfo()
972 % GetClientFullInfo()
973 );
974
975 break;
976 }
977 }
978
979 if( m_byDataCompVer == 0 ){
980 m_bySourceExchange1Ver = 0;
981 m_byExtendedRequestsVer = 0;
982 m_byAcceptCommentVer = 0;
983 m_nUDPPort = 0;
984 }
985
986 //implicitly supported options by older clients
987 //in the future do not use version to guess about new features
988 if(m_byEmuleVersion < 0x25 && m_byEmuleVersion > 0x22) {
989 m_byUDPVer = 1;
990 }
991
992 if(m_byEmuleVersion < 0x25 && m_byEmuleVersion > 0x21) {
993 m_bySourceExchange1Ver = 1;
994 }
995
996 if(m_byEmuleVersion == 0x24) {
997 m_byAcceptCommentVer = 1;
998 }
999
1000 // Shared directories are requested from eMule 0.28+ because eMule 0.27 has a bug in
1001 // the OP_ASKSHAREDFILESDIR handler, which does not return the shared files for a
1002 // directory which has a trailing backslash.
1003 if(m_byEmuleVersion >= 0x28 && !m_bIsML) {// MLdonkey currently does not support shared directories
1004 m_fSharedDirectories = 1;
1005 }
1006
1007 ReGetClientSoft();
1008
1009 m_byInfopacketsReceived |= IP_EMULEPROTPACK;
1010 }
1011
1012 return (protocol_version == 0xFF); // This was a OS_Info?
1013 }
1014
1015
1016 void CUpDownClient::SendHelloAnswer()
1017 {
1018 if (m_socket == NULL){
1019 wxFAIL;
1020 return;
1021 }
1022
1023 CMemFile data(128);
1024 SendHelloTypePacket(&data);
1025 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_HELLOANSWER);
1026 theStats::AddUpOverheadOther(packet->GetPacketSize());
1027 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_HELLOANSWER to ") + GetFullIP() );
1028 SendPacket(packet,true);
1029 }
1030
1031
1032 void CUpDownClient::SendHelloTypePacket(CMemFile* data)
1033 {
1034 data->WriteHash(thePrefs::GetUserHash());
1035 data->WriteUInt32(theApp->GetID());
1036 data->WriteUInt16(thePrefs::GetPort());
1037
1038 uint32 tagcount = 6;
1039
1040 if( theApp->clientlist->GetBuddy() && theApp->IsFirewalled() ) {
1041 tagcount += 2;
1042 }
1043 tagcount ++; // eMule misc flags 2 (kad version)
1044
1045 #ifdef __SVN__
1046 // Kry - This is the tagcount!!! Be sure to update it!!
1047 // Last update: CT_EMULECOMPAT_OPTIONS included
1048 data->WriteUInt32(tagcount + 1);
1049 #else
1050 data->WriteUInt32(tagcount); // NO MOD_VERSION
1051 #endif
1052
1053
1054 CTagString tagname(CT_NAME,thePrefs::GetUserNick());
1055 tagname.WriteTagToFile(data, utf8strRaw);
1056
1057 CTagVarInt tagversion(CT_VERSION, EDONKEYVERSION, GetVBTTags() ? 0 : 32);
1058 tagversion.WriteTagToFile(data);
1059 // eMule UDP Ports
1060
1061 uint32 kadUDPPort = 0;
1062
1063 if(Kademlia::CKademlia::IsConnected()) {
1064 if (Kademlia::CKademlia::GetPrefs()->GetExternalKadPort() != 0 && Kademlia::CKademlia::GetPrefs()->GetUseExternKadPort() && Kademlia::CUDPFirewallTester::IsVerified()) {
1065 kadUDPPort = Kademlia::CKademlia::GetPrefs()->GetExternalKadPort();
1066 } else {
1067 kadUDPPort = Kademlia::CKademlia::GetPrefs()->GetInternKadPort();
1068 }
1069 }
1070
1071 CTagVarInt tagUdpPorts(CT_EMULE_UDPPORTS, (kadUDPPort << 16) | ((uint32)thePrefs::GetEffectiveUDPPort()), GetVBTTags() ? 0 : 32);
1072 tagUdpPorts.WriteTagToFile(data);
1073
1074 if( theApp->clientlist->GetBuddy() && theApp->IsFirewalled() ) {
1075 CTagVarInt tagBuddyIP(CT_EMULE_BUDDYIP, theApp->clientlist->GetBuddy()->GetIP(), GetVBTTags() ? 0 : 32);
1076 tagBuddyIP.WriteTagToFile(data);
1077
1078 CTagVarInt tagBuddyPort(CT_EMULE_BUDDYUDP,
1079 // ( RESERVED )
1080 ((uint32)theApp->clientlist->GetBuddy()->GetUDPPort() )
1081 , GetVBTTags() ? 0 : 32);
1082 tagBuddyPort.WriteTagToFile(data);
1083 }
1084
1085 // aMule Version
1086 CTagVarInt tagMuleVersion(CT_EMULE_VERSION,
1087 (SO_AMULE << 24) |
1088 make_full_ed2k_version(VERSION_MJR, VERSION_MIN, VERSION_UPDATE)
1089 // | (RESERVED )
1090 , GetVBTTags() ? 0 : 32);
1091 tagMuleVersion.WriteTagToFile(data);
1092
1093
1094 // eMule Misc. Options #1
1095 const uint32 uUdpVer = 4;
1096 const uint32 uDataCompVer = 1;
1097 const uint32 uSupportSecIdent = theApp->CryptoAvailable() ? 3 : 0;
1098 const uint32 uSourceExchangeVer = 3;
1099 const uint32 uExtendedRequestsVer = 2;
1100 const uint32 uAcceptCommentVer = 1;
1101 const uint32 uNoViewSharedFiles = (thePrefs::CanSeeShares() == vsfaNobody) ? 1 : 0; // for backward compatibility this has to be a 'negative' flag
1102 const uint32 uMultiPacket = 1;
1103 const uint32 uSupportPreview = 0; // No network preview at all.
1104 const uint32 uPeerCache = 0; // No peercache for aMule, baby
1105 const uint32 uUnicodeSupport = 1;
1106 const uint32 nAICHVer = 1; // AICH is ENABLED right now.
1107
1108 CTagVarInt tagMisOptions(CT_EMULE_MISCOPTIONS1,
1109 (nAICHVer << ((4*7)+1)) |
1110 (uUnicodeSupport << 4*7) |
1111 (uUdpVer << 4*6) |
1112 (uDataCompVer << 4*5) |
1113 (uSupportSecIdent << 4*4) |
1114 (uSourceExchangeVer << 4*3) |
1115 (uExtendedRequestsVer << 4*2) |
1116 (uAcceptCommentVer << 4*1) |
1117 (uPeerCache << 1*3) |
1118 (uNoViewSharedFiles << 1*2) |
1119 (uMultiPacket << 1*1) |
1120 (uSupportPreview << 1*0)
1121 , GetVBTTags() ? 0 : 32);
1122 tagMisOptions.WriteTagToFile(data);
1123
1124 // eMule Misc. Options #2
1125 const uint32 uKadVersion = KADEMLIA_VERSION;
1126 const uint32 uSupportLargeFiles = 1;
1127 const uint32 uExtMultiPacket = 1;
1128 const uint32 uReserved = 0; // mod bit
1129 const uint32 uSupportsCryptLayer = thePrefs::IsClientCryptLayerSupported() ? 1 : 0;
1130 const uint32 uRequestsCryptLayer = thePrefs::IsClientCryptLayerRequested() ? 1 : 0;
1131 const uint32 uRequiresCryptLayer = thePrefs::IsClientCryptLayerRequired() ? 1 : 0;
1132 const uint32 uSupportsSourceEx2 = 1;
1133 #ifdef AMULE_DAEMON
1134 // captcha for daemon/remotegui not supported for now
1135 const uint32 uSupportsCaptcha = 0;
1136 #else
1137 const uint32 uSupportsCaptcha = 1;
1138 #endif
1139 // direct callback is only possible if connected to kad, tcp firewalled and verified UDP open (for example on a full cone NAT)
1140 const uint32 uDirectUDPCallback = (Kademlia::CKademlia::IsRunning() && Kademlia::CKademlia::IsFirewalled()
1141 && !Kademlia::CUDPFirewallTester::IsFirewalledUDP(true) && Kademlia::CUDPFirewallTester::IsVerified()) ? 1 : 0;
1142
1143 CTagVarInt tagMisOptions2(CT_EMULE_MISCOPTIONS2,
1144 // (RESERVED )
1145 (uDirectUDPCallback << 12) |
1146 (uSupportsCaptcha << 11) |
1147 (uSupportsSourceEx2 << 10) |
1148 (uRequiresCryptLayer << 9) |
1149 (uRequestsCryptLayer << 8) |
1150 (uSupportsCryptLayer << 7) |
1151 (uReserved << 6) |
1152 (uExtMultiPacket << 5) |
1153 (uSupportLargeFiles << 4) |
1154 (uKadVersion << 0)
1155 , GetVBTTags() ? 0 : 32 );
1156 tagMisOptions2.WriteTagToFile(data);
1157
1158 const uint32 nOSInfoSupport = 1; // We support OS_INFO
1159 const uint32 nValueBasedTypeTags = 0; // Experimental, disabled
1160
1161 CTagVarInt tagMisCompatOptions(CT_EMULECOMPAT_OPTIONS,
1162 (nValueBasedTypeTags << 1*1) |
1163 (nOSInfoSupport << 1*0)
1164 , GetVBTTags() ? 0 : 32);
1165
1166 tagMisCompatOptions.WriteTagToFile(data);
1167
1168 #ifdef __SVN__
1169 wxString mod_name(MOD_VERSION_LONG);
1170 CTagString tagModName(ET_MOD_VERSION, mod_name);
1171 tagModName.WriteTagToFile(data);
1172 #endif
1173
1174 uint32 dwIP = 0;
1175 uint16 nPort = 0;
1176 if (theApp->IsConnectedED2K()) {
1177 dwIP = theApp->serverconnect->GetCurrentServer()->GetIP();
1178 nPort = theApp->serverconnect->GetCurrentServer()->GetPort();
1179 }
1180 data->WriteUInt32(dwIP);
1181 data->WriteUInt16(nPort);
1182 }
1183
1184
1185 void CUpDownClient::ProcessMuleCommentPacket(const byte* pachPacket, uint32 nSize)
1186 {
1187 if (!m_reqfile) {
1188 throw CInvalidPacket(wxT("Comment packet for unknown file"));
1189 }
1190
1191 if (!m_reqfile->IsPartFile()) {
1192 throw CInvalidPacket(wxT("Comment packet for completed file"));
1193 }
1194
1195 const CMemFile data(pachPacket, nSize);
1196
1197 uint8 rating = data.ReadUInt8();
1198 if (rating > 5) {
1199 AddDebugLogLineN( logClient, wxString(wxT("Invalid Rating for file '")) << m_clientFilename << wxT("' received: ") << rating);
1200 m_iRating = 0;
1201 } else {
1202 m_iRating = rating;
1203 AddDebugLogLineN( logClient, wxString(wxT("Rating for file '")) << m_clientFilename << wxT("' received: ") << m_iRating);
1204 }
1205
1206 // The comment is unicoded, with a uin32 len and safe read
1207 // (won't break if string size is < than advertised len)
1208 // Truncated to MAXFILECOMMENTLEN size
1209 m_strComment = data.ReadString((GetUnicodeSupport() != utf8strNone), 4 /* bytes (it's a uint32)*/, true).Left(MAXFILECOMMENTLEN);
1210
1211 AddDebugLogLineN( logClient, wxString(wxT("Description for file '")) << m_clientFilename << wxT("' received: ") << m_strComment);
1212
1213 // Update file rating
1214 m_reqfile->UpdateFileRatingCommentAvail();
1215 }
1216
1217
1218 void CUpDownClient::ClearDownloadBlockRequests()
1219 {
1220 {
1221 std::list<Requested_Block_Struct*>::iterator it = m_DownloadBlocks_list.begin();
1222 for (; it != m_DownloadBlocks_list.end(); ++it) {
1223 Requested_Block_Struct* cur_block = *it;
1224
1225 if (m_reqfile){
1226 m_reqfile->RemoveBlockFromList(cur_block->StartOffset, cur_block->EndOffset);
1227 }
1228
1229 delete cur_block;
1230 }
1231
1232 m_DownloadBlocks_list.clear();
1233 }
1234
1235 {
1236 std::list<Pending_Block_Struct*>::iterator it = m_PendingBlocks_list.begin();
1237 for (; it != m_PendingBlocks_list.end(); ++it) {
1238 Pending_Block_Struct* pending = *it;
1239
1240 if (m_reqfile) {
1241 m_reqfile->RemoveBlockFromList(pending->block->StartOffset, pending->block->EndOffset);
1242 }
1243
1244 delete pending->block;
1245 // Not always allocated
1246 if (pending->zStream){
1247 inflateEnd(pending->zStream);
1248 delete pending->zStream;
1249 }
1250
1251 delete pending;
1252 }
1253
1254 m_PendingBlocks_list.clear();
1255 }
1256 }
1257
1258
1259 bool CUpDownClient::Disconnected(const wxString& DEBUG_ONLY(strReason), bool bFromSocket)
1260 {
1261 //wxASSERT(theApp->clientlist->IsValidClient(this));
1262
1263 if (HasBeenDeleted()) {
1264 AddDebugLogLineN(logClient, wxT("Disconnected() called for already deleted client on ip ") + Uint32toStringIP(GetConnectIP()));
1265 return false;
1266 }
1267
1268 // was this a direct callback?
1269 if (m_dwDirectCallbackTimeout != 0) {
1270 theApp->clientlist->RemoveDirectCallback(this);
1271 m_dwDirectCallbackTimeout = 0;
1272 theApp->clientlist->AddDeadSource(this);
1273 AddDebugLogLineN(logClient, wxT("Direct callback failed to client on ip ") + Uint32toStringIP(GetConnectIP()));
1274 }
1275
1276 if (GetKadState() == KS_QUEUED_FWCHECK_UDP || GetKadState() == KS_CONNECTING_FWCHECK_UDP) {
1277 Kademlia::CUDPFirewallTester::SetUDPFWCheckResult(false, true, wxUINT32_SWAP_ALWAYS(GetConnectIP()), 0); // inform the tester that this test was cancelled
1278 } else if (GetKadState() == KS_FWCHECK_UDP) {
1279 Kademlia::CUDPFirewallTester::SetUDPFWCheckResult(false, false, wxUINT32_SWAP_ALWAYS(GetConnectIP()), 0); // inform the tester that this test has failed
1280 } else if (GetKadState() == KS_CONNECTED_BUDDY) {
1281 AddDebugLogLineN(logClient, wxT("Buddy client disconnected - ") + strReason);
1282 }
1283
1284 //If this is a KAD client object, just delete it!
1285 SetKadState(KS_NONE);
1286
1287 if (GetUploadState() == US_UPLOADING) {
1288 // sets US_NONE
1289 theApp->uploadqueue->RemoveFromUploadQueue(this);
1290 }
1291
1292 if (GetDownloadState() == DS_DOWNLOADING) {
1293 SetDownloadState(DS_ONQUEUE);
1294 } else {
1295 // ensure that all possible block requests are removed from the partfile
1296 ClearDownloadBlockRequests();
1297
1298 if (GetDownloadState() == DS_CONNECTED) {
1299 // successfully connected, but probably didn't respond to our filerequest
1300 theApp->clientlist->AddDeadSource(this);
1301 theApp->downloadqueue->RemoveSource(this);
1302 }
1303 }
1304
1305 // we had still an AICH request pending, handle it
1306 if (IsAICHReqPending()) {
1307 m_fAICHRequested = FALSE;
1308 CAICHHashSet::ClientAICHRequestFailed(this);
1309 }
1310
1311 // The remote client does not have to answer with OP_HASHSETANSWER *immediatly*
1312 // after we've sent OP_HASHSETREQUEST. It may occure that a (buggy) remote client
1313 // is sending use another OP_FILESTATUS which would let us change to DL-state to DS_ONQUEUE.
1314 if (((GetDownloadState() == DS_REQHASHSET) || m_fHashsetRequesting) && (m_reqfile)) {
1315 m_reqfile->SetHashSetNeeded(true);
1316 }
1317
1318 SourceItemType source_type = UNAVAILABLE_SOURCE;
1319 SourceItemType peer_type = UNAVAILABLE_SOURCE;
1320
1321 //check if this client is needed in any way, if not delete it
1322 bool bDelete = true;
1323 switch (m_nUploadState) {
1324 case US_ONUPLOADQUEUE:
1325 bDelete = false;
1326 peer_type = AVAILABLE_SOURCE;
1327 break;
1328 };
1329
1330 switch (m_nDownloadState) {
1331 case DS_ONQUEUE:
1332 source_type = A4AF_SOURCE; // Will be checked.
1333 case DS_TOOMANYCONNS:
1334 case DS_NONEEDEDPARTS:
1335 case DS_LOWTOLOWIP:
1336 bDelete = false;
1337 break;
1338 };
1339
1340 switch (m_nUploadState) {
1341 case US_CONNECTING:
1342 case US_WAITCALLBACK:
1343 case US_ERROR:
1344 theApp->clientlist->AddDeadSource(this);
1345 bDelete = true;
1346 };
1347
1348 switch (m_nDownloadState) {
1349 case DS_CONNECTING:
1350 case DS_WAITCALLBACK:
1351 case DS_ERROR:
1352 case DS_BANNED:
1353 theApp->clientlist->AddDeadSource(this);
1354 bDelete = true;
1355 };
1356
1357
1358 // We keep chat partners in any case
1359 if (GetChatState() != MS_NONE) {
1360 bDelete = false;
1361 m_pendingMessage.Clear();
1362 Notify_ChatConnResult(false,GUI_ID(GetIP(),GetUserPort()),wxEmptyString);
1363 }
1364
1365 // Delete socket
1366 if (!bFromSocket && m_socket) {
1367 wxASSERT (theApp->listensocket->IsValidSocket(m_socket));
1368 m_socket->Safe_Delete();
1369 }
1370
1371 SetSocket(NULL);
1372
1373 if (m_iFileListRequested) {
1374 AddLogLineC(CFormat(_("Failed to retrieve shared files from user '%s'")) % GetUserName() );
1375 m_iFileListRequested = 0;
1376 }
1377
1378
1379 if (bDelete) {
1380 if (m_Friend) {
1381 // Remove the friend linkage
1382 m_Friend->UnLinkClient(); // this notifies
1383 }
1384 } else {
1385 Notify_SharedCtrlRefreshClient(ECID(), peer_type);
1386 Notify_SourceCtrlUpdateSource(ECID(), source_type);
1387
1388 m_fHashsetRequesting = 0;
1389 SetSentCancelTransfer(0);
1390 m_bHelloAnswerPending = false;
1391 m_fSentOutOfPartReqs = 0;
1392 }
1393 AddDebugLogLineN(logClient, CFormat(wxT("--- %s client D:%d U:%d \"%s\"; Reason was %s"))
1394 % (bDelete ? wxT("Deleted") : wxT("Disconnected"))
1395 % m_nDownloadState % m_nUploadState % GetClientFullInfo() % strReason );
1396
1397 return bDelete;
1398 }
1399
1400 //Returned bool is not if the TryToConnect is successful or not..
1401 //false means the client was deleted!
1402 //true means the client was not deleted!
1403 bool CUpDownClient::TryToConnect(bool bIgnoreMaxCon)
1404 {
1405 // Kad reviewed
1406 if (theApp->listensocket->TooManySockets() && !bIgnoreMaxCon ) {
1407 if (!(m_socket && m_socket->IsConnected())) {
1408 if(Disconnected(wxT("Too many connections"))) {
1409 Safe_Delete();
1410 return false;
1411 }
1412 return true;
1413 }
1414 }
1415
1416 // Do not try to connect to source which are incompatible with our encryption setting (one requires it, and the other one doesn't supports it)
1417 if ( (RequiresCryptLayer() && !thePrefs::IsClientCryptLayerSupported()) || (thePrefs::IsClientCryptLayerRequired() && !SupportsCryptLayer()) ){
1418 if(Disconnected(wxT("CryptLayer-Settings (Obfuscation) incompatible"))){
1419 Safe_Delete();
1420 return false;
1421 } else {
1422 return true;
1423 }
1424 }
1425
1426 // Ipfilter check
1427 uint32 uClientIP = GetIP();
1428 if (uClientIP == 0 && !HasLowID()) {
1429 uClientIP = wxUINT32_SWAP_ALWAYS(m_nUserIDHybrid);
1430 }
1431
1432 if (uClientIP) {
1433 // Although we filter all received IPs (server sources, source exchange) and all incomming connection attempts,
1434 // we do have to filter outgoing connection attempts here too, because we may have updated the ip filter list
1435 if (theApp->ipfilter->IsFiltered(uClientIP)) {
1436 AddDebugLogLineN(logIPFilter, CFormat(wxT("Filtered ip %u (%s) on TryToConnect\n")) % uClientIP % Uint32toStringIP(uClientIP));
1437 if (Disconnected(wxT("IPFilter"))) {
1438 Safe_Delete();
1439 return false;
1440 }
1441 return true;
1442 }
1443
1444 // for safety: check again whether that IP is banned
1445 if (theApp->clientlist->IsBannedClient(uClientIP)) {
1446 AddDebugLogLineN(logClient, wxT("Refused to connect to banned client ") + Uint32toStringIP(uClientIP));
1447 if (Disconnected(wxT("Banned IP"))) {
1448 Safe_Delete();
1449 return false;
1450 }
1451 return true;
1452 }
1453 }
1454
1455 if (GetKadState() == KS_QUEUED_FWCHECK) {
1456 SetKadState(KS_CONNECTING_FWCHECK);
1457 } else if (GetKadState() == KS_QUEUED_FWCHECK_UDP) {
1458 SetKadState(KS_CONNECTING_FWCHECK_UDP);
1459 }
1460
1461 if (HasLowID()) {
1462 if (!theApp->CanDoCallback(GetServerIP(), GetServerPort())) {
1463 //We cannot do a callback!
1464 if (GetDownloadState() == DS_CONNECTING) {
1465 SetDownloadState(DS_LOWTOLOWIP);
1466 } else if (GetDownloadState() == DS_REQHASHSET) {
1467 SetDownloadState(DS_ONQUEUE);
1468 m_reqfile->SetHashSetNeeded(true);
1469 }
1470 if (GetUploadState() == US_CONNECTING) {
1471 if(Disconnected(wxT("LowID->LowID and US_CONNECTING"))) {
1472 Safe_Delete();
1473 return false;
1474 }
1475 }
1476 return true;
1477 }
1478
1479 //We already know we are not firewalled here as the above condition already detected LowID->LowID and returned.
1480 //If ANYTHING changes with the "if(!theApp->CanDoCallback(this))" above that will let you fall through
1481 //with the condition that the source is firewalled and we are firewalled, we must
1482 //recheck it before the this check..
1483 if (HasValidBuddyID() && !GetBuddyIP() && !GetBuddyPort() && !theApp->serverconnect->IsLocalServer(GetServerIP(), GetServerPort())
1484 && !(SupportsDirectUDPCallback() && thePrefs::GetEffectiveUDPPort() != 0)) {
1485 //This is a Kad firewalled source that we want to do a special callback because it has no buddyIP or buddyPort.
1486 if( Kademlia::CKademlia::IsConnected() ) {
1487 //We are connect to Kad
1488 if( Kademlia::CKademlia::GetPrefs()->GetTotalSource() > 0 || Kademlia::CSearchManager::AlreadySearchingFor(Kademlia::CUInt128(GetBuddyID()))) {
1489 //There are too many source lookups already or we are already searching this key.
1490 SetDownloadState(DS_TOOMANYCONNSKAD);
1491 return true;
1492 }
1493 }
1494 }
1495 }
1496
1497 if (!m_socket || !m_socket->IsConnected()) {
1498 if (m_socket) {
1499 m_socket->Safe_Delete();
1500 }
1501 m_socket = new CClientTCPSocket(this, thePrefs::GetProxyData());
1502 } else {
1503 ConnectionEstablished();
1504 return true;
1505 }
1506
1507
1508 if (HasLowID() && SupportsDirectUDPCallback() && thePrefs::GetEffectiveUDPPort() != 0 && GetConnectIP() != 0) { // LOWID with DirectCallback
1509 if (m_dwDirectCallbackTimeout != 0) {
1510 AddDebugLogLineN(logClient, wxT("ERROR: Trying Direct UDP Callback while already trying to connect to client on ip ") + Uint32toStringIP(GetConnectIP()));
1511 return true; // We're already trying a direct connection to this client
1512 }
1513 // a direct callback is possible - since no other parties are involved and only one additional packet overhead
1514 // is used we basically handle it like a normal connection try, no restrictions apply
1515 // we already check above with !theApp->CanDoCallback(this) if any callback is possible at all
1516 m_dwDirectCallbackTimeout = ::GetTickCount() + SEC2MS(45);
1517 theApp->clientlist->AddDirectCallbackClient(this);
1518 AddDebugLogLineN(logClient, CFormat(wxT("Direct Callback on port %u to client on ip %s")) % GetKadPort() % Uint32toStringIP(GetConnectIP()));
1519
1520 CMemFile data;
1521 data.WriteUInt16(thePrefs::GetPort()); // needs to know our port
1522 data.WriteHash(thePrefs::GetUserHash()); // and userhash
1523 // our connection settings
1524 data.WriteUInt8(Kademlia::CPrefs::GetMyConnectOptions(true, false));
1525 AddDebugLogLineN(logClientUDP, wxT("Sending OP_DIRECTCALLBACKREQ to ") + Uint32_16toStringIP_Port(GetConnectIP(), GetKadPort()));
1526 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_DIRECTCALLBACKREQ);
1527 theStats::AddUpOverheadOther(packet->GetPacketSize());
1528 theApp->clientudp->SendPacket(packet, GetConnectIP(), GetKadPort(), ShouldReceiveCryptUDPPackets(), GetUserHash().GetHash(), false, 0);
1529 } else if (HasLowID()) { // LOWID
1530 if (GetDownloadState() == DS_CONNECTING) {
1531 SetDownloadState(DS_WAITCALLBACK);
1532 }
1533 if (GetUploadState() == US_CONNECTING) {
1534 if(Disconnected(wxT("LowID and US_CONNECTING"))) {
1535 Safe_Delete();
1536 return false;
1537 }
1538 return true;
1539 }
1540
1541 if (theApp->serverconnect->IsLocalServer(m_dwServerIP,m_nServerPort)) {
1542 CMemFile data;
1543 // AFAICS, this id must be reversed to be sent to clients
1544 // But if I reverse it, we do a serve violation ;)
1545 data.WriteUInt32(m_nUserIDHybrid);
1546 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_CALLBACKREQUEST);
1547 theStats::AddUpOverheadServer(packet->GetPacketSize());
1548 AddDebugLogLineN(logLocalClient, wxT("Local Client: OP_CALLBACKREQUEST to ") + GetFullIP());
1549 theApp->serverconnect->SendPacket(packet);
1550 SetDownloadState(DS_WAITCALLBACK);
1551 } else {
1552 if (GetUploadState() == US_NONE && (!GetRemoteQueueRank() || m_bReaskPending)) {
1553
1554 if( !HasValidBuddyID() ) {
1555 theApp->downloadqueue->RemoveSource(this);
1556 if (Disconnected(wxT("LowID and US_NONE and QR=0"))) {
1557 Safe_Delete();
1558 return false;
1559 }
1560 return true;
1561 }
1562
1563 if( !Kademlia::CKademlia::IsConnected() ) {
1564 //We are not connected to Kad and this is a Kad Firewalled source..
1565 theApp->downloadqueue->RemoveSource(this);
1566 if(Disconnected(wxT("Kad Firewalled source but not connected to Kad."))) {
1567 Safe_Delete();
1568 return false;
1569 }
1570 return true;
1571 }
1572
1573 if( GetDownloadState() == DS_WAITCALLBACK ) {
1574 if( GetBuddyIP() && GetBuddyPort()) {
1575 CMemFile bio(34);
1576 bio.WriteUInt128(Kademlia::CUInt128(GetBuddyID()));
1577 bio.WriteUInt128(Kademlia::CUInt128(m_reqfile->GetFileHash().GetHash()));
1578 bio.WriteUInt16(thePrefs::GetPort());
1579 CPacket* packet = new CPacket(bio, OP_KADEMLIAHEADER, KADEMLIA_CALLBACK_REQ);
1580 // eMule FIXME: We don't know which kadversion the buddy has, so we need to send unencrypted
1581 theApp->clientudp->SendPacket(packet, GetBuddyIP(), GetBuddyPort(), false, NULL, true, 0);
1582 AddDebugLogLineN(logClientKadUDP, CFormat(wxT("KadCallbackReq (size=%i) to %s")) % packet->GetPacketSize() % Uint32_16toStringIP_Port(GetBuddyIP(), GetBuddyPort()));
1583 theStats::AddUpOverheadKad(packet->GetRealPacketSize());
1584 SetDownloadState(DS_WAITCALLBACKKAD);
1585 } else {
1586 AddLogLineN(_("Searching buddy for lowid connection"));
1587 //Create search to find buddy.
1588 Kademlia::CSearch *findSource = new Kademlia::CSearch;
1589 findSource->SetSearchTypes(Kademlia::CSearch::FINDSOURCE);
1590 findSource->SetTargetID(Kademlia::CUInt128(GetBuddyID()));
1591 findSource->AddFileID(Kademlia::CUInt128(m_reqfile->GetFileHash().GetHash()));
1592 if(Kademlia::CSearchManager::StartSearch(findSource)) {
1593 //Started lookup..
1594 SetDownloadState(DS_WAITCALLBACKKAD);
1595 } else {
1596 //This should never happen..
1597 wxFAIL;
1598 }
1599 }
1600 }
1601 } else {
1602 if (GetDownloadState() == DS_WAITCALLBACK) {
1603 m_bReaskPending = true;
1604 SetDownloadState(DS_ONQUEUE);
1605 }
1606 }
1607 }
1608 } else { // HIGHID
1609 if (!Connect()) {
1610 return false;
1611 }
1612 }
1613 return true;
1614 }
1615
1616 bool CUpDownClient::Connect()
1617 {
1618 m_hasbeenobfuscatinglately = false;
1619
1620 if (!m_socket->IsOk()) {
1621 // Enable or disable crypting based on our and the remote clients preference
1622 if (HasValidHash() && SupportsCryptLayer() && thePrefs::IsClientCryptLayerSupported() && (RequestsCryptLayer() || thePrefs::IsClientCryptLayerRequested())){
1623 m_socket->SetConnectionEncryption(true, GetUserHash().GetHash(), false);
1624 } else {
1625 m_socket->SetConnectionEncryption(false, NULL, false);
1626 }
1627 amuleIPV4Address tmp;
1628 tmp.Hostname(GetConnectIP());
1629 tmp.Service(GetUserPort());
1630 AddDebugLogLineN(logClient, wxT("Trying to connect to ") + Uint32_16toStringIP_Port(GetConnectIP(),GetUserPort()));
1631 m_socket->Connect(tmp, false);
1632 // We should send hello packets AFTER connecting!
1633 // so I moved it to OnConnect
1634 return true;
1635 } else {
1636 return false;
1637 }
1638 }
1639
1640 void CUpDownClient::ConnectionEstablished()
1641 {
1642 /* Kry - First thing, check if this client was just used to retrieve
1643 info. That's some debug thing for myself... check connection_reason
1644 definition */
1645
1646 m_hasbeenobfuscatinglately = (m_socket && m_socket->IsConnected() && m_socket->IsObfusicating());
1647
1648 #ifdef __DEBUG__
1649 if (!connection_reason.IsEmpty()) {
1650 AddLogLineN(CFormat(wxT("Got client info checking for %s: %s\nDisconnecting and deleting.")) % connection_reason % GetClientFullInfo());
1651 connection_reason.Clear(); // So we don't re-print on destructor.
1652 Safe_Delete();
1653 return;
1654 }
1655 #endif
1656
1657 // Check if we should use this client to retrieve our public IP
1658 // Ignore local ip on GetPublicIP (could be wrong)
1659 if (theApp->GetPublicIP(true) == 0 && theApp->IsConnectedED2K()) {
1660 SendPublicIPRequest();
1661 }
1662
1663 // was this a direct callback?
1664 if (m_dwDirectCallbackTimeout != 0){
1665 theApp->clientlist->RemoveDirectCallback(this);
1666 m_dwDirectCallbackTimeout = 0;
1667 AddDebugLogLineN(logClient, wxT("Direct Callback succeeded, connection established to ") + Uint32toStringIP(GetConnectIP()));
1668 }
1669
1670 switch (GetKadState()) {
1671 case KS_CONNECTING_FWCHECK:
1672 SetKadState(KS_CONNECTED_FWCHECK);
1673 break;
1674 case KS_CONNECTING_BUDDY:
1675 case KS_INCOMING_BUDDY:
1676 SetKadState(KS_CONNECTED_BUDDY);
1677 break;
1678 case KS_CONNECTING_FWCHECK_UDP:
1679 SetKadState(KS_FWCHECK_UDP);
1680 SendFirewallCheckUDPRequest();
1681 break;
1682 default:
1683 break;
1684 }
1685
1686 // ok we have a connection, lets see if we want anything from this client
1687 if (GetChatState() == MS_CONNECTING) {
1688 SetChatState( MS_CHATTING );
1689 }
1690
1691 if (GetChatState() == MS_CHATTING) {
1692 bool result = true;
1693 if (!m_pendingMessage.IsEmpty()) {
1694 result = SendChatMessage(m_pendingMessage);
1695 }
1696 Notify_ChatConnResult(result,GUI_ID(GetIP(),GetUserPort()),m_pendingMessage);
1697 m_pendingMessage.Clear();
1698 }
1699
1700 switch(GetDownloadState()) {
1701 case DS_CONNECTING:
1702 case DS_WAITCALLBACK:
1703 case DS_WAITCALLBACKKAD:
1704 m_bReaskPending = false;
1705 SetDownloadState(DS_CONNECTED);
1706 SendFileRequest();
1707 }
1708 if (m_bReaskPending){
1709 m_bReaskPending = false;
1710 if (GetDownloadState() != DS_NONE && GetDownloadState() != DS_DOWNLOADING) {
1711 SetDownloadState(DS_CONNECTED);
1712 SendFileRequest();
1713 }
1714 }
1715 switch(GetUploadState()){
1716 case US_CONNECTING:
1717 case US_WAITCALLBACK:
1718 if (theApp->uploadqueue->IsDownloading(this)) {
1719 SetUploadState(US_UPLOADING);
1720 CPacket* packet = new CPacket(OP_ACCEPTUPLOADREQ, 0, OP_EDONKEYPROT);
1721 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
1722 SendPacket(packet,true);
1723 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ACCEPTUPLOADREQ to ") + GetFullIP() );
1724 }
1725 }
1726 if (m_iFileListRequested == 1) {
1727 CPacket* packet = new CPacket(m_fSharedDirectories ? OP_ASKSHAREDDIRS : OP_ASKSHAREDFILES, 0, OP_EDONKEYPROT);
1728 theStats::AddUpOverheadOther(packet->GetPacketSize());
1729 SendPacket(packet,true,true);
1730 #ifdef __DEBUG__
1731 if (m_fSharedDirectories) {
1732 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ASKSHAREDDIRS to ") + GetFullIP() );
1733 } else {
1734 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ASKSHAREDFILES to ") + GetFullIP() );
1735 }
1736 #endif
1737 }
1738
1739 while (!m_WaitingPackets_list.empty()) {
1740 CPacket* packet = m_WaitingPackets_list.front();
1741 m_WaitingPackets_list.pop_front();
1742
1743 SendPacket(packet);
1744 }
1745 }
1746
1747
1748 int CUpDownClient::GetHashType() const
1749 {
1750 if ( m_UserHash[5] == 13 && m_UserHash[14] == 110 ) {
1751 return SO_OLDEMULE;
1752 }
1753
1754 if ( m_UserHash[5] == 14 && m_UserHash[14] == 111 ) {
1755 return SO_EMULE;
1756 }
1757
1758 if ( m_UserHash[5] == 'M' && m_UserHash[14] == 'L' ) {
1759 return SO_MLDONKEY;
1760 }
1761
1762 return SO_UNKNOWN;
1763 }
1764
1765
1766 void CUpDownClient::SetSocket(CClientTCPSocket* socket)
1767 {
1768 #ifdef __DEBUG__
1769 if (m_socket == NULL && socket != NULL) {
1770 theStats::SocketAssignedToClient();
1771 } else if (m_socket != NULL && socket == NULL) {
1772 theStats::SocketUnassignedFromClient();
1773 }
1774 #endif
1775 m_socket = socket;
1776 }
1777
1778
1779 void CUpDownClient::ReGetClientSoft()
1780 {
1781 if (m_Username.IsEmpty()) {
1782 m_clientSoft=SO_UNKNOWN;
1783 m_clientVerString = m_clientSoftString = m_clientVersionString = m_fullClientVerString = _("Unknown");
1784 UpdateStats();
1785 return;
1786 }
1787
1788 int iHashType = GetHashType();
1789 wxString clientModString;
1790 if (iHashType == SO_EMULE) {
1791
1792 m_clientSoft = m_byCompatibleClient;
1793 m_clientSoftString = GetSoftName(m_clientSoft);
1794 // Special issues:
1795 if(!GetClientModString().IsEmpty() && (m_clientSoft != SO_EMULE)) {
1796 m_clientSoftString = GetClientModString();
1797 }
1798 // Isn't xMule annoying?
1799 if ((m_clientSoft == SO_LXMULE) && (GetMuleVersion() > 0x26) && (GetMuleVersion() != 0x99)) {
1800 m_clientSoftString += CFormat(_(" (Fake eMule version %#x)")) % GetMuleVersion();
1801 }
1802 if ((m_clientSoft == SO_EMULE) &&
1803 (
1804 wxString(GetClientModString()).MakeLower().Find(wxT("xmule")) != -1
1805 || GetUserName().Find(wxT("xmule.")) != -1
1806 )
1807 ) {
1808 // FAKE eMule -a newer xMule faking is ident.
1809 m_clientSoft = SO_LXMULE;
1810 if (GetClientModString().IsEmpty() == false) {
1811 m_clientSoftString = GetClientModString() + _(" (Fake eMule)");
1812 } else {
1813 m_clientSoftString = _("xMule (Fake eMule)"); // don't use GetSoftName, it's not lmule.
1814 }
1815 }
1816 // Now, what if we don't know this SO_ID?
1817 if (m_clientSoftString.IsEmpty()) {
1818 if(m_bIsML) {
1819 m_clientSoft = SO_MLDONKEY;
1820 m_clientSoftString = GetSoftName(m_clientSoft);
1821 } else if (m_bIsHybrid) {
1822 m_clientSoft = SO_EDONKEYHYBRID;
1823 m_clientSoftString = GetSoftName(m_clientSoft);
1824 } else if (m_byCompatibleClient != 0) {
1825 m_clientSoft = SO_COMPAT_UNK;
1826 #ifdef __DEBUG__
1827 if (
1828 // Exceptions:
1829 (m_byCompatibleClient != 0xf0) // Chinese leech mod
1830 && (1==1) // Your ad here
1831 ) {
1832 AddLogLineNS(CFormat(wxT("Compatible client found with ET_COMPATIBLECLIENT of %x")) % m_byCompatibleClient);
1833 }
1834 #endif
1835 m_clientSoftString = CFormat(wxT("%s(%#x)")) % GetSoftName(m_clientSoft) % m_byCompatibleClient;
1836 } else {
1837 // If we step here, it might mean 2 things:
1838 // a eMule
1839 // a Compat Client that has sent no MuleInfo packet yet.
1840 m_clientSoft = SO_EMULE;
1841 m_clientSoftString = wxT("eMule");
1842 }
1843 }
1844
1845 if (m_byEmuleVersion == 0) {
1846 m_nClientVersion = MAKE_CLIENT_VERSION(0,0,0);
1847 } else if (m_byEmuleVersion != 0x99) {
1848 uint32 nClientMinVersion = (m_byEmuleVersion >> 4)*10 + (m_byEmuleVersion & 0x0f);
1849 m_nClientVersion = MAKE_CLIENT_VERSION(0,nClientMinVersion,0);
1850 switch (m_clientSoft) {
1851 case SO_AMULE:
1852 m_clientVerString = CFormat(_("1.x (based on eMule v0.%u)")) % nClientMinVersion;
1853 break;
1854 case SO_LPHANT:
1855 m_clientVerString = wxT("< v0.05");
1856 break;
1857 default:
1858 clientModString = GetClientModString();
1859 m_clientVerString = CFormat(wxT("v0.%u")) % nClientMinVersion;
1860 break;
1861 }
1862 } else {
1863 uint32 nClientMajVersion = (m_nClientVersion >> 17) & 0x7f;
1864 uint32 nClientMinVersion = (m_nClientVersion >> 10) & 0x7f;
1865 uint32 nClientUpVersion = (m_nClientVersion >> 7) & 0x07;
1866
1867 m_nClientVersion = MAKE_CLIENT_VERSION(nClientMajVersion, nClientMinVersion, nClientUpVersion);
1868
1869 switch (m_clientSoft) {
1870 case SO_AMULE:
1871 case SO_LXMULE:
1872 case SO_HYDRANODE:
1873 case SO_MLDONKEY:
1874 case SO_NEW_MLDONKEY:
1875 case SO_NEW2_MLDONKEY:
1876 // Kry - xMule started sending correct version tags on 1.9.1b.
1877 // It only took them 4 months, and being told by me and the
1878 // eMule+ developers, so I think they're slowly getting smarter.
1879 // They are based on our implementation, so we use the same format
1880 // for the version string.
1881 m_clientVerString = CFormat(wxT("v%u.%u.%u")) % nClientMajVersion % nClientMinVersion % nClientUpVersion;
1882 break;
1883 case SO_LPHANT:
1884 m_clientVerString = CFormat(wxT(" v%u.%.2u%c")) % (nClientMajVersion-1) % nClientMinVersion % ('a' + nClientUpVersion);
1885 break;
1886 case SO_EMULEPLUS:
1887 m_clientVerString = CFormat(wxT("v%u")) % nClientMajVersion;
1888 if(nClientMinVersion != 0) {
1889 m_clientVerString += CFormat(wxT(".%u")) % nClientMinVersion;
1890 }
1891 if(nClientUpVersion != 0) {
1892 m_clientVerString += CFormat(wxT("%c")) % ('a' + nClientUpVersion - 1);
1893 }
1894 break;
1895 default:
1896 clientModString = GetClientModString();
1897 m_clientVerString = CFormat(wxT("v%u.%u%c")) % nClientMajVersion % nClientMinVersion % ('a' + nClientUpVersion);
1898 break;
1899 }
1900 }
1901 } else if (m_bIsHybrid) {
1902 // seen:
1903 // 105010 50.10
1904 // 10501 50.1
1905 // 1051 51.0
1906 // 501 50.1
1907
1908 m_clientSoft = SO_EDONKEYHYBRID;
1909 m_clientSoftString = GetSoftName(m_clientSoft);
1910
1911 uint32 nClientMajVersion;
1912 uint32 nClientMinVersion;
1913 uint32 nClientUpVersion;
1914 if (m_nClientVersion > 100000) {
1915 uint32 uMaj = m_nClientVersion/100000;
1916 nClientMajVersion = uMaj - 1;
1917 nClientMinVersion = (m_nClientVersion - uMaj*100000) / 100;
1918 nClientUpVersion = m_nClientVersion % 100;
1919 }
1920 else if (m_nClientVersion > 10000) {
1921 uint32 uMaj = m_nClientVersion/10000;
1922 nClientMajVersion = uMaj - 1;
1923 nClientMinVersion = (m_nClientVersion - uMaj*10000) / 10;
1924 nClientUpVersion = m_nClientVersion % 10;
1925 }
1926 else if (m_nClientVersion > 1000) {
1927 uint32 uMaj = m_nClientVersion/1000;
1928 nClientMajVersion = uMaj - 1;
1929 nClientMinVersion = m_nClientVersion - uMaj*1000;
1930 nClientUpVersion = 0;
1931 }
1932 else if (m_nClientVersion > 100) {
1933 uint32 uMin = m_nClientVersion/10;
1934 nClientMajVersion = 0;
1935 nClientMinVersion = uMin;
1936 nClientUpVersion = m_nClientVersion - uMin*10;
1937 }
1938 else{
1939 nClientMajVersion = 0;
1940 nClientMinVersion = m_nClientVersion;
1941 nClientUpVersion = 0;
1942 }
1943 m_nClientVersion = MAKE_CLIENT_VERSION(nClientMajVersion, nClientMinVersion, nClientUpVersion);
1944 if (nClientUpVersion) {
1945 m_clientVerString = CFormat(wxT("v%u.%u.%u")) % nClientMajVersion % nClientMinVersion % nClientUpVersion;
1946 } else {
1947 m_clientVerString = CFormat(wxT("v%u.%u")) % nClientMajVersion % nClientMinVersion;
1948 }
1949 } else if (m_bIsML || (iHashType == SO_MLDONKEY)) {
1950 m_clientSoft = SO_MLDONKEY;
1951 m_clientSoftString = GetSoftName(m_clientSoft);
1952 uint32 nClientMinVersion = m_nClientVersion;
1953 m_nClientVersion = MAKE_CLIENT_VERSION(0, nClientMinVersion, 0);
1954 m_clientVerString = CFormat(wxT("v0.%u")) % nClientMinVersion;
1955 } else if (iHashType == SO_OLDEMULE) {
1956 m_clientSoft = SO_OLDEMULE;
1957 m_clientSoftString = GetSoftName(m_clientSoft);
1958 uint32 nClientMinVersion = m_nClientVersion;
1959 m_nClientVersion = MAKE_CLIENT_VERSION(0, nClientMinVersion, 0);
1960 m_clientVerString = CFormat(wxT("v0.%u")) % nClientMinVersion;
1961 } else {
1962 m_clientSoft = SO_EDONKEY;
1963 m_clientSoftString = GetSoftName(m_clientSoft);
1964 m_nClientVersion *= 10;
1965 m_clientVerString = CFormat(wxT("v%u.%u")) % (m_nClientVersion / 100000) % ((m_nClientVersion / 1000) % 100);
1966 }
1967
1968 m_clientVersionString = m_clientVerString;
1969 if (!clientModString.IsEmpty()) {
1970 m_clientVerString += wxT(" - ") + clientModString;
1971 }
1972 m_fullClientVerString = m_clientSoftString + wxT(" ") + m_clientVerString;
1973
1974 UpdateStats();
1975 }
1976
1977 void CUpDownClient::RequestSharedFileList()
1978 {
1979 if (m_iFileListRequested == 0) {
1980 AddDebugLogLineN( logClient, wxString( wxT("Requesting shared files from ") ) + GetUserName() );
1981 m_iFileListRequested = 1;
1982 TryToConnect(true);
1983 } else {
1984 AddDebugLogLineN( logClient, CFormat( wxT("Requesting shared files from user %s (%u) is already in progress") ) % GetUserName() % GetUserIDHybrid() );
1985 }
1986 }
1987
1988
1989 void CUpDownClient::ProcessSharedFileList(const byte* pachPacket, uint32 nSize, wxString& pszDirectory)
1990 {
1991 if (m_iFileListRequested > 0) {
1992 m_iFileListRequested--;
1993 theApp->searchlist->ProcessSharedFileList(pachPacket, nSize, this, NULL, pszDirectory);
1994 }
1995 }
1996
1997
1998 void CUpDownClient::ResetFileStatusInfo()
1999 {
2000 m_nPartCount = 0;
2001
2002 if ( m_reqfile ) {
2003 m_reqfile->UpdatePartsFrequency( this, false );
2004 }
2005 m_downPartStatus.clear();
2006
2007 m_clientFilename.Clear();
2008
2009 m_bCompleteSource = false;
2010 m_dwLastAskedTime = 0;
2011 m_iRating = 0;
2012 m_strComment.Clear();
2013
2014 if (m_pReqFileAICHHash != NULL) {
2015 delete m_pReqFileAICHHash;
2016 m_pReqFileAICHHash = NULL;
2017 }
2018
2019 }
2020
2021 wxString CUpDownClient::GetUploadFileInfo()
2022 {
2023 // build info text and display it
2024 wxString sRet;
2025 sRet = (CFormat(_("NickName: %s ID: %u")) % GetUserName() % GetUserIDHybrid()) + wxT(" ");
2026 if (m_reqfile) {
2027 sRet += CFormat(_("Requested: %s\n")) % m_reqfile->GetFileName();
2028 sRet += CFormat(
2029 wxPLURAL("Filestats for this session: Accepted %d of %d request, %s transferred\n", "Filestats for this session: Accepted %d of %d requests, %s transferred\n", m_reqfile->statistic.GetRequests())
2030 ) % m_reqfile->statistic.GetAccepts() % m_reqfile->statistic.GetRequests() % CastItoXBytes(m_reqfile->statistic.GetTransferred());
2031 sRet += CFormat(
2032 wxPLURAL("Filestats for all sessions: Accepted %d of %d request, %s transferred\n", "Filestats for all sessions: Accepted %d of %d requests, %s transferred\n", m_reqfile->statistic.GetAllTimeRequests())
2033 ) % m_reqfile->statistic.GetAllTimeAccepts() % m_reqfile->statistic.GetAllTimeRequests() % CastItoXBytes(m_reqfile->statistic.GetAllTimeTransferred());
2034 } else {
2035 sRet += _("Requested unknown file");
2036 }
2037 return sRet;
2038 }
2039
2040 // sends a packet, if needed it will establish a connection before
2041 // options used: ignore max connections, control packet, delete packet
2042 // !if the functions returns false it is _possible_ that this clientobject was deleted, because the connectiontry fails
2043 bool CUpDownClient::SafeSendPacket(CPacket* packet)
2044 {
2045 if (IsConnected()) {
2046 SendPacket(packet, true);
2047 return true;
2048 } else {
2049 m_WaitingPackets_list.push_back(packet);
2050 return TryToConnect(true);
2051 }
2052 }
2053
2054 void CUpDownClient::SendPublicKeyPacket(){
2055 // send our public key to the client who requested it
2056 if (m_socket == NULL || credits == NULL || m_SecureIdentState != IS_KEYANDSIGNEEDED){
2057 wxFAIL;
2058 return;
2059 }
2060 if (!theApp->CryptoAvailable())
2061 return;
2062
2063 CMemFile data;
2064 data.WriteUInt8(theApp->clientcredits->GetPubKeyLen());
2065 data.Write(theApp->clientcredits->GetPublicKey(), theApp->clientcredits->GetPubKeyLen());
2066 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_PUBLICKEY);
2067
2068 theStats::AddUpOverheadOther(packet->GetPacketSize());
2069 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_PUBLICKEY to ") + GetFullIP() );
2070 SendPacket(packet,true,true);
2071 m_SecureIdentState = IS_SIGNATURENEEDED;
2072 }
2073
2074
2075 void CUpDownClient::SendSignaturePacket(){
2076 // signate the public key of this client and send it
2077 if (m_socket == NULL || credits == NULL || m_SecureIdentState == 0){
2078 wxFAIL;
2079 return;
2080 }
2081
2082 if (!theApp->CryptoAvailable()) {
2083 return;
2084 }
2085 if (credits->GetSecIDKeyLen() == 0) {
2086 return; // We don't have his public key yet, will be back here later
2087 }
2088 // do we have a challenge value received (actually we should if we are in this function)
2089 if (credits->m_dwCryptRndChallengeFrom == 0){
2090 AddDebugLogLineN( logClient, wxString(wxT("Want to send signature but challenge value is invalid - User ")) + GetUserName());
2091 return;
2092 }
2093 // v2
2094 // we will use v1 as default, except if only v2 is supported
2095 bool bUseV2;
2096 if ( (m_bySupportSecIdent&1) == 1 )
2097 bUseV2 = false;
2098 else
2099 bUseV2 = true;
2100
2101 uint8 byChaIPKind = 0;
2102 uint32 ChallengeIP = 0;
2103 if (bUseV2){
2104 if (::IsLowID(theApp->GetED2KID())) {
2105 // we cannot do not know for sure our public ip, so use the remote clients one
2106 ChallengeIP = GetIP();
2107 byChaIPKind = CRYPT_CIP_REMOTECLIENT;
2108 } else {
2109 ChallengeIP = theApp->GetED2KID();
2110 byChaIPKind = CRYPT_CIP_LOCALCLIENT;
2111 }
2112 }
2113 //end v2
2114 byte achBuffer[250];
2115
2116 uint8 siglen = theApp->clientcredits->CreateSignature(credits, achBuffer, 250, ChallengeIP, byChaIPKind );
2117 if (siglen == 0){
2118 wxFAIL;
2119 return;
2120 }
2121 CMemFile data;
2122 data.WriteUInt8(siglen);
2123 data.Write(achBuffer, siglen);
2124 if (bUseV2) {
2125 data.WriteUInt8(byChaIPKind);
2126 }
2127
2128 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_SIGNATURE);
2129
2130 theStats::AddUpOverheadOther(packet->GetPacketSize());
2131 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_SIGNATURE to ") + GetFullIP() );
2132 SendPacket(packet,true,true);
2133 m_SecureIdentState = IS_ALLREQUESTSSEND;
2134 }
2135
2136
2137 void CUpDownClient::ProcessPublicKeyPacket(const byte* pachPacket, uint32 nSize)
2138 {
2139 theApp->clientlist->AddTrackClient(this);
2140
2141 if (m_socket == NULL || credits == NULL || pachPacket[0] != nSize-1
2142 || nSize == 0 || nSize > 250){
2143 wxFAIL;
2144 return;
2145 }
2146 if (!theApp->CryptoAvailable())
2147 return;
2148 // the function will handle everything (mulitple key etc)
2149 if (credits->SetSecureIdent(pachPacket+1, pachPacket[0])){
2150 // if this client wants a signature, now we can send him one
2151 if (m_SecureIdentState == IS_SIGNATURENEEDED){
2152 SendSignaturePacket();
2153 }
2154 else if (m_SecureIdentState == IS_KEYANDSIGNEEDED) {
2155 // something is wrong
2156 AddDebugLogLineN( logClient, wxT("Invalid State error: IS_KEYANDSIGNEEDED in ProcessPublicKeyPacket") );
2157 }
2158 } else {
2159 AddDebugLogLineN( logClient, wxT("Failed to use new received public key") );
2160 }
2161 }
2162
2163
2164 void CUpDownClient::ProcessSignaturePacket(const byte* pachPacket, uint32 nSize)
2165 {
2166 // here we spread the good guys from the bad ones ;)
2167
2168 if (m_socket == NULL || credits == NULL || nSize == 0 || nSize > 250){
2169 wxFAIL;
2170 return;
2171 }
2172
2173 uint8 byChaIPKind;
2174 if (pachPacket[0] == nSize-1)
2175 byChaIPKind = 0;
2176 else if (pachPacket[0] == nSize-2 && (m_bySupportSecIdent & 2) > 0) //v2
2177 byChaIPKind = pachPacket[nSize-1];
2178 else{
2179 wxFAIL;
2180 return;
2181 }
2182
2183 if (!theApp->CryptoAvailable())
2184 return;
2185
2186 // we accept only one signature per IP, to avoid floods which need a lot cpu time for cryptfunctions
2187 if (m_dwLastSignatureIP == GetIP()){
2188 AddDebugLogLineN( logClient, wxT("received multiple signatures from one client") );
2189 return;
2190 }
2191 // also make sure this client has a public key
2192 if (credits->GetSecIDKeyLen() == 0){
2193 AddDebugLogLineN( logClient, wxT("received signature for client without public key") );
2194 return;
2195 }
2196 // and one more check: did we ask for a signature and sent a challange packet?
2197 if (credits->m_dwCryptRndChallengeFor == 0){
2198 AddDebugLogLineN( logClient, wxT("received signature for client with invalid challenge value - User ") + GetUserName() );
2199 return;
2200 }
2201
2202 // cppcheck-suppress duplicateBranch
2203 if (theApp->clientcredits->VerifyIdent(credits, pachPacket+1, pachPacket[0], GetIP(), byChaIPKind ) ) {
2204 // result is saved in function above
2205 AddDebugLogLineN( logClient, CFormat( wxT("'%s' has passed the secure identification, V2 State: %i") ) % GetUserName() % byChaIPKind );
2206 } else {
2207 AddDebugLogLineN( logClient, CFormat( wxT("'%s' has failed the secure identification, V2 State: %i") ) % GetUserName() % byChaIPKind );
2208 }
2209
2210 m_dwLastSignatureIP = GetIP();
2211 }
2212
2213 void CUpDownClient::SendSecIdentStatePacket(){
2214 // check if we need public key and signature
2215 if (credits){
2216 uint8 nValue = 0;
2217 if (theApp->CryptoAvailable()){
2218 if (credits->GetSecIDKeyLen() == 0) {
2219 nValue = IS_KEYANDSIGNEEDED;
2220 } else if (m_dwLastSignatureIP != GetIP()) {
2221 nValue = IS_SIGNATURENEEDED;
2222 }
2223 }
2224 if (nValue == 0){
2225 AddDebugLogLineN( logClient, wxT("Not sending SecIdentState Packet, because State is Zero") );
2226 return;
2227 }
2228 // crypt: send random data to sign
2229 uint32 dwRandom = rand()+1;
2230 credits->m_dwCryptRndChallengeFor = dwRandom;
2231
2232 CMemFile data;
2233 data.WriteUInt8(nValue);
2234 data.WriteUInt32(dwRandom);
2235 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_SECIDENTSTATE);
2236
2237 theStats::AddUpOverheadOther(packet->GetPacketSize());
2238 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_SECIDENTSTATE to ") + GetFullIP() );
2239 SendPacket(packet,true,true);
2240 } else {
2241 wxFAIL;
2242 }
2243 }
2244
2245
2246 void CUpDownClient::ProcessSecIdentStatePacket(const byte* pachPacket, uint32 nSize)
2247 {
2248 if ( nSize != 5 ) {
2249 return;
2250 }
2251
2252 if ( !credits ) {
2253 wxASSERT( credits );
2254 return;
2255 }
2256
2257 CMemFile data(pachPacket,nSize);
2258
2259 switch ( data.ReadUInt8() ) {
2260 case 0:
2261 m_SecureIdentState = IS_UNAVAILABLE;
2262 break;
2263 case 1:
2264 m_SecureIdentState = IS_SIGNATURENEEDED;
2265 break;
2266 case 2:
2267 m_SecureIdentState = IS_KEYANDSIGNEEDED;
2268 break;
2269 default:
2270 return;
2271 }
2272
2273 credits->m_dwCryptRndChallengeFrom = data.ReadUInt32();
2274 }
2275
2276
2277 void CUpDownClient::InfoPacketsReceived()
2278 {
2279 // indicates that both Information Packets has been received
2280 // needed for actions, which process data from both packets
2281 wxASSERT ( m_byInfopacketsReceived == IP_BOTH );
2282 m_byInfopacketsReceived = IP_NONE;
2283
2284 if (m_bySupportSecIdent){
2285 SendSecIdentStatePacket();
2286 }
2287 }
2288
2289
2290 bool CUpDownClient::CheckHandshakeFinished() const
2291 {
2292 if (m_bHelloAnswerPending) {
2293 // this triggers way too often.. need more time to look at this -> only create a warning
2294 // The reason for this is that 2 clients are connecting to each other at the same time..
2295 AddDebugLogLineN( logClient, wxT("Handshake not finished while processing packet.") );
2296 return false;
2297 }
2298
2299 return true;
2300 }
2301
2302
2303 #ifdef __DEBUG__
2304 wxString CUpDownClient::GetClientFullInfo()
2305 {
2306 if (m_clientVerString.IsEmpty()) {
2307 ReGetClientSoft();
2308 }
2309
2310 return CFormat( wxT("Client %s on IP:Port %s:%d using %s %s %s") )
2311 % ( m_Username.IsEmpty() ? wxString(_("Unknown")) : m_Username )
2312 % GetFullIP()
2313 % GetUserPort()
2314 % m_clientSoftString
2315 % m_clientVerString
2316 % m_strModVersion;
2317 }
2318 #endif
2319
2320 wxString CUpDownClient::GetClientShortInfo()
2321 {
2322 if (m_clientVerString.IsEmpty()) {
2323 ReGetClientSoft();
2324 }
2325
2326 return CFormat( wxT("'%s' (%s %s %s)") )
2327 % ( m_Username.IsEmpty() ? wxString(_("Unknown")) : m_Username )
2328 % m_clientSoftString
2329 % m_clientVerString
2330 % m_strModVersion;
2331 }
2332
2333
2334 void CUpDownClient::SendPublicIPRequest()
2335 {
2336 if (IsConnected()){
2337 CPacket* packet = new CPacket(OP_PUBLICIP_REQ,0,OP_EMULEPROT);
2338 theStats::AddUpOverheadOther(packet->GetPacketSize());
2339 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_PUBLICIP_REQ to ") + GetFullIP());
2340 SendPacket(packet,true);
2341 m_fNeedOurPublicIP = true;
2342 }
2343 }
2344
2345 void CUpDownClient::ProcessPublicIPAnswer(const byte* pbyData, uint32 uSize)
2346 {
2347 if (uSize != 4) {
2348 throw wxString(wxT("Wrong Packet size on Public IP answer"));
2349 }
2350 uint32 dwIP = PeekUInt32(pbyData);
2351 if (m_fNeedOurPublicIP == true){ // did we?
2352 m_fNeedOurPublicIP = false;
2353 // Ignore local ip on GetPublicIP (could be wrong)
2354 if (theApp->GetPublicIP(true) == 0 && !IsLowID(dwIP) ) {
2355 theApp->SetPublicIP(dwIP);
2356 }
2357 }
2358 }
2359
2360
2361 bool CUpDownClient::IsConnected() const
2362 {
2363 return m_socket && m_socket->IsConnected();
2364 }
2365
2366 bool CUpDownClient::SendPacket(CPacket* packet, bool delpacket, bool controlpacket)
2367 {
2368 if ( m_socket ) {
2369 m_socket->SendPacket(packet, delpacket, controlpacket );
2370 return true;
2371 } else {
2372 AddLogLineN(wxT("CAUGHT DEAD SOCKET IN SENDPACKET()"));
2373 return false;
2374 }
2375 }
2376
2377 float CUpDownClient::SetDownloadLimit(uint32 reducedownload)
2378 {
2379 // lfroen: in daemon it actually can happen
2380 wxASSERT( m_socket );
2381
2382 float kBpsClient = CalculateKBpsDown();
2383
2384 if ( m_socket ) {
2385
2386 if (reducedownload) {
2387 // (% to reduce * current speed) / 100 and THEN, / (1000 / CORE_TIMER_PERIOD)
2388 // which is how often it is called per second.
2389 uint32 limit = (uint32)(reducedownload * kBpsClient * 1024.0 / 100000.0 * CORE_TIMER_PERIOD);
2390
2391 if(limit<1024 && reducedownload >= 200) {
2392 // If we're going up and this download is < 1kB,
2393 // we want it to go up fast. Can be reduced later,
2394 // and it'll probably be in a more fair way with
2395 // other downloads that are faster.
2396 limit +=1024;
2397 } else if(limit == 0) {
2398 // This download is not transferring yet... make it
2399 // 1024 so we don't fill the TCP stack and lose the
2400 // connection.
2401 limit = 1024;
2402 }
2403
2404 m_socket->SetDownloadLimit(limit);
2405 } else {
2406 m_socket->DisableDownloadLimit();
2407 }
2408
2409 } else {
2410 AddLogLineNS(CFormat(wxT("CAUGHT DEAD SOCKET IN SETDOWNLOADLIMIT() WITH SPEED %f")) % kBpsClient);
2411 }
2412
2413 return kBpsClient;
2414 }
2415
2416 void CUpDownClient::SetUserIDHybrid(uint32 nUserID)
2417 {
2418 theApp->clientlist->UpdateClientID( this, nUserID );
2419
2420 m_nUserIDHybrid = nUserID;
2421 }
2422
2423
2424 void CUpDownClient::SetIP( uint32 val )
2425 {
2426 theApp->clientlist->UpdateClientIP( this, val );
2427
2428 m_dwUserIP = val;
2429
2430 m_nConnectIP = val;
2431
2432 m_FullUserIP = val;
2433 }
2434
2435
2436 void CUpDownClient::SetUserHash(const CMD4Hash& userhash)
2437 {
2438 theApp->clientlist->UpdateClientHash( this, userhash );
2439
2440 m_UserHash = userhash;
2441
2442 ValidateHash();
2443 }
2444
2445 EUtf8Str CUpDownClient::GetUnicodeSupport() const
2446 {
2447 return m_bUnicodeSupport ? utf8strRaw : utf8strNone;
2448 }
2449
2450 void CUpDownClient::SetSpammer(bool bVal)
2451 {
2452 if (bVal) {
2453 Ban();
2454 } else if (IsBanned() && m_fIsSpammer) {
2455 UnBan();
2456 }
2457 m_fIsSpammer = bVal;
2458 }
2459
2460 uint8 CUpDownClient::GetSecureIdentState()
2461 {
2462 if (m_SecureIdentState != IS_UNAVAILABLE) {
2463 if (!SecIdentSupRec) {
2464 // This can be caused by a 0.30x based client which sends the old
2465 // style Hello packet, and the mule info packet, but between them they
2466 // send a secure ident state packet (after a hello but before we have
2467 // the SUI capabilities). This is a misbehaving client, and somehow I
2468 // feel like it should be dropped. But then again, it won't harm to use
2469 // this SUI state if they are reporting no SUI (won't be used) and if
2470 // they report using SUI on the mule info packet, it's ok to use it.
2471
2472 AddDebugLogLineN(logClient, wxT("A client sent secure ident state before telling us the SUI capabilities"));
2473 AddDebugLogLineN(logClient, wxT("Client info: ") + GetClientFullInfo());
2474 AddDebugLogLineN(logClient, wxT("This client won't be disconnected, but it should be. :P"));
2475 }
2476 }
2477
2478 return m_SecureIdentState;
2479 }
2480
2481
2482 bool CUpDownClient::SendChatMessage(const wxString& message)
2483 {
2484 if (GetChatCaptchaState() == CA_CAPTCHARECV) {
2485 m_nChatCaptchaState = CA_SOLUTIONSENT;
2486 } else if (GetChatCaptchaState() == CA_SOLUTIONSENT) {
2487 wxFAIL; // we responsed to a captcha but didn't heard from the client afterwards - hopefully its just lag and this message will get through
2488 } else {
2489 m_nChatCaptchaState = CA_ACCEPTING;
2490 }
2491
2492 SetSpammer(false);
2493 IncMessagesSent();
2494 // Already connecting?
2495 if (GetChatState() == MS_CONNECTING) {
2496 // Queue all messages till we're able to send them (or discard them)
2497 if (!m_pendingMessage.IsEmpty()) {
2498 m_pendingMessage += wxT("\n");
2499 } else {
2500 // There must be a message to send
2501 // - except if we got disconnected. No need to assert therefore.
2502 }
2503 m_pendingMessage += message;
2504 return false;
2505 }
2506 if (IsConnected()) {
2507 // If we are already connected when we send the first message,
2508 // we have to update the chat status.
2509 SetChatState(MS_CHATTING);
2510 CMemFile data;
2511 data.WriteString(message, GetUnicodeSupport());
2512 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_MESSAGE);
2513 theStats::AddUpOverheadOther(packet->GetPacketSize());
2514 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_MESSAGE to ") + GetFullIP());
2515 SendPacket(packet, true, true);
2516 return true;
2517 } else {
2518 m_pendingMessage = message;
2519 SetChatState(MS_CONNECTING);
2520 // True to ignore "Too Many Connections"
2521 TryToConnect(true);
2522 return false;
2523 }
2524 }
2525
2526 /* Kad stuff */
2527
2528 void CUpDownClient::SetBuddyID(const byte* pucBuddyID)
2529 {
2530 if( pucBuddyID == NULL ){
2531 md4clr(m_achBuddyID);
2532 m_bBuddyIDValid = false;
2533 return;
2534 }
2535 m_bBuddyIDValid = true;
2536 md4cpy(m_achBuddyID, pucBuddyID);
2537 }
2538
2539 // Kad added by me
2540
2541 bool CUpDownClient::SendBuddyPing() {
2542 SetLastBuddyPingPongTime();
2543 CPacket* buddyPing = new CPacket(OP_BUDDYPING, 0, OP_EMULEPROT);
2544 theStats::AddUpOverheadKad(buddyPing->GetPacketSize());
2545 AddDebugLogLineN(logLocalClient,wxT("Local Client: OP_BUDDYPING to ") + GetFullIP());
2546 return SafeSendPacket(buddyPing);
2547 }
2548
2549
2550 /* Statistics */
2551
2552 void CUpDownClient::UpdateStats()
2553 {
2554 if (m_lastClientSoft != m_clientSoft || m_lastClientVersion != m_nClientVersion || m_lastOSInfo != m_sClientOSInfo) {
2555 if (m_lastClientSoft == SO_UNKNOWN) {
2556 theStats::RemoveUnknownClient();
2557 } else if (m_lastClientSoft != (uint32)(-1)) {
2558 theStats::RemoveKnownClient(m_lastClientSoft, m_lastClientVersion, m_lastOSInfo);
2559 }
2560
2561 m_lastClientSoft = m_clientSoft;
2562 m_lastClientVersion = m_nClientVersion;
2563 m_lastOSInfo = m_sClientOSInfo;
2564
2565 if (m_clientSoft == SO_UNKNOWN) {
2566 theStats::AddUnknownClient();
2567 } else {
2568 theStats::AddKnownClient(this);
2569 }
2570 }
2571 }
2572
2573 bool CUpDownClient::IsIdentified() const
2574 {
2575 return (credits && credits->GetCurrentIdentState(GetIP()) == IS_IDENTIFIED);
2576 }
2577
2578 bool CUpDownClient::IsBadGuy() const
2579 {
2580 return (credits && credits->GetCurrentIdentState(GetIP()) == IS_IDBADGUY);
2581 }
2582
2583 bool CUpDownClient::SUIFailed() const
2584 {
2585 return (credits && credits->GetCurrentIdentState(GetIP()) == IS_IDFAILED);
2586 }
2587
2588 bool CUpDownClient::SUINeeded() const
2589 {
2590 return (credits && credits->GetCurrentIdentState(GetIP()) == IS_IDNEEDED);
2591 }
2592
2593 bool CUpDownClient::SUINotSupported() const
2594 {
2595 return (credits && credits->GetCurrentIdentState(GetIP()) == IS_NOTAVAILABLE);
2596 }
2597
2598 uint64 CUpDownClient::GetDownloadedTotal() const
2599 {
2600 return credits ? credits->GetDownloadedTotal() : 0;
2601 }
2602
2603 uint64 CUpDownClient::GetUploadedTotal() const
2604 {
2605 return credits ? credits->GetUploadedTotal() : 0;
2606 }
2607
2608 double CUpDownClient::GetScoreRatio() const
2609 {
2610 return credits ? credits->GetScoreRatio(GetIP(), theApp->CryptoAvailable()) : 0;
2611 }
2612
2613 const wxString CUpDownClient::GetServerName() const
2614 {
2615 wxString ret;
2616 wxString srvaddr = Uint32toStringIP(GetServerIP());
2617 CServer* cserver = theApp->serverlist->GetServerByAddress(
2618 srvaddr, GetServerPort());
2619 if (cserver) {
2620 ret = cserver->GetListName();
2621 } else {
2622 ret = _("Unknown");
2623 }
2624
2625 return ret;
2626 }
2627
2628 bool CUpDownClient::ShouldReceiveCryptUDPPackets() const
2629 {
2630 return (thePrefs::IsClientCryptLayerSupported() && SupportsCryptLayer() && theApp->GetPublicIP() != 0
2631 && HasValidHash() && (thePrefs::IsClientCryptLayerRequested() || RequestsCryptLayer()) );
2632 }
2633
2634 #ifdef AMULE_DAEMON
2635
2636 void CUpDownClient::ProcessCaptchaRequest(CMemFile* WXUNUSED(data)) {}
2637 void CUpDownClient::ProcessCaptchaReqRes(uint8 WXUNUSED(nStatus)) {}
2638 void CUpDownClient::ProcessChatMessage(const wxString WXUNUSED(message)) {}
2639
2640 #else
2641
2642 void CUpDownClient::ProcessCaptchaRequest(CMemFile* data)
2643 {
2644 uint64 id = GUI_ID(GetIP(),GetUserPort());
2645 // received a captcha request, check if we actually accept it (only after sending a message ourself to this client)
2646 if (GetChatCaptchaState() == CA_ACCEPTING && GetChatState() != MS_NONE
2647 && theApp->amuledlg->m_chatwnd->IsIdValid(id)) {
2648 // read tags (for future use)
2649 uint8 nTagCount = data->ReadUInt8();
2650 if (nTagCount) {
2651 AddDebugLogLineN(logClient, CFormat(wxT("Received captcha request from client (%s) with (%u) tags")) % GetFullIP() % nTagCount);
2652 // and ignore them for now
2653 for (uint32 i = 0; i < nTagCount; i++) {
2654 CTag tag(*data, true);
2655 }
2656 }
2657
2658 // sanitize checks - we want a small captcha not a wallpaper
2659 uint32 nSize = (uint32)(data->GetLength() - data->GetPosition());
2660
2661 if ( nSize > 128 && nSize < 4096 ) {
2662 uint64 pos = data->GetPosition();
2663 wxMemoryInputStream memstr(data->GetRawBuffer() + pos, nSize);
2664 wxImage imgCaptcha(memstr, wxBITMAP_TYPE_BMP);
2665
2666 if (imgCaptcha.IsOk() && imgCaptcha.GetHeight() > 10 && imgCaptcha.GetHeight() < 50
2667 && imgCaptcha.GetWidth() > 10 && imgCaptcha.GetWidth() < 150 ) {
2668 m_nChatCaptchaState = CA_CAPTCHARECV;
2669 CCaptchaDialog * dialog = new CCaptchaDialog(theApp->amuledlg, imgCaptcha, id);
2670 dialog->Show();
2671
2672 } else {
2673 AddDebugLogLineN(logClient, CFormat(wxT("Received captcha request from client, processing image failed or invalid pixel size (%s)")) % GetFullIP());
2674 }
2675 } else {
2676 AddDebugLogLineN(logClient, CFormat(wxT("Received captcha request from client, size sanitize check failed (%u) (%s)")) % nSize % GetFullIP());
2677 }
2678 } else {
2679 AddDebugLogLineN(logClient, CFormat(wxT("Received captcha request from client, but don't accepting it at this time (%s)")) % GetFullIP());
2680 }
2681 }
2682
2683 void CUpDownClient::ProcessCaptchaReqRes(uint8 nStatus)
2684 {
2685 uint64 id = GUI_ID(GetIP(),GetUserPort());
2686 if (GetChatCaptchaState() == CA_SOLUTIONSENT && GetChatState() != MS_NONE
2687 && theApp->amuledlg->m_chatwnd->IsIdValid(id)) {
2688 wxASSERT( nStatus < 3 );
2689 m_nChatCaptchaState = CA_NONE;
2690 theApp->amuledlg->m_chatwnd->ShowCaptchaResult(id, nStatus == 0);
2691 } else {
2692 m_nChatCaptchaState = CA_NONE;
2693 AddDebugLogLineN(logClient, CFormat(wxT("Received captcha result from client, but not accepting it at this time (%s)")) % GetFullIP());
2694 }
2695 }
2696
2697 void CUpDownClient::ProcessChatMessage(wxString message)
2698 {
2699 if (IsMessageFiltered(message)) {
2700 AddLogLineC(CFormat(_("Message filtered from '%s' (IP:%s)")) % GetUserName() % GetFullIP());
2701 return;
2702 }
2703
2704 // advanced spamfilter check
2705 if (thePrefs::IsChatCaptchaEnabled() && !IsFriend()) {
2706 // captcha checks outrank any further checks - if the captcha has been solved, we assume it's not spam
2707 // first check if we need to send a captcha request to this client
2708 if (GetMessagesSent() == 0 && GetMessagesReceived() == 0 && GetChatCaptchaState() != CA_CAPTCHASOLVED) {
2709 // we have never sent a message to this client, and no message from him has ever passed our filters
2710 if (GetChatCaptchaState() != CA_CHALLENGESENT) {
2711 // we also aren't currently expecting a captcha response
2712 if (m_fSupportsCaptcha) {
2713 // and he supports captcha, so send him one and store the message (without showing for now)
2714 if (m_cCaptchasSent < 3) { // no more than 3 tries
2715 m_strCaptchaPendingMsg = message;
2716 wxMemoryOutputStream memstr;
2717 memstr.PutC(0); // no tags, for future use
2718 CCaptchaGenerator captcha(4);
2719 if (captcha.WriteCaptchaImage(memstr)){
2720 m_strCaptchaChallenge = captcha.GetCaptchaText();
2721 m_nChatCaptchaState = CA_CHALLENGESENT;
2722 m_cCaptchasSent++;
2723 CMemFile fileAnswer((byte*) memstr.GetOutputStreamBuffer()->GetBufferStart(), memstr.GetLength());
2724 CPacket* packet = new CPacket(fileAnswer, OP_EMULEPROT, OP_CHATCAPTCHAREQ);
2725 theStats::AddUpOverheadOther(packet->GetPacketSize());
2726 AddLogLineN(CFormat(wxT("sent Captcha %s (%d)")) % m_strCaptchaChallenge % packet->GetPacketSize());
2727 SafeSendPacket(packet);
2728 } else {
2729 wxFAIL;
2730 }
2731 }
2732 } else {
2733 // client doesn't support captchas, but we require them, tell him that it's not going to work out
2734 // with an answer message (will not be shown and doesn't count as sent message)
2735 if (m_cCaptchasSent < 1) { // don't send this notifier more than once
2736 m_cCaptchasSent++;
2737 // always sent in english
2738 SendChatMessage(wxT("In order to avoid spam messages, this user requires you to solve a captcha before you can send a message to him. However your client does not supports captchas, so you will not be able to chat with this user."));
2739 AddDebugLogLineN(logClient, CFormat(wxT("Received message from client not supporting captchas, filtered and sent notifier (%s)")) % GetClientFullInfo());
2740 } else {
2741 AddDebugLogLineN(logClient, CFormat(wxT("Received message from client not supporting captchas, filtered, didn't send notifier (%s)")) % GetClientFullInfo());
2742 }
2743 }
2744 return;
2745 } else { // (GetChatCaptchaState() == CA_CHALLENGESENT)
2746 // this message must be the answer to the captcha request we sent him, let's verify
2747 wxASSERT( !m_strCaptchaChallenge.IsEmpty() );
2748 if (m_strCaptchaChallenge.CmpNoCase(message.Trim().Right(std::min(message.Length(), m_strCaptchaChallenge.Length()))) == 0) {
2749 // allright
2750 AddDebugLogLineN(logClient, CFormat(wxT("Captcha solved, showing withheld message (%s)")) % GetClientFullInfo());
2751 m_nChatCaptchaState = CA_CAPTCHASOLVED; // this state isn't persitent, but the messagecounter will be used to determine later if the captcha has been solved
2752 // replace captchaanswer with withheld message and show it
2753 message = m_strCaptchaPendingMsg;
2754 m_cCaptchasSent = 0;
2755 m_strCaptchaChallenge.Clear();
2756 CPacket* packet = new CPacket(OP_CHATCAPTCHARES, 1, OP_EMULEPROT, false);
2757 byte statusResponse = 0; // status response
2758 packet->CopyToDataBuffer(0, &statusResponse, 1);
2759 theStats::AddUpOverheadOther(packet->GetPacketSize());
2760 SafeSendPacket(packet);
2761 } else { // wrong, cleanup and ignore
2762 AddDebugLogLineN(logClient, CFormat(wxT("Captcha answer failed (%s)")) % GetClientFullInfo());
2763 m_nChatCaptchaState = CA_NONE;
2764 m_strCaptchaChallenge.Clear();
2765 m_strCaptchaPendingMsg.Clear();
2766 CPacket* packet = new CPacket(OP_CHATCAPTCHARES, 1, OP_EMULEPROT, false);
2767 byte statusResponse = (m_cCaptchasSent < 3) ? 1 : 2; // status response
2768 packet->CopyToDataBuffer(0, &statusResponse, 1);
2769 theStats::AddUpOverheadOther(packet->GetPacketSize());
2770 SafeSendPacket(packet);
2771 return; // nothing more todo
2772 }
2773 }
2774 }
2775 }
2776
2777 if (thePrefs::IsAdvancedSpamfilterEnabled() && !IsFriend()) { // friends are never spammer... (but what if two spammers are friends :P )
2778 bool bIsSpam = false;
2779 if (m_fIsSpammer) {
2780 bIsSpam = true;
2781 } else {
2782 // first fixed criteria: If a client sends me an URL in his first message before I respond to him
2783 // there is a 99,9% chance that it is some poor guy advising his leech mod, or selling you .. well you know :P
2784 if (GetMessagesSent() == 0) {
2785 static wxArrayString urlindicators(wxStringTokenize(wxT("http:|www.|.de |.net |.com |.org |.to |.tk |.cc |.fr |ftp:|ed2k:|https:|ftp.|.info|.biz|.uk|.eu|.es|.tv|.cn|.tw|.ws|.nu|.jp"), wxT("|")));
2786 for (size_t pos = urlindicators.GetCount(); pos--;) {
2787 if (message.Find(urlindicators[pos]) != wxNOT_FOUND) {
2788 bIsSpam = true;
2789 break;
2790 }
2791 }
2792 // second fixed criteria: he sent me 4 or more messages and I didn't answer him once
2793 if (GetMessagesReceived() > 3) {
2794 bIsSpam = true;
2795 }
2796 }
2797 }
2798 if (bIsSpam) {
2799 AddDebugLogLineN(logClient, CFormat(wxT("'%s' has been marked as spammer")) % GetUserName());
2800 SetSpammer(true);
2801 theApp->amuledlg->m_chatwnd->EndSession(GUI_ID(GetIP(),GetUserPort()));
2802 return;
2803 }
2804 }
2805
2806
2807 wxString logMsg = CFormat(_("New message from '%s' (IP:%s)")) % GetUserName() % GetFullIP();
2808 if(thePrefs::ShowMessagesInLog()) {
2809 logMsg += wxT(": ") + message;
2810 }
2811 AddLogLineC(logMsg);
2812 IncMessagesReceived();
2813
2814 Notify_ChatProcessMsg(GUI_ID(GetIP(), GetUserPort()), GetUserName() + wxT("|") + message);
2815 }
2816
2817 bool CUpDownClient::IsMessageFiltered(const wxString& message)
2818 {
2819 bool filtered = false;
2820 // If we're chatting to the guy, we don't want to filter!
2821 if (GetChatState() != MS_CHATTING) {
2822 if (thePrefs::MsgOnlyFriends() && !IsFriend()) {
2823 filtered = true;
2824 } else if (thePrefs::MsgOnlySecure() && GetUserName().IsEmpty() ) {
2825 filtered = true;
2826 } else if (thePrefs::MustFilterMessages()) {
2827 filtered = thePrefs::IsMessageFiltered(message);
2828 }
2829 }
2830 if (filtered) {
2831 SetSpammer(true);
2832 }
2833 return filtered;
2834 }
2835
2836 #endif
2837
2838 void CUpDownClient::SendSharedDirectories()
2839 {
2840 // This list will contain all (unique) folders.
2841 PathList foldersToSend;
2842
2843 // The shared folders
2844 const unsigned folderCount = theApp->glob_prefs->shareddir_list.size();
2845 for (unsigned i = 0; i < folderCount; ++i) {
2846 foldersToSend.push_back(theApp->glob_prefs->shareddir_list[i]);
2847 }
2848
2849 // ... the categories folders ... (category 0 -> incoming)
2850 for (unsigned i = 0; i < theApp->glob_prefs->GetCatCount(); ++i) {
2851 foldersToSend.push_back(theApp->glob_prefs->GetCategory(i)->path);
2852 }
2853
2854 // Strip duplicates
2855 foldersToSend.sort();
2856 foldersToSend.unique();
2857
2858 // Build packet
2859 CMemFile tempfile(80);
2860 tempfile.WriteUInt32(foldersToSend.size() + 1); // + 1 for the incomplete files
2861
2862 PathList::iterator it = foldersToSend.begin();
2863 for (; it != foldersToSend.end(); ++it) {
2864 // Note: the public shared name contains the 'raw' path, so we can recognize it again.
2865 // the 'raw' path is determined using CPath::GetRaw()
2866 tempfile.WriteString( theApp->sharedfiles->GetPublicSharedDirName(*it), GetUnicodeSupport() );
2867 }
2868
2869 // ... and the Magic thing from the eDonkey Hybrids...
2870 tempfile.WriteString(OP_INCOMPLETE_SHARED_FILES, GetUnicodeSupport());
2871
2872 // Send the packet.
2873 CPacket* replypacket = new CPacket(tempfile, OP_EDONKEYPROT, OP_ASKSHAREDDIRSANS);
2874 theStats::AddUpOverheadOther(replypacket->GetPacketSize());
2875 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ASKSHAREDDIRSANS to ") + GetFullIP() );
2876 SendPacket(replypacket, true, true);
2877 }
2878
2879 void CUpDownClient::SendSharedFilesOfDirectory(const wxString& strReqDir)
2880 {
2881 CKnownFilePtrList list;
2882
2883 if (strReqDir == OP_INCOMPLETE_SHARED_FILES) {
2884 // get all shared files from download queue
2885 int iQueuedFiles = theApp->downloadqueue->GetFileCount();
2886 for (int i = 0; i < iQueuedFiles; i++) {
2887 CPartFile* pFile = theApp->downloadqueue->GetFileByIndex(i);
2888 if (pFile == NULL || pFile->GetStatus(true) != PS_READY) {
2889 continue;
2890 }
2891 list.push_back(pFile);
2892 }
2893 } else {
2894 // get all shared files for the requested directory
2895 const CPath *sharedDir = theApp->sharedfiles->GetDirForPublicSharedDirName(strReqDir);
2896 if (sharedDir) {
2897 theApp->sharedfiles->GetSharedFilesByDirectory(sharedDir->GetRaw(), list);
2898 } else {
2899 AddLogLineC(CFormat(_("User %s (%u) requested sharedfiles-list for not existing directory '%s' -> Ignored")) % GetUserName() % GetUserIDHybrid() % strReqDir);
2900 }
2901 }
2902
2903 CMemFile tempfile(80);
2904 tempfile.WriteString(strReqDir, GetUnicodeSupport());
2905 tempfile.WriteUInt32(list.size());
2906
2907 while (!list.empty()) {
2908 if (!list.front()->IsLargeFile() || SupportsLargeFiles()) {
2909 list.front()->CreateOfferedFilePacket(&tempfile, NULL, this);
2910 }
2911 list.pop_front();
2912 }
2913
2914 CPacket* replypacket = new CPacket(tempfile, OP_EDONKEYPROT, OP_ASKSHAREDFILESDIRANS);
2915 theStats::AddUpOverheadOther(replypacket->GetPacketSize());
2916 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ASKSHAREDFILESDIRANS to ") + GetFullIP() );
2917 SendPacket(replypacket, true, true);
2918 }
2919
2920 void CUpDownClient::SendFirewallCheckUDPRequest()
2921 {
2922 wxASSERT(GetKadState() == KS_FWCHECK_UDP);
2923
2924 if (!Kademlia::CKademlia::IsRunning()) {
2925 SetKadState(KS_NONE);
2926 return;
2927 } else if (GetUploadState() != US_NONE || GetDownloadState() != DS_NONE || GetChatState() != MS_NONE || GetKadVersion() <= 5 || GetKadPort() == 0) {
2928 Kademlia::CUDPFirewallTester::SetUDPFWCheckResult(false, true, wxUINT32_SWAP_ALWAYS(GetIP()), 0); // inform the tester that this test was cancelled
2929 SetKadState(KS_NONE);
2930 return;
2931 }
2932
2933 CMemFile data;
2934 data.WriteUInt16(Kademlia::CKademlia::GetPrefs()->GetInternKadPort());
2935 data.WriteUInt16(Kademlia::CKademlia::GetPrefs()->GetExternalKadPort());
2936 data.WriteUInt32(Kademlia::CKademlia::GetPrefs()->GetUDPVerifyKey(GetConnectIP()));
2937 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_FWCHECKUDPREQ);
2938 theStats::AddUpOverheadKad(packet->GetPacketSize());
2939 SafeSendPacket(packet);
2940 }
2941
2942 void CUpDownClient::ProcessFirewallCheckUDPRequest(CMemFile* data)
2943 {
2944 if (!Kademlia::CKademlia::IsRunning() || Kademlia::CKademlia::GetUDPListener() == NULL) {
2945 //DebugLogWarning(_T("Ignored Kad Firewallrequest UDP because Kad is not running (%s)"), GetClientFullInfo());
2946 return;
2947 }
2948
2949 // first search if we know this IP already, if so the result might be biased and we need tell the requester
2950 bool errorAlreadyKnown = false;
2951 if (GetUploadState() != US_NONE || GetDownloadState() != DS_NONE || GetChatState() != MS_NONE) {
2952 errorAlreadyKnown = true;
2953 } else if (Kademlia::CKademlia::GetRoutingZone()->GetContact(wxUINT32_SWAP_ALWAYS(GetConnectIP()), 0, false) != NULL) {
2954 errorAlreadyKnown = true;
2955 }
2956
2957 uint16_t remoteInternPort = data->ReadUInt16();
2958 uint16_t remoteExternPort = data->ReadUInt16();
2959 uint32_t senderKey = data->ReadUInt32();
2960 if (remoteInternPort == 0) {
2961 //DebugLogError(_T("UDP Firewallcheck requested with Intern Port == 0 (%s)"), GetClientFullInfo());
2962 return;
2963 }
2964 // if (senderKey == 0)
2965 // DebugLogWarning(_T("UDP Firewallcheck requested with SenderKey == 0 (%s)"), GetClientFullInfo());
2966
2967 CMemFile testPacket1;
2968 testPacket1.WriteUInt8(errorAlreadyKnown ? 1 : 0);
2969 testPacket1.WriteUInt16(remoteInternPort);
2970 DebugSend(Kad2FirewallUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteInternPort);
2971 Kademlia::CKademlia::GetUDPListener()->SendPacket(testPacket1, KADEMLIA2_FIREWALLUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteInternPort, Kademlia::CKadUDPKey(senderKey, theApp->GetPublicIP(false)), NULL);
2972
2973 // if the client has a router with PAT (and therefore a different extern port than intern), test this port too
2974 if (remoteExternPort != 0 && remoteExternPort != remoteInternPort) {
2975 CMemFile testPacket2;
2976 testPacket2.WriteUInt8(errorAlreadyKnown ? 1 : 0);
2977 testPacket2.WriteUInt16(remoteExternPort);
2978 DebugSend(Kad2FirewalledUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteExternPort);
2979 Kademlia::CKademlia::GetUDPListener()->SendPacket(testPacket2, KADEMLIA2_FIREWALLUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteExternPort, Kademlia::CKadUDPKey(senderKey, theApp->GetPublicIP(false)), NULL);
2980 }
2981 //DebugLog(_T("Answered UDP Firewallcheck request (%s)"), GetClientFullInfo());
2982 }
2983
2984 void CUpDownClient::SetConnectOptions(uint8_t options, bool encryption, bool callback)
2985 {
2986 SetCryptLayerSupport((options & 0x01) != 0 && encryption);
2987 SetCryptLayerRequest((options & 0x02) != 0 && encryption);
2988 SetCryptLayerRequires((options & 0x04) != 0 && encryption);
2989 SetDirectUDPCallbackSupport((options & 0x08) != 0 && callback);
2990 }
2991
2992
2993 #ifdef DEBUG_ZOMBIE_CLIENTS
2994 void CUpDownClient::Unlink(const wxString& from)
2995 {
2996 std::multiset<wxString>::iterator it = m_linkedFrom.find(from);
2997 if (it != m_linkedFrom.end()) {
2998 m_linkedFrom.erase(it);
2999 }
3000 m_linked--;
3001 if (!m_linked) {
3002 if (m_linkedDebug) {
3003 AddLogLineN(CFormat(wxT("Last reference to client %d %p unlinked, delete it.")) % ECID() % this);
3004 }
3005 delete this;
3006 }
3007 }
3008
3009 #else
3010
3011 void CUpDownClient::Unlink()
3012 {
3013 m_linked--;
3014 if (!m_linked) {
3015 delete this;
3016 }
3017 }
3018 #endif
3019
3020
3021 // File_checked_for_headers
aMule P2P client