?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve speed of category tab title updates
[amule.git] / src / BaseClient.cpp
blob686f547cbd42bc919ac1d2921d3fecb764fa3fda
1 //
2 // This file is part of the aMule Project.
3 //
4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
5 // Copyright (c) 2002-2008 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
32 #include <protocol/Protocols.h>
33 #include <protocol/ed2k/Client2Client/TCP.h>
34 #include <protocol/ed2k/ClientSoftware.h>
35 #include <protocol/kad/Client2Client/UDP.h>
36 #include <protocol/kad2/Constants.h>
37 #include <protocol/kad2/Client2Client/TCP.h>
38 #include <protocol/kad2/Client2Client/UDP.h>
39
40 #include <common/ClientVersion.h>
41
42 #include <tags/ClientTags.h>
43
44 #include <zlib.h> // Needed for inflateEnd
45
46 #include <common/Format.h> // Needed for CFormat
47
48 #include "SearchList.h" // Needed for CSearchList
49 #include "DownloadQueue.h" // Needed for CDownloadQueue
50 #include "UploadQueue.h" // Needed for CUploadQueue
51 #include "IPFilter.h" // Needed for CIPFilter
52 #include "ServerConnect.h" // Needed for CServerConnect
53 #include "ClientCredits.h" // Needed for CClientCredits
54 #include "ClientCreditsList.h" // Needed for CClientCreditsList
55 #include "Server.h" // Needed for CServer
56 #include "Preferences.h" // Needed for CPreferences
57 #include "MemFile.h" // Needed for CMemFile
58 #include "Packet.h" // Needed for CPacket
59 #include "Friend.h" // Needed for CFriend
60 #include "ClientList.h" // Needed for CClientList
61 #ifndef AMULE_DAEMON
62 #include "amuleDlg.h" // Needed for CamuleDlg
63 #include "CaptchaDialog.h" // Needed for CCaptchaDialog
64 #include "CaptchaGenerator.h"
65 #include "ChatWnd.h" // Needed for CChatWnd
66 #endif
67 #include "amule.h" // Needed for theApp
68 #include "PartFile.h" // Needed for CPartFile
69 #include "ClientTCPSocket.h" // Needed for CClientTCPSocket
70 #include "ListenSocket.h" // Needed for CListenSocket
71 #include "FriendList.h" // Needed for CFriendList
72 #include "Statistics.h" // Needed for theStats
73 #include "ClientUDPSocket.h"
74 #include "Logger.h"
75 #include "DataToText.h" // Needed for GetSoftName()
76 #include "GuiEvents.h" // Needed for Notify_
77 #include "ServerList.h" // For CServerList
78
79 #include "kademlia/kademlia/Kademlia.h"
80 #include "kademlia/kademlia/Prefs.h"
81 #include "kademlia/kademlia/Search.h"
82 #include "kademlia/kademlia/UDPFirewallTester.h"
83 #include "kademlia/routing/RoutingZone.h"
84
85
86 //#define __PACKET_DEBUG__
87
88
89 // some client testing variables
90 static wxString crash_name = wxT("[Invalid User Name]");
91 static wxString empty_name = wxT("[Empty User Name]");
92
93 // members of CUpDownClient
94 // which are used by down and uploading functions
95
96
97 CUpDownClient::CUpDownClient(CClientTCPSocket* sender)
98 {
99 #ifdef __DEBUG__
100 m_socket = NULL;
101 SetSocket(sender);
102 #else
103 m_socket = sender;
104 #endif
105 Init();
106 }
107
108 CUpDownClient::CUpDownClient(uint16 in_port, uint32 in_userid, uint32 in_serverip, uint16 in_serverport, CPartFile* in_reqfile, bool ed2kID, bool checkfriend)
109 {
110 m_socket = NULL;
111 Init();
112 m_nUserPort = in_port;
113
114 if(ed2kID && !IsLowID(in_userid)) {
115 SetUserIDHybrid( wxUINT32_SWAP_ALWAYS(in_userid) );
116 } else {
117 SetUserIDHybrid( in_userid);
118 }
119
120 //If highID and ED2K source, incoming ID and IP are equal..
121 //If highID and Kad source, incoming IP needs swap for the IP
122
123 if (!HasLowID()) {
124 if (ed2kID) {
125 m_nConnectIP = in_userid;
126 } else {
127 m_nConnectIP = wxUINT32_SWAP_ALWAYS(in_userid);
128 }
129 // Will be on right endianess now
130 m_FullUserIP = m_nConnectIP;
131 }
132
133 m_dwServerIP = in_serverip;
134 m_nServerPort = in_serverport;
135 SetRequestFile( in_reqfile );
136 ReGetClientSoft();
137
138 if (checkfriend) {
139 if ((m_Friend = theApp->friendlist->FindFriend(CMD4Hash(), m_dwUserIP, m_nUserPort)) != NULL){
140 m_Friend->LinkClient(CCLIENTREF(this, wxT("CUpDownClient::CUpDownClient m_Friend->LinkClient")));
141 } else{
142 // avoid that an unwanted client instance keeps a friend slot
143 m_bFriendSlot = false;
144 }
145 }
146
147 }
148
149 void CUpDownClient::Init()
150 {
151 m_linked = 0;
152 #ifdef DEBUG_ZOMBIE_CLIENTS
153 m_linkedDebug = false;
154 #endif
155 m_bAddNextConnect = false;
156 credits = NULL;
157 m_byChatstate = MS_NONE;
158 m_nKadState = KS_NONE;
159 m_nChatCaptchaState = CA_NONE;
160 m_cShowDR = 0;
161 m_reqfile = NULL; // No file required yet
162 m_nTransferredUp = 0;
163 m_cSendblock = 0;
164 m_cAsked = 0;
165 msReceivedPrev = 0;
166 kBpsDown = 0.0;
167 bytesReceivedCycle = 0;
168 m_nServerPort = 0;
169 m_iFileListRequested = 0;
170 m_dwLastUpRequest = 0;
171 m_bEmuleProtocol = false;
172 m_bCompleteSource = false;
173 m_bFriendSlot = false;
174 m_bCommentDirty = false;
175 m_bReaskPending = false;
176 m_bUDPPending = false;
177 m_nUserPort = 0;
178 m_nPartCount = 0;
179 m_dwLastAskedTime = 0;
180 m_nDownloadState = DS_NONE;
181 m_dwUploadTime = 0;
182 m_nTransferredDown = 0;
183 m_nUploadState = US_NONE;
184 m_dwLastBlockReceived = 0;
185 m_bUnicodeSupport = false;
186
187 m_fSentOutOfPartReqs = 0;
188 m_nCurQueueSessionPayloadUp = 0;
189 m_addedPayloadQueueSession = 0;
190 m_nUpDatarate = 0;
191 m_nSumForAvgUpDataRate = 0;
192
193 m_nRemoteQueueRank = 0;
194 m_nOldRemoteQueueRank = 0;
195 m_dwLastSourceRequest = 0;
196 m_dwLastSourceAnswer = 0;
197 m_dwLastAskedForSources = 0;
198
199 m_SecureIdentState = IS_UNAVAILABLE;
200 m_dwLastSignatureIP = 0;
201
202 m_byInfopacketsReceived = IP_NONE;
203
204 m_bIsHybrid = false;
205 m_bIsML = false;
206 m_Friend = NULL;
207 m_iRating = 0;
208 m_nCurSessionUp = 0;
209 m_clientSoft=SO_UNKNOWN;
210
211 m_bRemoteQueueFull = false;
212 m_HasValidHash = false;
213 SetWaitStartTime();
214
215 m_fHashsetRequesting = 0;
216 m_fSharedDirectories = 0;
217 m_lastPartAsked = 0xffff;
218 m_nUpCompleteSourcesCount= 0;
219 m_waitingPosition = 0;
220 m_score = 0;
221 m_lastRefreshedDLDisplay = 0;
222 m_bHelloAnswerPending = false;
223 m_fSentCancelTransfer = 0;
224 m_Aggressiveness = 0;
225 m_LastFileRequest = 0;
226
227 m_clientState = CS_NEW;
228
229 ClearHelloProperties();
230
231 m_pReqFileAICHHash = NULL;
232 m_fSupportsAICH = 0;
233 m_fAICHRequested = 0;
234 m_fSupportsLargeFiles = 0;
235 m_fExtMultiPacket = 0;
236 m_fIsSpammer = 0;
237
238 m_dwUserIP = 0;
239 m_nConnectIP = 0;
240 m_dwServerIP = 0;
241
242 m_fNeedOurPublicIP = false;
243 m_bHashsetRequested = false;
244
245 m_lastDownloadingPart = 0;
246
247 m_uploadingfile = NULL;
248
249 m_OSInfo_sent = false;
250
251 /* Kad stuff */
252 SetBuddyID(NULL);
253 m_nBuddyIP = 0;
254 m_nBuddyPort = 0;
255 m_nUserIDHybrid = 0;
256
257 m_nSourceFrom = SF_NONE;
258
259 if (m_socket) {
260 amuleIPV4Address address;
261 m_socket->GetPeer(address);
262 SetIP(StringIPtoUint32(address.IPAddress()));
263 } else {
264 SetIP(0);
265 }
266
267 /* Statistics */
268 m_lastClientSoft = (uint32)(-1);
269 m_lastClientVersion = 0;
270
271 /* Creation time (for buddies timeout) */
272 m_nCreationTime = ::GetTickCount();
273
274 m_MaxBlockRequests = STANDARD_BLOCKS_REQUEST; // Safe starting amount
275
276 m_last_block_start = 0;
277 m_lastaverage = 0;
278
279 SetLastBuddyPingPongTime();
280 m_fRequestsCryptLayer = 0;
281 m_fSupportsCryptLayer = 0;
282 m_fRequiresCryptLayer = 0;
283 m_fSupportsSourceEx2 = 0;
284 m_fSupportsCaptcha = 0;
285 m_fDirectUDPCallback = 0;
286 m_dwDirectCallbackTimeout = 0;
287
288 m_hasbeenobfuscatinglately = false;
289
290 m_cCaptchasSent = 0;
291 m_cMessagesReceived = 0;
292 m_cMessagesSent = 0;
293
294 }
295
296
297 CUpDownClient::~CUpDownClient()
298 {
299 #ifdef __DEBUG__
300 if (!connection_reason.IsEmpty()) {
301 AddDebugLogLineN(logClient, wxT("Client to check for ") + connection_reason + wxT(" was deleted without connection."));
302 }
303 #endif
304
305
306 if (m_lastClientSoft == SO_UNKNOWN) {
307 theStats::RemoveUnknownClient();
308 } else if (m_lastClientSoft != (uint32)(-1)) {
309 theStats::RemoveKnownClient(m_lastClientSoft, m_lastClientVersion, m_lastOSInfo);
310 }
311
312 // Indicate that we are not anymore on stats
313 m_lastClientSoft = (uint32)(-1);
314
315 // The socket should have been removed in Safe_Delete, but it
316 // doesn't hurt to have an extra check.
317 if (m_socket) {
318 m_socket->Safe_Delete();
319 // Paranoia
320 SetSocket(NULL);
321 }
322
323 ClearUploadBlockRequests();
324 ClearDownloadBlockRequests();
325
326 DeleteContents(m_WaitingPackets_list);
327
328 // Allow detection of deleted clients that didn't go through Safe_Delete
329 m_clientState = CS_DYING;
330 }
331
332
333 void CUpDownClient::ClearHelloProperties()
334 {
335 m_nUDPPort = 0;
336 m_byUDPVer = 0;
337 m_byDataCompVer = 0;
338 m_byEmuleVersion = 0;
339 m_bySourceExchange1Ver = 0;
340 m_byAcceptCommentVer = 0;
341 m_byExtendedRequestsVer = 0;
342 m_byCompatibleClient = 0;
343 m_nKadPort = 0;
344 m_bySupportSecIdent = 0;
345 m_bSupportsPreview = 0;
346 m_nClientVersion = 0;
347 m_fSharedDirectories = 0;
348 m_bMultiPacket = 0;
349 m_fOsInfoSupport = 0;
350 m_fValueBasedTypeTags = 0;
351 SecIdentSupRec = 0;
352 m_byKadVersion = 0;
353 m_fRequestsCryptLayer = 0;
354 m_fSupportsCryptLayer = 0;
355 m_fRequiresCryptLayer = 0;
356 m_fSupportsSourceEx2 = 0;
357 m_fSupportsCaptcha = 0;
358 m_fDirectUDPCallback = 0;
359 }
360
361 bool CUpDownClient::ProcessHelloPacket(const byte* pachPacket, uint32 nSize)
362 {
363 const CMemFile data(pachPacket,nSize);
364 uint8 hashsize = data.ReadUInt8();
365 if ( 16 != hashsize ) {
366 /*
367 * Hint: We can not accept other sizes here because:
368 * - the magic number is spread all over the source
369 * - the answer packet lacks the size field
370 */
371 throw wxString(wxT("Invalid Hello packet: Other userhash sizes than 16 are not implemented"));
372 }
373 // eMule 0.42: reset all client properties; a client may not send a particular emule tag any longer
374 ClearHelloProperties();
375
376 return ProcessHelloTypePacket(data);
377 }
378
379 void CUpDownClient::Safe_Delete()
380 {
381 // Because we are delaying the deletion, we might end up trying to delete
382 // it twice, however, this is normal and shouldn't trigger any failures
383 if ( m_clientState == CS_DYING ) {
384 return;
385 }
386
387 // If called from background, post an event to process it in main thread
388 if (!wxThread::IsMain()) {
389 CoreNotify_Client_Delete(CCLIENTREF(this, wxT("CUpDownClient::Safe_Delete CoreNotify_Client_Delete")));
390 return;
391 }
392
393 m_clientState = CS_DYING;
394
395 // Make sure client doesn't get deleted until this method is finished
396 CClientRef ref(CCLIENTREF(this, wxT("CUpDownClient::Safe_Delete reflocker")));
397
398 // Close the socket to avoid any more connections and related events
399 if ( m_socket ) {
400 m_socket->Safe_Delete();
401 // Paranoia
402 SetSocket(NULL);
403 }
404
405 // Remove the client from the clientlist if we still have it
406 if ( theApp->clientlist ) {
407 theApp->clientlist->RemoveClient( this );
408 }
409
410 // Doing what RemoveClient used to do. Just to be sure...
411 if (theApp->uploadqueue) {
412 theApp->uploadqueue->RemoveFromUploadQueue(this);
413 theApp->uploadqueue->RemoveFromWaitingQueue(this);
414 }
415 if (theApp->downloadqueue) {
416 theApp->downloadqueue->RemoveSource(this);
417 }
418
419 // For security, remove it from the lists unconditionally.
420 Notify_SharedCtrlRemoveClient(ECID(), (CKnownFile*)NULL);
421 Notify_SourceCtrlRemoveSource(ECID(), (CPartFile*)NULL);
422
423 if (IsAICHReqPending()){
424 m_fAICHRequested = FALSE;
425 CAICHHashSet::ClientAICHRequestFailed(this);
426 }
427
428 if (m_Friend) {
429 m_Friend->UnLinkClient(); // this notifies
430 m_Friend = NULL;
431 }
432
433 if (m_iRating>0 || !m_strComment.IsEmpty()) {
434 m_iRating = 0;
435 m_strComment.Clear();
436 if (m_reqfile) {
437 m_reqfile->UpdateFileRatingCommentAvail();
438 }
439 }
440
441 // Ensure that source-counts gets updated in case
442 // of a source not on the download-queue
443 SetRequestFile( NULL );
444
445 SetUploadFileID(NULL);
446
447 delete m_pReqFileAICHHash;
448 m_pReqFileAICHHash = NULL;
449
450 #ifdef DEBUG_ZOMBIE_CLIENTS
451 if (m_linked > 1) {
452 AddLogLineC(CFormat(wxT("Client %d still linked in %d places: %s")) % ECID() % (m_linked - 1) % GetLinkedFrom());
453 m_linkedDebug = true;
454 }
455 #endif
456 }
457
458
459 bool CUpDownClient::ProcessHelloAnswer(const byte* pachPacket, uint32 nSize)
460 {
461 const CMemFile data(pachPacket,nSize);
462 bool bIsMule = ProcessHelloTypePacket(data);
463 m_bHelloAnswerPending = false;
464 return bIsMule;
465 }
466
467 bool CUpDownClient::ProcessHelloTypePacket(const CMemFile& data)
468 {
469
470 m_bIsHybrid = false;
471 m_bIsML = false;
472 m_fNoViewSharedFiles = 0;
473 m_bUnicodeSupport = false;
474 uint32 dwEmuleTags = 0;
475
476 CMD4Hash hash = data.ReadHash();
477 SetUserHash( hash );
478 SetUserIDHybrid( data.ReadUInt32() );
479 uint16 nUserPort = data.ReadUInt16(); // hmm clientport is sent twice - why?
480 uint32 tagcount = data.ReadUInt32();
481 for (uint32 i = 0;i < tagcount; i++){
482 CTag temptag(data, true);
483 switch(temptag.GetNameID()){
484 case CT_NAME:
485 m_Username = temptag.GetStr();
486 break;
487
488 case CT_VERSION:
489 m_nClientVersion = temptag.GetInt();
490 break;
491
492 case ET_MOD_VERSION:
493 if (temptag.IsStr()) {
494 m_strModVersion = temptag.GetStr();
495 } else if (temptag.IsInt()) {
496 m_strModVersion = CFormat(wxT("ModID=%u")) % temptag.GetInt();
497 } else {
498 m_strModVersion = wxT("ModID=<Unknown>");
499 }
500
501 break;
502
503 case CT_PORT:
504 nUserPort = temptag.GetInt();
505 break;
506
507 case CT_EMULE_UDPPORTS:
508 // 16 KAD Port
509 // 16 UDP Port
510 SetKadPort((temptag.GetInt() >> 16) & 0xFFFF);
511 m_nUDPPort = temptag.GetInt() & 0xFFFF;
512 dwEmuleTags |= 1;
513 #ifdef __PACKET_DEBUG__
514 AddLogLineNS(CFormat(wxT("Hello type packet processing with eMule ports UDP=%i KAD=%i")) % m_nUDPPort % m_nKadPort);
515 #endif
516 break;
517
518 case CT_EMULE_BUDDYIP:
519 // 32 BUDDY IP
520 m_nBuddyIP = temptag.GetInt();
521 #ifdef __PACKET_DEBUG__
522 AddLogLineNS(CFormat(wxT("Hello type packet processing with eMule BuddyIP=%u (%s)")) % m_nBuddyIP % Uint32toStringIP(m_nBuddyIP));
523 #endif
524 break;
525
526 case CT_EMULE_BUDDYUDP:
527 // 16 --Reserved for future use--
528 // 16 BUDDY Port
529 m_nBuddyPort = (uint16)temptag.GetInt();
530 #ifdef __PACKET_DEBUG__
531 AddLogLineNS(CFormat(wxT("Hello type packet processing with eMule BuddyPort=%u")) % m_nBuddyPort);
532 #endif
533 break;
534
535 case CT_EMULE_MISCOPTIONS1: {
536 // 3 AICH Version (0 = not supported)
537 // 1 Unicode
538 // 4 UDP version
539 // 4 Data compression version
540 // 4 Secure Ident
541 // 4 Source Exchange
542 // 4 Ext. Requests
543 // 4 Comments
544 // 1 PeerCache supported
545 // 1 No 'View Shared Files' supported
546 // 1 MultiPacket
547 // 1 Preview
548 uint32 flags = temptag.GetInt();
549 m_fSupportsAICH = (flags >> (4*7+1)) & 0x07;
550 m_bUnicodeSupport = (flags >> 4*7) & 0x01;
551 m_byUDPVer = (flags >> 4*6) & 0x0f;
552 m_byDataCompVer = (flags >> 4*5) & 0x0f;
553 m_bySupportSecIdent = (flags >> 4*4) & 0x0f;
554 m_bySourceExchange1Ver = (flags >> 4*3) & 0x0f;
555 m_byExtendedRequestsVer = (flags >> 4*2) & 0x0f;
556 m_byAcceptCommentVer = (flags >> 4*1) & 0x0f;
557 m_fNoViewSharedFiles = (flags >> 1*2) & 0x01;
558 m_bMultiPacket = (flags >> 1*1) & 0x01;
559 m_fSupportsPreview = (flags >> 1*0) & 0x01;
560 dwEmuleTags |= 2;
561 #ifdef __PACKET_DEBUG__
562 AddLogLineNS(wxT("Hello type packet processing with eMule Misc Options:"));
563 AddLogLineNS(CFormat(wxT("m_byUDPVer = %i")) % m_byUDPVer);
564 AddLogLineNS(CFormat(wxT("m_byDataCompVer = %i")) % m_byDataCompVer);
565 AddLogLineNS(CFormat(wxT("m_bySupportSecIdent = %i")) % m_bySupportSecIdent);
566 AddLogLineNS(CFormat(wxT("m_bySourceExchangeVer = %i")) % m_bySourceExchange1Ver);
567 AddLogLineNS(CFormat(wxT("m_byExtendedRequestsVer = %i")) % m_byExtendedRequestsVer);
568 AddLogLineNS(CFormat(wxT("m_byAcceptCommentVer = %i")) % m_byAcceptCommentVer);
569 AddLogLineNS(CFormat(wxT("m_fNoViewSharedFiles = %i")) % m_fNoViewSharedFiles);
570 AddLogLineNS(CFormat(wxT("m_bMultiPacket = %i")) % m_bMultiPacket);
571 AddLogLineNS(CFormat(wxT("m_fSupportsPreview = %i")) % m_fSharedDirectories);
572 AddLogLineNS(wxT("That's all."));
573 #endif
574 SecIdentSupRec += 1;
575 break;
576 }
577
578 case CT_EMULE_MISCOPTIONS2:
579 // 19 Reserved
580 // 1 Direct UDP Callback supported and available
581 // 1 Supports ChatCaptchas
582 // 1 Supports SourceExachnge2 Packets, ignores SX1 Packet Version
583 // 1 Requires CryptLayer
584 // 1 Requests CryptLayer
585 // 1 Supports CryptLayer
586 // 1 Reserved (ModBit)
587 // 1 Ext Multipacket (Hash+Size instead of Hash)
588 // 1 Large Files (includes support for 64bit tags)
589 // 4 Kad Version - will go up to version 15 only (may need to add another field at some point in the future)
590 m_fDirectUDPCallback = (temptag.GetInt() >> 12) & 0x01;
591 m_fSupportsCaptcha = (temptag.GetInt() >> 11) & 0x01;
592 m_fSupportsSourceEx2 = (temptag.GetInt() >> 10) & 0x01;
593 m_fRequiresCryptLayer = (temptag.GetInt() >> 9) & 0x01;
594 m_fRequestsCryptLayer = (temptag.GetInt() >> 8) & 0x01;
595 m_fSupportsCryptLayer = (temptag.GetInt() >> 7) & 0x01;
596 // reserved 1
597 m_fExtMultiPacket = (temptag.GetInt() >> 5) & 0x01;
598 m_fSupportsLargeFiles = (temptag.GetInt() >> 4) & 0x01;
599 m_byKadVersion = (temptag.GetInt() >> 0) & 0x0f;
600 dwEmuleTags |= 8;
601
602 m_fRequestsCryptLayer &= m_fSupportsCryptLayer;
603 m_fRequiresCryptLayer &= m_fRequestsCryptLayer;
604
605 #ifdef __PACKET_DEBUG__
606 AddLogLineNS(wxT("Hello type packet processing with eMule Misc Options 2:"));
607 AddLogLineNS(CFormat(wxT(" m_fDirectUDPCallback = %i")) % m_fDirectUDPCallback);
608 AddLogLineNS(CFormat(wxT(" m_fSupportsCaptcha = %i")) % m_fSupportsCaptcha);
609 AddLogLineNS(CFormat(wxT(" m_fSupportsSourceEx2 = %i")) % m_fSupportsSourceEx2);
610 AddLogLineNS(CFormat(wxT(" m_fRequiresCryptLayer = %i")) % m_fRequiresCryptLayer);
611 AddLogLineNS(CFormat(wxT(" m_fRequestsCryptLayer = %i")) % m_fRequestsCryptLayer);
612 AddLogLineNS(CFormat(wxT(" m_fSupportsCryptLayer = %i")) % m_fSupportsCryptLayer);
613 AddLogLineNS(CFormat(wxT(" m_fExtMultiPacket = %i")) % m_fExtMultiPacket);
614 AddLogLineNS(CFormat(wxT(" m_fSupportsLargeFiles = %i")) % m_fSupportsLargeFiles);
615 AddLogLineNS(CFormat(wxT(" KadVersion = %u")) % m_byKadVersion);
616 AddLogLineNS(wxT("That's all."));
617 #endif
618 break;
619
620 // Special tag for Compat. Clients Misc options.
621 case CT_EMULECOMPAT_OPTIONS:
622 // 1 Operative System Info
623 // 1 Value-based-type int tags (experimental!)
624 m_fValueBasedTypeTags = (temptag.GetInt() >> 1*1) & 0x01;
625 m_fOsInfoSupport = (temptag.GetInt() >> 1*0) & 0x01;
626 break;
627
628 case CT_EMULE_VERSION:
629 // 8 Compatible Client ID
630 // 7 Mjr Version (Doesn't really matter..)
631 // 7 Min Version (Only need 0-99)
632 // 3 Upd Version (Only need 0-5)
633 // 7 Bld Version (Only need 0-99)
634 m_byCompatibleClient = (temptag.GetInt() >> 24);
635 m_nClientVersion = temptag.GetInt() & 0x00ffffff;
636 m_byEmuleVersion = 0x99;
637 m_fSharedDirectories = 1;
638 dwEmuleTags |= 4;
639 break;
640 }
641 }
642
643 m_nUserPort = nUserPort;
644 m_dwServerIP = data.ReadUInt32();
645 m_nServerPort = data.ReadUInt16();
646 // Hybrid now has an extra uint32.. What is it for?
647 // Also, many clients seem to send an extra 6? These are not eDonkeys or Hybrids..
648 if ( data.GetLength() - data.GetPosition() == sizeof(uint32) ) {
649 uint32 test = data.ReadUInt32();
650 /*if (test == 'KDLM') below kdlm is converted to ascii values.
651 This fixes a warning with gcc 3.4.
652 K=4b D=44 L=4c M=4d
653 */
654 if (test == 0x4b444c4d) { //if it's == "KDLM"
655 m_bIsML=true;
656 } else{
657 m_bIsHybrid = true;
658 m_fSharedDirectories = 1;
659 }
660 }
661
662 if (m_socket) {
663 amuleIPV4Address address;
664 m_socket->GetPeer(address);
665 SetIP(StringIPtoUint32(address.IPAddress()));
666 } else {
667 throw wxString(wxT("Huh, socket failure. Avoided crash this time."));
668 }
669
670 if (thePrefs::AddServersFromClient()) {
671 CServer* addsrv = new CServer(m_nServerPort, Uint32toStringIP(m_dwServerIP));
672 addsrv->SetListName(addsrv->GetAddress());
673 if (!theApp->AddServer(addsrv)) {
674 delete addsrv;
675 }
676 }
677
678 //(a)If this is a highID user, store the ID in the Hybrid format.
679 //(b)Some older clients will not send a ID, these client are HighID users that are not connected to a server.
680 //(c)Kad users with a *.*.*.0 IPs will look like a lowID user they are actually a highID user.. They can be detected easily
681 //because they will send a ID that is the same as their IP..
682 if(!HasLowID() || m_nUserIDHybrid == 0 || m_nUserIDHybrid == m_dwUserIP ) {
683 SetUserIDHybrid(wxUINT32_SWAP_ALWAYS(m_dwUserIP));
684 }
685
686 // get client credits
687 CClientCredits* pFoundCredits = theApp->clientcredits->GetCredit(m_UserHash);
688 if (credits == NULL){
689 credits = pFoundCredits;
690 if (!theApp->clientlist->ComparePriorUserhash(m_dwUserIP, m_nUserPort, pFoundCredits)){
691 AddDebugLogLineN( logClient, CFormat( wxT("Client: %s (%s) Banreason: Userhash changed (Found in TrackedClientsList)") ) % GetUserName() % GetFullIP() );
692 Ban();
693 }
694 } else if (credits != pFoundCredits){
695 // userhash change ok, however two hours "waittime" before it can be used
696 credits = pFoundCredits;
697 AddDebugLogLineN( logClient, CFormat( wxT("Client: %s (%s) Banreason: Userhash changed") ) % GetUserName() % GetFullIP() );
698 Ban();
699 }
700
701 if ((m_Friend = theApp->friendlist->FindFriend(m_UserHash, m_dwUserIP, m_nUserPort)) != NULL){
702 m_Friend->LinkClient(CCLIENTREF(this, wxT("CUpDownClient::ProcessHelloTypePacket m_Friend->LinkClient")));
703 } else{
704 // avoid that an unwanted client instance keeps a friend slot
705 SetFriendSlot(false);
706 }
707
708
709 ReGetClientSoft();
710
711 m_byInfopacketsReceived |= IP_EDONKEYPROTPACK;
712
713 // check if at least CT_EMULEVERSION was received, all other tags are optional
714 bool bIsMule = (dwEmuleTags & 0x04) == 0x04;
715 if (bIsMule) {
716 m_bEmuleProtocol = true;
717 m_byInfopacketsReceived |= IP_EMULEPROTPACK;
718 }
719
720 if (GetKadPort() && GetKadVersion() > 1) {
721 Kademlia::CKademlia::Bootstrap(wxUINT32_SWAP_ALWAYS(GetIP()), GetKadPort());
722 }
723
724 return bIsMule;
725 }
726
727
728 bool CUpDownClient::SendHelloPacket()
729 {
730 if (m_socket == NULL) {
731 wxFAIL;
732 return true;
733 }
734
735 // if IP is filtered, don't greet him but disconnect...
736 amuleIPV4Address address;
737 m_socket->GetPeer(address);
738 if ( theApp->ipfilter->IsFiltered(StringIPtoUint32(address.IPAddress()))) {
739 if (Disconnected(wxT("IPFilter"))) {
740 Safe_Delete();
741 return false;
742 }
743 return true;
744 }
745
746 CMemFile data(128);
747 data.WriteUInt8(16); // size of userhash
748 SendHelloTypePacket(&data);
749
750 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_HELLO);
751 theStats::AddUpOverheadOther(packet->GetPacketSize());
752 SendPacket(packet,true);
753 m_bHelloAnswerPending = true;
754 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_HELLO to ") + GetFullIP() );
755 return true;
756 }
757
758 void CUpDownClient::SendMuleInfoPacket(bool bAnswer, bool OSInfo) {
759
760 if (m_socket == NULL){
761 wxFAIL;
762 return;
763 }
764
765 CPacket* packet = NULL;
766 CMemFile data;
767
768 data.WriteUInt8(CURRENT_VERSION_SHORT);
769
770 if (OSInfo) {
771
772 // Special MuleInfo packet for clients supporting it.
773 // This means aMule >= 2.0.0 and Hydranode
774
775 // Violently mark it as special Mule Info packet
776 // Sending this makes non-supporting-osinfo clients to refuse to read this
777 // packet. Anyway, this packet should NEVER get to non-supporting clients.
778
779 data.WriteUInt8(/*EMULE_PROTOCOL*/ 0xFF);
780
781 data.WriteUInt32(1); // One Tag (OS_INFO)
782
783 CTagString tag1(ET_OS_INFO,theApp->GetOSType());
784 tag1.WriteTagToFile(&data);
785
786 m_OSInfo_sent = true; // So we don't send it again
787
788 } else {
789
790 // Normal MuleInfo packet
791
792 // Kry - There's no point on upgrading to VBT tags here
793 // as no client supporting it uses mule info packet.
794
795 data.WriteUInt8(EMULE_PROTOCOL);
796
797 // Tag number
798 data.WriteUInt32(9);
799
800 CTagInt32 tag1(ET_COMPRESSION,1);
801 tag1.WriteTagToFile(&data);
802 CTagInt32 tag2(ET_UDPVER,4);
803 tag2.WriteTagToFile(&data);
804 CTagInt32 tag3(ET_UDPPORT, thePrefs::GetEffectiveUDPPort());
805 tag3.WriteTagToFile(&data);
806 CTagInt32 tag4(ET_SOURCEEXCHANGE,3);
807 tag4.WriteTagToFile(&data);
808 CTagInt32 tag5(ET_COMMENTS,1);
809 tag5.WriteTagToFile(&data);
810 CTagInt32 tag6(ET_EXTENDEDREQUEST,2);
811 tag6.WriteTagToFile(&data);
812
813 uint32 dwTagValue = (theApp->CryptoAvailable() ? 3 : 0);
814 // Kry - Needs the preview code from eMule
815 /*
816 // set 'Preview supported' only if 'View Shared Files' allowed
817 if (thePrefs::CanSeeShares() != vsfaNobody) {
818 dwTagValue |= 128;
819 }
820 */
821 CTagInt32 tag7(ET_FEATURES, dwTagValue);
822 tag7.WriteTagToFile(&data);
823
824 CTagInt32 tag8(ET_COMPATIBLECLIENT,SO_AMULE);
825 tag8.WriteTagToFile(&data);
826
827 // Support for tag ET_MOD_VERSION
828 wxString mod_name(MOD_VERSION_LONG);
829 CTagString tag9(ET_MOD_VERSION, mod_name);
830 tag9.WriteTagToFile(&data);
831 // Maella end
832
833 }
834
835 packet = new CPacket(data, OP_EMULEPROT, (bAnswer ? OP_EMULEINFOANSWER : OP_EMULEINFO));
836
837 if (m_socket) {
838 theStats::AddUpOverheadOther(packet->GetPacketSize());
839 SendPacket(packet,true,true);
840
841 if (!bAnswer) {
842 if (!OSInfo) {
843 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_EMULEINFO to ") + GetFullIP() );
844 } else {
845 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_EMULEINFO/OS_INFO to ") + GetFullIP() );
846 }
847 } else {
848 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_EMULEINFOANSWER to ") + GetFullIP() );
849 }
850 }
851 }
852
853 bool CUpDownClient::ProcessMuleInfoPacket(const byte* pachPacket, uint32 nSize)
854 {
855 uint8 protocol_version;
856
857 const CMemFile data(pachPacket,nSize);
858
859 // The version number part of this packet will soon be useless since
860 // it is only able to go to v.99. Why the version is a uint8 and why
861 // it was not done as a tag like the eDonkey hello packet is not known.
862 // Therefore, sooner or later, we are going to have to switch over to
863 // using the eDonkey hello packet to set the version. No sense making
864 // a third value sent for versions.
865 uint8 mule_version = data.ReadUInt8();
866 protocol_version = data.ReadUInt8();
867 uint32 tagcount = data.ReadUInt32();
868 if (protocol_version == 0xFF) {
869 // OS Info supporting clients sending a recycled Mule info packet
870 for (uint32 i = 0;i < tagcount; i++){
871 CTag temptag(data, true);
872 switch(temptag.GetNameID()){
873 case ET_OS_INFO:
874 // Special tag, only supporting clients (aMule/Hydranode)
875 // It was recycled from a mod's tag, so if the other side
876 // is not supporting OS Info, we're seriously fucked up :)
877 m_sClientOSInfo = temptag.GetStr();
878
879 // If we didn't send our OSInfo to this client, just send it
880 if (!m_OSInfo_sent) {
881 SendMuleInfoPacket(false,true);
882 }
883
884 UpdateStats();
885
886 break;
887
888 // Your ad... er... I mean TAG, here
889
890 default:
891 break;
892 }
893 }
894 } else {
895 // Old eMule sending tags
896 m_byCompatibleClient = 0;
897 m_byEmuleVersion = mule_version;
898
899 if( m_byEmuleVersion == 0x2B ) {
900 m_byEmuleVersion = 0x22;
901 }
902
903 if (!(m_bEmuleProtocol = (protocol_version == EMULE_PROTOCOL))) {
904 return false;
905 }
906
907 for (uint32 i = 0;i < tagcount; i++){
908 CTag temptag(data, false);
909 switch(temptag.GetNameID()){
910 case ET_COMPRESSION:
911 // Bits 31- 8: 0 - reserved
912 // Bits 7- 0: data compression version
913 m_byDataCompVer = temptag.GetInt();
914 break;
915
916 case ET_UDPPORT:
917 // Bits 31-16: 0 - reserved
918 // Bits 15- 0: UDP port
919 m_nUDPPort = temptag.GetInt();
920 break;
921
922 case ET_UDPVER:
923 // Bits 31- 8: 0 - reserved
924 // Bits 7- 0: UDP protocol version
925 m_byUDPVer = temptag.GetInt();
926 break;
927
928 case ET_SOURCEEXCHANGE:
929 // Bits 31- 8: 0 - reserved
930 // Bits 7- 0: source exchange protocol version
931 m_bySourceExchange1Ver = temptag.GetInt();
932 break;
933
934 case ET_COMMENTS:
935 // Bits 31- 8: 0 - reserved
936 // Bits 7- 0: comments version
937 m_byAcceptCommentVer = temptag.GetInt();
938 break;
939
940 case ET_EXTENDEDREQUEST:
941 // Bits 31- 8: 0 - reserved
942 // Bits 7- 0: extended requests version
943 m_byExtendedRequestsVer = temptag.GetInt();
944 break;
945
946 case ET_COMPATIBLECLIENT:
947 // Bits 31- 8: 0 - reserved
948 // Bits 7- 0: compatible client ID
949 m_byCompatibleClient = temptag.GetInt();
950 break;
951
952 case ET_FEATURES:
953 // Bits 31- 8: 0 - reserved
954 // Bit 7: Preview
955 // Bit 6- 0: secure identification
956 m_bySupportSecIdent = temptag.GetInt() & 3;
957 m_bSupportsPreview = (temptag.GetInt() & 128) > 0;
958 SecIdentSupRec += 2;
959 break;
960
961 case ET_MOD_VERSION:
962 if (temptag.IsStr()) {
963 m_strModVersion = temptag.GetStr();
964 } else if (temptag.IsInt()) {
965 m_strModVersion = CFormat(wxT("ModID=%u")) % temptag.GetInt();
966 } else {
967 m_strModVersion = wxT("ModID=<Unknown>");
968 }
969
970 break;
971
972 default:
973 AddDebugLogLineN( logPacketErrors,
974 CFormat( wxT("Unknown Mule tag (%s) from client: %s") )
975 % temptag.GetFullInfo()
976 % GetClientFullInfo()
977 );
978
979 break;
980 }
981 }
982
983 if( m_byDataCompVer == 0 ){
984 m_bySourceExchange1Ver = 0;
985 m_byExtendedRequestsVer = 0;
986 m_byAcceptCommentVer = 0;
987 m_nUDPPort = 0;
988 }
989
990 //implicitly supported options by older clients
991 //in the future do not use version to guess about new features
992 if(m_byEmuleVersion < 0x25 && m_byEmuleVersion > 0x22) {
993 m_byUDPVer = 1;
994 }
995
996 if(m_byEmuleVersion < 0x25 && m_byEmuleVersion > 0x21) {
997 m_bySourceExchange1Ver = 1;
998 }
999
1000 if(m_byEmuleVersion == 0x24) {
1001 m_byAcceptCommentVer = 1;
1002 }
1003
1004 // Shared directories are requested from eMule 0.28+ because eMule 0.27 has a bug in
1005 // the OP_ASKSHAREDFILESDIR handler, which does not return the shared files for a
1006 // directory which has a trailing backslash.
1007 if(m_byEmuleVersion >= 0x28 && !m_bIsML) {// MLdonkey currently does not support shared directories
1008 m_fSharedDirectories = 1;
1009 }
1010
1011 ReGetClientSoft();
1012
1013 m_byInfopacketsReceived |= IP_EMULEPROTPACK;
1014 }
1015
1016 return (protocol_version == 0xFF); // This was a OS_Info?
1017 }
1018
1019
1020 void CUpDownClient::SendHelloAnswer()
1021 {
1022 if (m_socket == NULL){
1023 wxFAIL;
1024 return;
1025 }
1026
1027 CMemFile data(128);
1028 SendHelloTypePacket(&data);
1029 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_HELLOANSWER);
1030 theStats::AddUpOverheadOther(packet->GetPacketSize());
1031 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_HELLOANSWER to ") + GetFullIP() );
1032 SendPacket(packet,true);
1033 }
1034
1035
1036 void CUpDownClient::SendHelloTypePacket(CMemFile* data)
1037 {
1038 data->WriteHash(thePrefs::GetUserHash());
1039 data->WriteUInt32(theApp->GetID());
1040 data->WriteUInt16(thePrefs::GetPort());
1041
1042 uint32 tagcount = 6;
1043
1044 if( theApp->clientlist->GetBuddy() && theApp->IsFirewalled() ) {
1045 tagcount += 2;
1046 }
1047 tagcount ++; // eMule misc flags 2 (kad version)
1048
1049 #ifdef __SVN__
1050 // Kry - This is the tagcount!!! Be sure to update it!!
1051 // Last update: CT_EMULECOMPAT_OPTIONS included
1052 data->WriteUInt32(tagcount + 1);
1053 #else
1054 data->WriteUInt32(tagcount); // NO MOD_VERSION
1055 #endif
1056
1057
1058 CTagString tagname(CT_NAME,thePrefs::GetUserNick());
1059 tagname.WriteTagToFile(data, utf8strRaw);
1060
1061 CTagVarInt tagversion(CT_VERSION, EDONKEYVERSION, GetVBTTags() ? 0 : 32);
1062 tagversion.WriteTagToFile(data);
1063 // eMule UDP Ports
1064
1065 uint32 kadUDPPort = 0;
1066
1067 if(Kademlia::CKademlia::IsConnected()) {
1068 if (Kademlia::CKademlia::GetPrefs()->GetExternalKadPort() != 0 && Kademlia::CKademlia::GetPrefs()->GetUseExternKadPort() && Kademlia::CUDPFirewallTester::IsVerified()) {
1069 kadUDPPort = Kademlia::CKademlia::GetPrefs()->GetExternalKadPort();
1070 } else {
1071 kadUDPPort = Kademlia::CKademlia::GetPrefs()->GetInternKadPort();
1072 }
1073 }
1074
1075 CTagVarInt tagUdpPorts(CT_EMULE_UDPPORTS, (kadUDPPort << 16) | ((uint32)thePrefs::GetEffectiveUDPPort()), GetVBTTags() ? 0 : 32);
1076 tagUdpPorts.WriteTagToFile(data);
1077
1078 if( theApp->clientlist->GetBuddy() && theApp->IsFirewalled() ) {
1079 CTagVarInt tagBuddyIP(CT_EMULE_BUDDYIP, theApp->clientlist->GetBuddy()->GetIP(), GetVBTTags() ? 0 : 32);
1080 tagBuddyIP.WriteTagToFile(data);
1081
1082 CTagVarInt tagBuddyPort(CT_EMULE_BUDDYUDP,
1083 // ( RESERVED )
1084 ((uint32)theApp->clientlist->GetBuddy()->GetUDPPort() )
1085 , GetVBTTags() ? 0 : 32);
1086 tagBuddyPort.WriteTagToFile(data);
1087 }
1088
1089 // aMule Version
1090 CTagVarInt tagMuleVersion(CT_EMULE_VERSION,
1091 (SO_AMULE << 24) |
1092 make_full_ed2k_version(VERSION_MJR, VERSION_MIN, VERSION_UPDATE)
1093 // | (RESERVED )
1094 , GetVBTTags() ? 0 : 32);
1095 tagMuleVersion.WriteTagToFile(data);
1096
1097
1098 // eMule Misc. Options #1
1099 const uint32 uUdpVer = 4;
1100 const uint32 uDataCompVer = 1;
1101 const uint32 uSupportSecIdent = theApp->CryptoAvailable() ? 3 : 0;
1102 const uint32 uSourceExchangeVer = 3;
1103 const uint32 uExtendedRequestsVer = 2;
1104 const uint32 uAcceptCommentVer = 1;
1105 const uint32 uNoViewSharedFiles = (thePrefs::CanSeeShares() == vsfaNobody) ? 1 : 0; // for backward compatibility this has to be a 'negative' flag
1106 const uint32 uMultiPacket = 1;
1107 const uint32 uSupportPreview = 0; // No network preview at all.
1108 const uint32 uPeerCache = 0; // No peercache for aMule, baby
1109 const uint32 uUnicodeSupport = 1;
1110 const uint32 nAICHVer = 1; // AICH is ENABLED right now.
1111
1112 CTagVarInt tagMisOptions(CT_EMULE_MISCOPTIONS1,
1113 (nAICHVer << ((4*7)+1)) |
1114 (uUnicodeSupport << 4*7) |
1115 (uUdpVer << 4*6) |
1116 (uDataCompVer << 4*5) |
1117 (uSupportSecIdent << 4*4) |
1118 (uSourceExchangeVer << 4*3) |
1119 (uExtendedRequestsVer << 4*2) |
1120 (uAcceptCommentVer << 4*1) |
1121 (uPeerCache << 1*3) |
1122 (uNoViewSharedFiles << 1*2) |
1123 (uMultiPacket << 1*1) |
1124 (uSupportPreview << 1*0)
1125 , GetVBTTags() ? 0 : 32);
1126 tagMisOptions.WriteTagToFile(data);
1127
1128 // eMule Misc. Options #2
1129 const uint32 uKadVersion = KADEMLIA_VERSION;
1130 const uint32 uSupportLargeFiles = 1;
1131 const uint32 uExtMultiPacket = 1;
1132 const uint32 uReserved = 0; // mod bit
1133 const uint32 uSupportsCryptLayer = thePrefs::IsClientCryptLayerSupported() ? 1 : 0;
1134 const uint32 uRequestsCryptLayer = thePrefs::IsClientCryptLayerRequested() ? 1 : 0;
1135 const uint32 uRequiresCryptLayer = thePrefs::IsClientCryptLayerRequired() ? 1 : 0;
1136 const uint32 uSupportsSourceEx2 = 1;
1137 #ifdef AMULE_DAEMON
1138 // captcha for daemon/remotegui not supported for now
1139 const uint32 uSupportsCaptcha = 0;
1140 #else
1141 const uint32 uSupportsCaptcha = 1;
1142 #endif
1143 // direct callback is only possible if connected to kad, tcp firewalled and verified UDP open (for example on a full cone NAT)
1144 const uint32 uDirectUDPCallback = (Kademlia::CKademlia::IsRunning() && Kademlia::CKademlia::IsFirewalled()
1145 && !Kademlia::CUDPFirewallTester::IsFirewalledUDP(true) && Kademlia::CUDPFirewallTester::IsVerified()) ? 1 : 0;
1146
1147 CTagVarInt tagMisOptions2(CT_EMULE_MISCOPTIONS2,
1148 // (RESERVED )
1149 (uDirectUDPCallback << 12) |
1150 (uSupportsCaptcha << 11) |
1151 (uSupportsSourceEx2 << 10) |
1152 (uRequiresCryptLayer << 9) |
1153 (uRequestsCryptLayer << 8) |
1154 (uSupportsCryptLayer << 7) |
1155 (uReserved << 6) |
1156 (uExtMultiPacket << 5) |
1157 (uSupportLargeFiles << 4) |
1158 (uKadVersion << 0)
1159 , GetVBTTags() ? 0 : 32 );
1160 tagMisOptions2.WriteTagToFile(data);
1161
1162 const uint32 nOSInfoSupport = 1; // We support OS_INFO
1163 const uint32 nValueBasedTypeTags = 0; // Experimental, disabled
1164
1165 CTagVarInt tagMisCompatOptions(CT_EMULECOMPAT_OPTIONS,
1166 (nValueBasedTypeTags << 1*1) |
1167 (nOSInfoSupport << 1*0)
1168 , GetVBTTags() ? 0 : 32);
1169
1170 tagMisCompatOptions.WriteTagToFile(data);
1171
1172 #ifdef __SVN__
1173 wxString mod_name(MOD_VERSION_LONG);
1174 CTagString tagModName(ET_MOD_VERSION, mod_name);
1175 tagModName.WriteTagToFile(data);
1176 #endif
1177
1178 uint32 dwIP = 0;
1179 uint16 nPort = 0;
1180 if (theApp->IsConnectedED2K()) {
1181 dwIP = theApp->serverconnect->GetCurrentServer()->GetIP();
1182 nPort = theApp->serverconnect->GetCurrentServer()->GetPort();
1183 }
1184 data->WriteUInt32(dwIP);
1185 data->WriteUInt16(nPort);
1186 }
1187
1188
1189 void CUpDownClient::ProcessMuleCommentPacket(const byte* pachPacket, uint32 nSize)
1190 {
1191 if (!m_reqfile) {
1192 throw CInvalidPacket(wxT("Comment packet for unknown file"));
1193 }
1194
1195 if (!m_reqfile->IsPartFile()) {
1196 throw CInvalidPacket(wxT("Comment packet for completed file"));
1197 }
1198
1199 const CMemFile data(pachPacket, nSize);
1200
1201 uint8 rating = data.ReadUInt8();
1202 if (rating > 5) {
1203 AddDebugLogLineN( logClient, wxString(wxT("Invalid Rating for file '")) << m_clientFilename << wxT("' received: ") << rating);
1204 m_iRating = 0;
1205 } else {
1206 m_iRating = rating;
1207 AddDebugLogLineN( logClient, wxString(wxT("Rating for file '")) << m_clientFilename << wxT("' received: ") << m_iRating);
1208 }
1209
1210 // The comment is unicoded, with a uin32 len and safe read
1211 // (won't break if string size is < than advertised len)
1212 // Truncated to MAXFILECOMMENTLEN size
1213 m_strComment = data.ReadString((GetUnicodeSupport() != utf8strNone), 4 /* bytes (it's a uint32)*/, true).Left(MAXFILECOMMENTLEN);
1214
1215 AddDebugLogLineN( logClient, wxString(wxT("Description for file '")) << m_clientFilename << wxT("' received: ") << m_strComment);
1216
1217 // Update file rating
1218 m_reqfile->UpdateFileRatingCommentAvail();
1219 }
1220
1221
1222 void CUpDownClient::ClearDownloadBlockRequests()
1223 {
1224 {
1225 std::list<Requested_Block_Struct*>::iterator it = m_DownloadBlocks_list.begin();
1226 for (; it != m_DownloadBlocks_list.end(); ++it) {
1227 Requested_Block_Struct* cur_block = *it;
1228
1229 if (m_reqfile){
1230 m_reqfile->RemoveBlockFromList(cur_block->StartOffset, cur_block->EndOffset);
1231 }
1232
1233 delete cur_block;
1234 }
1235
1236 m_DownloadBlocks_list.clear();
1237 }
1238
1239 {
1240 std::list<Pending_Block_Struct*>::iterator it = m_PendingBlocks_list.begin();
1241 for (; it != m_PendingBlocks_list.end(); ++it) {
1242 Pending_Block_Struct* pending = *it;
1243
1244 if (m_reqfile) {
1245 m_reqfile->RemoveBlockFromList(pending->block->StartOffset, pending->block->EndOffset);
1246 }
1247
1248 delete pending->block;
1249 // Not always allocated
1250 if (pending->zStream){
1251 inflateEnd(pending->zStream);
1252 delete pending->zStream;
1253 }
1254
1255 delete pending;
1256 }
1257
1258 m_PendingBlocks_list.clear();
1259 }
1260 }
1261
1262
1263 bool CUpDownClient::Disconnected(const wxString& strReason, bool bFromSocket)
1264 {
1265 //wxASSERT(theApp->clientlist->IsValidClient(this));
1266
1267 if (HasBeenDeleted()) {
1268 AddDebugLogLineN(logClient, wxT("Disconnected() called for already deleted client on ip ") + Uint32toStringIP(GetConnectIP()));
1269 return false;
1270 }
1271
1272 // was this a direct callback?
1273 if (m_dwDirectCallbackTimeout != 0) {
1274 theApp->clientlist->RemoveDirectCallback(this);
1275 m_dwDirectCallbackTimeout = 0;
1276 theApp->clientlist->AddDeadSource(this);
1277 AddDebugLogLineN(logClient, wxT("Direct callback failed to client on ip ") + Uint32toStringIP(GetConnectIP()));
1278 }
1279
1280 if (GetKadState() == KS_QUEUED_FWCHECK_UDP || GetKadState() == KS_CONNECTING_FWCHECK_UDP) {
1281 Kademlia::CUDPFirewallTester::SetUDPFWCheckResult(false, true, wxUINT32_SWAP_ALWAYS(GetConnectIP()), 0); // inform the tester that this test was cancelled
1282 } else if (GetKadState() == KS_FWCHECK_UDP) {
1283 Kademlia::CUDPFirewallTester::SetUDPFWCheckResult(false, false, wxUINT32_SWAP_ALWAYS(GetConnectIP()), 0); // inform the tester that this test has failed
1284 } else if (GetKadState() == KS_CONNECTED_BUDDY) {
1285 AddDebugLogLineN(logClient, wxT("Buddy client disconnected - ") + strReason);
1286 }
1287
1288 //If this is a KAD client object, just delete it!
1289 SetKadState(KS_NONE);
1290
1291 if (GetUploadState() == US_UPLOADING) {
1292 // sets US_NONE
1293 theApp->uploadqueue->RemoveFromUploadQueue(this);
1294 }
1295
1296 if (GetDownloadState() == DS_DOWNLOADING) {
1297 SetDownloadState(DS_ONQUEUE);
1298 } else {
1299 // ensure that all possible block requests are removed from the partfile
1300 ClearDownloadBlockRequests();
1301
1302 if (GetDownloadState() == DS_CONNECTED) {
1303 // successfully connected, but probably didn't respond to our filerequest
1304 theApp->clientlist->AddDeadSource(this);
1305 theApp->downloadqueue->RemoveSource(this);
1306 }
1307 }
1308
1309 // we had still an AICH request pending, handle it
1310 if (IsAICHReqPending()) {
1311 m_fAICHRequested = FALSE;
1312 CAICHHashSet::ClientAICHRequestFailed(this);
1313 }
1314
1315 // The remote client does not have to answer with OP_HASHSETANSWER *immediatly*
1316 // after we've sent OP_HASHSETREQUEST. It may occure that a (buggy) remote client
1317 // is sending use another OP_FILESTATUS which would let us change to DL-state to DS_ONQUEUE.
1318 if (((GetDownloadState() == DS_REQHASHSET) || m_fHashsetRequesting) && (m_reqfile)) {
1319 m_reqfile->SetHashSetNeeded(true);
1320 }
1321
1322 SourceItemType source_type = UNAVAILABLE_SOURCE;
1323 SourceItemType peer_type = UNAVAILABLE_SOURCE;
1324
1325 //check if this client is needed in any way, if not delete it
1326 bool bDelete = true;
1327 switch (m_nUploadState) {
1328 case US_ONUPLOADQUEUE:
1329 bDelete = false;
1330 peer_type = AVAILABLE_SOURCE;
1331 break;
1332 };
1333
1334 switch (m_nDownloadState) {
1335 case DS_ONQUEUE:
1336 source_type = A4AF_SOURCE; // Will be checked.
1337 case DS_TOOMANYCONNS:
1338 case DS_NONEEDEDPARTS:
1339 case DS_LOWTOLOWIP:
1340 bDelete = false;
1341 break;
1342 };
1343
1344 switch (m_nUploadState) {
1345 case US_CONNECTING:
1346 case US_WAITCALLBACK:
1347 case US_ERROR:
1348 theApp->clientlist->AddDeadSource(this);
1349 bDelete = true;
1350 };
1351
1352 switch (m_nDownloadState) {
1353 case DS_CONNECTING:
1354 case DS_WAITCALLBACK:
1355 case DS_ERROR:
1356 case DS_BANNED:
1357 theApp->clientlist->AddDeadSource(this);
1358 bDelete = true;
1359 };
1360
1361
1362 // We keep chat partners in any case
1363 if (GetChatState() != MS_NONE) {
1364 bDelete = false;
1365 m_pendingMessage.Clear();
1366 Notify_ChatConnResult(false,GUI_ID(GetIP(),GetUserPort()),wxEmptyString);
1367 }
1368
1369 // Delete socket
1370 if (!bFromSocket && m_socket) {
1371 wxASSERT (theApp->listensocket->IsValidSocket(m_socket));
1372 m_socket->Safe_Delete();
1373 }
1374
1375 SetSocket(NULL);
1376
1377 if (m_iFileListRequested) {
1378 AddLogLineN(CFormat(_("Failed to retrieve shared files from user '%s'")) % GetUserName() );
1379 m_iFileListRequested = 0;
1380 }
1381
1382
1383 if (bDelete) {
1384 if (m_Friend) {
1385 // Remove the friend linkage
1386 m_Friend->UnLinkClient(); // this notifies
1387 }
1388 } else {
1389 Notify_SharedCtrlRefreshClient(ECID(), peer_type);
1390 Notify_SourceCtrlUpdateSource(ECID(), source_type);
1391
1392 m_fHashsetRequesting = 0;
1393 SetSentCancelTransfer(0);
1394 m_bHelloAnswerPending = false;
1395 m_fSentOutOfPartReqs = 0;
1396 }
1397 AddDebugLogLineN(logClient, CFormat(wxT("--- %s client D:%d U:%d \"%s\"; Reason was %s"))
1398 % (bDelete ? wxT("Deleted") : wxT("Disconnected"))
1399 % m_nDownloadState % m_nUploadState % GetClientFullInfo() % strReason );
1400
1401 return bDelete;
1402 }
1403
1404 //Returned bool is not if the TryToConnect is successful or not..
1405 //false means the client was deleted!
1406 //true means the client was not deleted!
1407 bool CUpDownClient::TryToConnect(bool bIgnoreMaxCon)
1408 {
1409 // Kad reviewed
1410 if (theApp->listensocket->TooManySockets() && !bIgnoreMaxCon ) {
1411 if (!(m_socket && m_socket->IsConnected())) {
1412 if(Disconnected(wxT("Too many connections"))) {
1413 Safe_Delete();
1414 return false;
1415 }
1416 return true;
1417 }
1418 }
1419
1420 // 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)
1421 if ( (RequiresCryptLayer() && !thePrefs::IsClientCryptLayerSupported()) || (thePrefs::IsClientCryptLayerRequired() && !SupportsCryptLayer()) ){
1422 if(Disconnected(wxT("CryptLayer-Settings (Obfuscation) incompatible"))){
1423 Safe_Delete();
1424 return false;
1425 } else {
1426 return true;
1427 }
1428 }
1429
1430 // Ipfilter check
1431 uint32 uClientIP = GetIP();
1432 if (uClientIP == 0 && !HasLowID()) {
1433 uClientIP = wxUINT32_SWAP_ALWAYS(m_nUserIDHybrid);
1434 }
1435
1436 if (uClientIP) {
1437 // Although we filter all received IPs (server sources, source exchange) and all incomming connection attempts,
1438 // we do have to filter outgoing connection attempts here too, because we may have updated the ip filter list
1439 if (theApp->ipfilter->IsFiltered(uClientIP)) {
1440 AddDebugLogLineN(logIPFilter, CFormat(wxT("Filtered ip %u (%s) on TryToConnect\n")) % uClientIP % Uint32toStringIP(uClientIP));
1441 if (Disconnected(wxT("IPFilter"))) {
1442 Safe_Delete();
1443 return false;
1444 }
1445 return true;
1446 }
1447
1448 // for safety: check again whether that IP is banned
1449 if (theApp->clientlist->IsBannedClient(uClientIP)) {
1450 AddDebugLogLineN(logClient, wxT("Refused to connect to banned client ") + Uint32toStringIP(uClientIP));
1451 if (Disconnected(wxT("Banned IP"))) {
1452 Safe_Delete();
1453 return false;
1454 }
1455 return true;
1456 }
1457 }
1458
1459 if (GetKadState() == KS_QUEUED_FWCHECK) {
1460 SetKadState(KS_CONNECTING_FWCHECK);
1461 } else if (GetKadState() == KS_QUEUED_FWCHECK_UDP) {
1462 SetKadState(KS_CONNECTING_FWCHECK_UDP);
1463 }
1464
1465 if (HasLowID()) {
1466 if (!theApp->CanDoCallback(GetServerIP(), GetServerPort())) {
1467 //We cannot do a callback!
1468 if (GetDownloadState() == DS_CONNECTING) {
1469 SetDownloadState(DS_LOWTOLOWIP);
1470 } else if (GetDownloadState() == DS_REQHASHSET) {
1471 SetDownloadState(DS_ONQUEUE);
1472 m_reqfile->SetHashSetNeeded(true);
1473 }
1474 if (GetUploadState() == US_CONNECTING) {
1475 if(Disconnected(wxT("LowID->LowID and US_CONNECTING"))) {
1476 Safe_Delete();
1477 return false;
1478 }
1479 }
1480 return true;
1481 }
1482
1483 //We already know we are not firewalled here as the above condition already detected LowID->LowID and returned.
1484 //If ANYTHING changes with the "if(!theApp->CanDoCallback(this))" above that will let you fall through
1485 //with the condition that the source is firewalled and we are firewalled, we must
1486 //recheck it before the this check..
1487 if (HasValidBuddyID() && !GetBuddyIP() && !GetBuddyPort() && !theApp->serverconnect->IsLocalServer(GetServerIP(), GetServerPort())
1488 && !(SupportsDirectUDPCallback() && thePrefs::GetEffectiveUDPPort() != 0)) {
1489 //This is a Kad firewalled source that we want to do a special callback because it has no buddyIP or buddyPort.
1490 if( Kademlia::CKademlia::IsConnected() ) {
1491 //We are connect to Kad
1492 if( Kademlia::CKademlia::GetPrefs()->GetTotalSource() > 0 || Kademlia::CSearchManager::AlreadySearchingFor(Kademlia::CUInt128(GetBuddyID()))) {
1493 //There are too many source lookups already or we are already searching this key.
1494 SetDownloadState(DS_TOOMANYCONNSKAD);
1495 return true;
1496 }
1497 }
1498 }
1499 }
1500
1501 if (!m_socket || !m_socket->IsConnected()) {
1502 if (m_socket) {
1503 m_socket->Safe_Delete();
1504 }
1505 m_socket = new CClientTCPSocket(this, thePrefs::GetProxyData());
1506 } else {
1507 ConnectionEstablished();
1508 return true;
1509 }
1510
1511
1512 if (HasLowID() && SupportsDirectUDPCallback() && thePrefs::GetEffectiveUDPPort() != 0 && GetConnectIP() != 0) { // LOWID with DirectCallback
1513 if (m_dwDirectCallbackTimeout != 0) {
1514 AddDebugLogLineN(logClient, wxT("ERROR: Trying Direct UDP Callback while already trying to connect to client on ip ") + Uint32toStringIP(GetConnectIP()));
1515 return true; // We're already trying a direct connection to this client
1516 }
1517 // a direct callback is possible - since no other parties are involved and only one additional packet overhead
1518 // is used we basically handle it like a normal connection try, no restrictions apply
1519 // we already check above with !theApp->CanDoCallback(this) if any callback is possible at all
1520 m_dwDirectCallbackTimeout = ::GetTickCount() + SEC2MS(45);
1521 theApp->clientlist->AddDirectCallbackClient(this);
1522 AddDebugLogLineN(logClient, CFormat(wxT("Direct Callback on port %u to client on ip %s")) % GetKadPort() % Uint32toStringIP(GetConnectIP()));
1523
1524 CMemFile data;
1525 data.WriteUInt16(thePrefs::GetPort()); // needs to know our port
1526 data.WriteHash(thePrefs::GetUserHash()); // and userhash
1527 // our connection settings
1528 data.WriteUInt8(Kademlia::CPrefs::GetMyConnectOptions(true, false));
1529 AddDebugLogLineN(logClientUDP, wxT("Sending OP_DIRECTCALLBACKREQ to ") + Uint32_16toStringIP_Port(GetConnectIP(), GetKadPort()));
1530 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_DIRECTCALLBACKREQ);
1531 theStats::AddUpOverheadOther(packet->GetPacketSize());
1532 theApp->clientudp->SendPacket(packet, GetConnectIP(), GetKadPort(), ShouldReceiveCryptUDPPackets(), GetUserHash().GetHash(), false, 0);
1533 } else if (HasLowID()) { // LOWID
1534 if (GetDownloadState() == DS_CONNECTING) {
1535 SetDownloadState(DS_WAITCALLBACK);
1536 }
1537 if (GetUploadState() == US_CONNECTING) {
1538 if(Disconnected(wxT("LowID and US_CONNECTING"))) {
1539 Safe_Delete();
1540 return false;
1541 }
1542 return true;
1543 }
1544
1545 if (theApp->serverconnect->IsLocalServer(m_dwServerIP,m_nServerPort)) {
1546 CMemFile data;
1547 // AFAICS, this id must be reversed to be sent to clients
1548 // But if I reverse it, we do a serve violation ;)
1549 data.WriteUInt32(m_nUserIDHybrid);
1550 CPacket* packet = new CPacket(data, OP_EDONKEYPROT, OP_CALLBACKREQUEST);
1551 theStats::AddUpOverheadServer(packet->GetPacketSize());
1552 AddDebugLogLineN(logLocalClient, wxT("Local Client: OP_CALLBACKREQUEST to ") + GetFullIP());
1553 theApp->serverconnect->SendPacket(packet);
1554 SetDownloadState(DS_WAITCALLBACK);
1555 } else {
1556 if (GetUploadState() == US_NONE && (!GetRemoteQueueRank() || m_bReaskPending)) {
1557
1558 if( !HasValidBuddyID() ) {
1559 theApp->downloadqueue->RemoveSource(this);
1560 if (Disconnected(wxT("LowID and US_NONE and QR=0"))) {
1561 Safe_Delete();
1562 return false;
1563 }
1564 return true;
1565 }
1566
1567 if( !Kademlia::CKademlia::IsConnected() ) {
1568 //We are not connected to Kad and this is a Kad Firewalled source..
1569 theApp->downloadqueue->RemoveSource(this);
1570 if(Disconnected(wxT("Kad Firewalled source but not connected to Kad."))) {
1571 Safe_Delete();
1572 return false;
1573 }
1574 return true;
1575 }
1576
1577 if( GetDownloadState() == DS_WAITCALLBACK ) {
1578 if( GetBuddyIP() && GetBuddyPort()) {
1579 CMemFile bio(34);
1580 bio.WriteUInt128(Kademlia::CUInt128(GetBuddyID()));
1581 bio.WriteUInt128(Kademlia::CUInt128(m_reqfile->GetFileHash().GetHash()));
1582 bio.WriteUInt16(thePrefs::GetPort());
1583 CPacket* packet = new CPacket(bio, OP_KADEMLIAHEADER, KADEMLIA_CALLBACK_REQ);
1584 // eMule FIXME: We don't know which kadversion the buddy has, so we need to send unencrypted
1585 theApp->clientudp->SendPacket(packet, GetBuddyIP(), GetBuddyPort(), false, NULL, true, 0);
1586 AddDebugLogLineN(logClientKadUDP, CFormat(wxT("KadCallbackReq (size=%i) to %s")) % packet->GetPacketSize() % Uint32_16toStringIP_Port(GetBuddyIP(), GetBuddyPort()));
1587 theStats::AddUpOverheadKad(packet->GetRealPacketSize());
1588 SetDownloadState(DS_WAITCALLBACKKAD);
1589 } else {
1590 AddLogLineN(_("Searching buddy for lowid connection"));
1591 //Create search to find buddy.
1592 Kademlia::CSearch *findSource = new Kademlia::CSearch;
1593 findSource->SetSearchTypes(Kademlia::CSearch::FINDSOURCE);
1594 findSource->SetTargetID(Kademlia::CUInt128(GetBuddyID()));
1595 findSource->AddFileID(Kademlia::CUInt128(m_reqfile->GetFileHash().GetHash()));
1596 if(Kademlia::CSearchManager::StartSearch(findSource)) {
1597 //Started lookup..
1598 SetDownloadState(DS_WAITCALLBACKKAD);
1599 } else {
1600 //This should never happen..
1601 wxFAIL;
1602 }
1603 }
1604 }
1605 } else {
1606 if (GetDownloadState() == DS_WAITCALLBACK) {
1607 m_bReaskPending = true;
1608 SetDownloadState(DS_ONQUEUE);
1609 }
1610 }
1611 }
1612 } else { // HIGHID
1613 if (!Connect()) {
1614 return false;
1615 }
1616 }
1617 return true;
1618 }
1619
1620 bool CUpDownClient::Connect()
1621 {
1622 m_hasbeenobfuscatinglately = false;
1623
1624 if (!m_socket->IsOk()) {
1625 // Enable or disable crypting based on our and the remote clients preference
1626 if (HasValidHash() && SupportsCryptLayer() && thePrefs::IsClientCryptLayerSupported() && (RequestsCryptLayer() || thePrefs::IsClientCryptLayerRequested())){
1627 m_socket->SetConnectionEncryption(true, GetUserHash().GetHash(), false);
1628 } else {
1629 m_socket->SetConnectionEncryption(false, NULL, false);
1630 }
1631 amuleIPV4Address tmp;
1632 tmp.Hostname(GetConnectIP());
1633 tmp.Service(GetUserPort());
1634 AddDebugLogLineN(logClient, wxT("Trying to connect to ") + Uint32_16toStringIP_Port(GetConnectIP(),GetUserPort()));
1635 m_socket->Connect(tmp, false);
1636 // We should send hello packets AFTER connecting!
1637 // so I moved it to OnConnect
1638 return true;
1639 } else {
1640 return false;
1641 }
1642 }
1643
1644 void CUpDownClient::ConnectionEstablished()
1645 {
1646 /* Kry - First thing, check if this client was just used to retrieve
1647 info. That's some debug thing for myself... check connection_reason
1648 definition */
1649
1650 m_hasbeenobfuscatinglately = (m_socket && m_socket->IsConnected() && m_socket->IsObfusicating());
1651
1652 #ifdef __DEBUG__
1653 if (!connection_reason.IsEmpty()) {
1654 AddLogLineN(CFormat(wxT("Got client info checking for %s: %s\nDisconnecting and deleting.")) % connection_reason % GetClientFullInfo());
1655 connection_reason.Clear(); // So we don't re-print on destructor.
1656 Safe_Delete();
1657 return;
1658 }
1659 #endif
1660
1661 // Check if we should use this client to retrieve our public IP
1662 // Ignore local ip on GetPublicIP (could be wrong)
1663 if (theApp->GetPublicIP(true) == 0 && theApp->IsConnectedED2K()) {
1664 SendPublicIPRequest();
1665 }
1666
1667 // was this a direct callback?
1668 if (m_dwDirectCallbackTimeout != 0){
1669 theApp->clientlist->RemoveDirectCallback(this);
1670 m_dwDirectCallbackTimeout = 0;
1671 AddDebugLogLineN(logClient, wxT("Direct Callback succeeded, connection established to ") + Uint32toStringIP(GetConnectIP()));
1672 }
1673
1674 switch (GetKadState()) {
1675 case KS_CONNECTING_FWCHECK:
1676 SetKadState(KS_CONNECTED_FWCHECK);
1677 break;
1678 case KS_CONNECTING_BUDDY:
1679 case KS_INCOMING_BUDDY:
1680 SetKadState(KS_CONNECTED_BUDDY);
1681 break;
1682 case KS_CONNECTING_FWCHECK_UDP:
1683 SetKadState(KS_FWCHECK_UDP);
1684 SendFirewallCheckUDPRequest();
1685 break;
1686 default:
1687 break;
1688 }
1689
1690 // ok we have a connection, lets see if we want anything from this client
1691 if (GetChatState() == MS_CONNECTING) {
1692 SetChatState( MS_CHATTING );
1693 }
1694
1695 if (GetChatState() == MS_CHATTING) {
1696 bool result = true;
1697 if (!m_pendingMessage.IsEmpty()) {
1698 result = SendChatMessage(m_pendingMessage);
1699 }
1700 Notify_ChatConnResult(result,GUI_ID(GetIP(),GetUserPort()),m_pendingMessage);
1701 m_pendingMessage.Clear();
1702 }
1703
1704 switch(GetDownloadState()) {
1705 case DS_CONNECTING:
1706 case DS_WAITCALLBACK:
1707 case DS_WAITCALLBACKKAD:
1708 m_bReaskPending = false;
1709 SetDownloadState(DS_CONNECTED);
1710 SendFileRequest();
1711 }
1712 if (m_bReaskPending){
1713 m_bReaskPending = false;
1714 if (GetDownloadState() != DS_NONE && GetDownloadState() != DS_DOWNLOADING) {
1715 SetDownloadState(DS_CONNECTED);
1716 SendFileRequest();
1717 }
1718 }
1719 switch(GetUploadState()){
1720 case US_CONNECTING:
1721 case US_WAITCALLBACK:
1722 if (theApp->uploadqueue->IsDownloading(this)) {
1723 SetUploadState(US_UPLOADING);
1724 CPacket* packet = new CPacket(OP_ACCEPTUPLOADREQ, 0, OP_EDONKEYPROT);
1725 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
1726 SendPacket(packet,true);
1727 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ACCEPTUPLOADREQ to ") + GetFullIP() );
1728 }
1729 }
1730 if (m_iFileListRequested == 1) {
1731 CPacket* packet = new CPacket(m_fSharedDirectories ? OP_ASKSHAREDDIRS : OP_ASKSHAREDFILES, 0, OP_EDONKEYPROT);
1732 theStats::AddUpOverheadOther(packet->GetPacketSize());
1733 SendPacket(packet,true,true);
1734 if (m_fSharedDirectories) {
1735 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ASKSHAREDDIRS to ") + GetFullIP() );
1736 } else {
1737 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_ASKSHAREDFILES to ") + GetFullIP() );
1738 }
1739 }
1740
1741 while (!m_WaitingPackets_list.empty()) {
1742 CPacket* packet = m_WaitingPackets_list.front();
1743 m_WaitingPackets_list.pop_front();
1744
1745 SendPacket(packet);
1746 }
1747 }
1748
1749
1750 int CUpDownClient::GetHashType() const
1751 {
1752 if ( m_UserHash[5] == 13 && m_UserHash[14] == 110 ) {
1753 return SO_OLDEMULE;
1754 }
1755
1756 if ( m_UserHash[5] == 14 && m_UserHash[14] == 111 ) {
1757 return SO_EMULE;
1758 }
1759
1760 if ( m_UserHash[5] == 'M' && m_UserHash[14] == 'L' ) {
1761 return SO_MLDONKEY;
1762 }
1763
1764 return SO_UNKNOWN;
1765 }
1766
1767
1768 void CUpDownClient::SetSocket(CClientTCPSocket* socket)
1769 {
1770 #if defined(__DEBUG__)
1771 if (m_socket == NULL && socket != NULL) {
1772 theStats::SocketAssignedToClient();
1773 } else if (m_socket != NULL && socket == NULL) {
1774 theStats::SocketUnassignedFromClient();
1775 }
1776 #endif
1777 m_socket = socket;
1778 }
1779
1780
1781 void CUpDownClient::ReGetClientSoft()
1782 {
1783 if (m_Username.IsEmpty()) {
1784 m_clientSoft=SO_UNKNOWN;
1785 m_clientVerString = m_clientSoftString = m_clientVersionString = m_fullClientVerString = _("Unknown");
1786 UpdateStats();
1787 return;
1788 }
1789
1790 int iHashType = GetHashType();
1791 wxString clientModString;
1792 if (iHashType == SO_EMULE) {
1793
1794 m_clientSoft = m_byCompatibleClient;
1795 m_clientSoftString = GetSoftName(m_clientSoft);
1796 // Special issues:
1797 if(!GetClientModString().IsEmpty() && (m_clientSoft != SO_EMULE)) {
1798 m_clientSoftString = GetClientModString();
1799 }
1800 // Isn't xMule annoying?
1801 if ((m_clientSoft == SO_LXMULE) && (GetMuleVersion() > 0x26) && (GetMuleVersion() != 0x99)) {
1802 m_clientSoftString += CFormat(_(" (Fake eMule version %#x)")) % GetMuleVersion();
1803 }
1804 if ((m_clientSoft == SO_EMULE) &&
1805 (
1806 wxString(GetClientModString()).MakeLower().Find(wxT("xmule")) != -1
1807 || GetUserName().Find(wxT("xmule.")) != -1
1808 )
1809 ) {
1810 // FAKE eMule -a newer xMule faking is ident.
1811 m_clientSoft = SO_LXMULE;
1812 if (GetClientModString().IsEmpty() == false) {
1813 m_clientSoftString = GetClientModString() + _(" (Fake eMule)");
1814 } else {
1815 m_clientSoftString = _("xMule (Fake eMule)"); // don't use GetSoftName, it's not lmule.
1816 }
1817 }
1818 // Now, what if we don't know this SO_ID?
1819 if (m_clientSoftString.IsEmpty()) {
1820 if(m_bIsML) {
1821 m_clientSoft = SO_MLDONKEY;
1822 m_clientSoftString = GetSoftName(m_clientSoft);
1823 } else if (m_bIsHybrid) {
1824 m_clientSoft = SO_EDONKEYHYBRID;
1825 m_clientSoftString = GetSoftName(m_clientSoft);
1826 } else if (m_byCompatibleClient != 0) {
1827 m_clientSoft = SO_COMPAT_UNK;
1828 #ifdef __DEBUG__
1829 if (
1830 // Exceptions:
1831 (m_byCompatibleClient != 0xf0) // Chinese leech mod
1832 && (1==1) // Your ad here
1833 ) {
1834 AddLogLineNS(CFormat(wxT("Compatible client found with ET_COMPATIBLECLIENT of %x")) % m_byCompatibleClient);
1835 }
1836 #endif
1837 m_clientSoftString = CFormat(wxT("%s(%#x)")) % GetSoftName(m_clientSoft) % m_byCompatibleClient;
1838 } else {
1839 // If we step here, it might mean 2 things:
1840 // a eMule
1841 // a Compat Client that has sent no MuleInfo packet yet.
1842 m_clientSoft = SO_EMULE;
1843 m_clientSoftString = wxT("eMule");
1844 }
1845 }
1846
1847 if (m_byEmuleVersion == 0) {
1848 m_nClientVersion = MAKE_CLIENT_VERSION(0,0,0);
1849 } else if (m_byEmuleVersion != 0x99) {
1850 uint32 nClientMinVersion = (m_byEmuleVersion >> 4)*10 + (m_byEmuleVersion & 0x0f);
1851 m_nClientVersion = MAKE_CLIENT_VERSION(0,nClientMinVersion,0);
1852 switch (m_clientSoft) {
1853 case SO_AMULE:
1854 m_clientVerString = CFormat(_("1.x (based on eMule v0.%u)")) % nClientMinVersion;
1855 break;
1856 case SO_LPHANT:
1857 m_clientVerString = wxT("< v0.05");
1858 break;
1859 default:
1860 clientModString = GetClientModString();
1861 m_clientVerString = CFormat(wxT("v0.%u")) % nClientMinVersion;
1862 break;
1863 }
1864 } else {
1865 uint32 nClientMajVersion = (m_nClientVersion >> 17) & 0x7f;
1866 uint32 nClientMinVersion = (m_nClientVersion >> 10) & 0x7f;
1867 uint32 nClientUpVersion = (m_nClientVersion >> 7) & 0x07;
1868
1869 m_nClientVersion = MAKE_CLIENT_VERSION(nClientMajVersion, nClientMinVersion, nClientUpVersion);
1870
1871 switch (m_clientSoft) {
1872 case SO_AMULE:
1873 case SO_LXMULE:
1874 case SO_HYDRANODE:
1875 case SO_MLDONKEY:
1876 case SO_NEW_MLDONKEY:
1877 case SO_NEW2_MLDONKEY:
1878 // Kry - xMule started sending correct version tags on 1.9.1b.
1879 // It only took them 4 months, and being told by me and the
1880 // eMule+ developers, so I think they're slowly getting smarter.
1881 // They are based on our implementation, so we use the same format
1882 // for the version string.
1883 m_clientVerString = CFormat(wxT("v%u.%u.%u")) % nClientMajVersion % nClientMinVersion % nClientUpVersion;
1884 break;
1885 case SO_LPHANT:
1886 m_clientVerString = CFormat(wxT(" v%u.%.2u%c")) % (nClientMajVersion-1) % nClientMinVersion % ('a' + nClientUpVersion);
1887 break;
1888 case SO_EMULEPLUS:
1889 m_clientVerString = CFormat(wxT("v%u")) % nClientMajVersion;
1890 if(nClientMinVersion != 0) {
1891 m_clientVerString += CFormat(wxT(".%u")) % nClientMinVersion;
1892 }
1893 if(nClientUpVersion != 0) {
1894 m_clientVerString += CFormat(wxT("%c")) % ('a' + nClientUpVersion - 1);
1895 }
1896 break;
1897 default:
1898 clientModString = GetClientModString();
1899 m_clientVerString = CFormat(wxT("v%u.%u%c")) % nClientMajVersion % nClientMinVersion % ('a' + nClientUpVersion);
1900 break;
1901 }
1902 }
1903 } else if (m_bIsHybrid) {
1904 // seen:
1905 // 105010 50.10
1906 // 10501 50.1
1907 // 1051 51.0
1908 // 501 50.1
1909
1910 m_clientSoft = SO_EDONKEYHYBRID;
1911 m_clientSoftString = GetSoftName(m_clientSoft);
1912
1913 uint32 nClientMajVersion;
1914 uint32 nClientMinVersion;
1915 uint32 nClientUpVersion;
1916 if (m_nClientVersion > 100000) {
1917 uint32 uMaj = m_nClientVersion/100000;
1918 nClientMajVersion = uMaj - 1;
1919 nClientMinVersion = (m_nClientVersion - uMaj*100000) / 100;
1920 nClientUpVersion = m_nClientVersion % 100;
1921 }
1922 else if (m_nClientVersion > 10000) {
1923 uint32 uMaj = m_nClientVersion/10000;
1924 nClientMajVersion = uMaj - 1;
1925 nClientMinVersion = (m_nClientVersion - uMaj*10000) / 10;
1926 nClientUpVersion = m_nClientVersion % 10;
1927 }
1928 else if (m_nClientVersion > 1000) {
1929 uint32 uMaj = m_nClientVersion/1000;
1930 nClientMajVersion = uMaj - 1;
1931 nClientMinVersion = m_nClientVersion - uMaj*1000;
1932 nClientUpVersion = 0;
1933 }
1934 else if (m_nClientVersion > 100) {
1935 uint32 uMin = m_nClientVersion/10;
1936 nClientMajVersion = 0;
1937 nClientMinVersion = uMin;
1938 nClientUpVersion = m_nClientVersion - uMin*10;
1939 }
1940 else{
1941 nClientMajVersion = 0;
1942 nClientMinVersion = m_nClientVersion;
1943 nClientUpVersion = 0;
1944 }
1945 m_nClientVersion = MAKE_CLIENT_VERSION(nClientMajVersion, nClientMinVersion, nClientUpVersion);
1946 if (nClientUpVersion) {
1947 m_clientVerString = CFormat(wxT("v%u.%u.%u")) % nClientMajVersion % nClientMinVersion % nClientUpVersion;
1948 } else {
1949 m_clientVerString = CFormat(wxT("v%u.%u")) % nClientMajVersion % nClientMinVersion;
1950 }
1951 } else if (m_bIsML || (iHashType == SO_MLDONKEY)) {
1952 m_clientSoft = SO_MLDONKEY;
1953 m_clientSoftString = GetSoftName(m_clientSoft);
1954 uint32 nClientMinVersion = m_nClientVersion;
1955 m_nClientVersion = MAKE_CLIENT_VERSION(0, nClientMinVersion, 0);
1956 m_clientVerString = CFormat(wxT("v0.%u")) % nClientMinVersion;
1957 } else if (iHashType == SO_OLDEMULE) {
1958 m_clientSoft = SO_OLDEMULE;
1959 m_clientSoftString = GetSoftName(m_clientSoft);
1960 uint32 nClientMinVersion = m_nClientVersion;
1961 m_nClientVersion = MAKE_CLIENT_VERSION(0, nClientMinVersion, 0);
1962 m_clientVerString = CFormat(wxT("v0.%u")) % nClientMinVersion;
1963 } else {
1964 m_clientSoft = SO_EDONKEY;
1965 m_clientSoftString = GetSoftName(m_clientSoft);
1966 m_nClientVersion *= 10;
1967 m_clientVerString = CFormat(wxT("v%u.%u")) % (m_nClientVersion / 100000) % ((m_nClientVersion / 1000) % 100);
1968 }
1969
1970 m_clientVersionString = m_clientVerString;
1971 if (!clientModString.IsEmpty()) {
1972 m_clientVerString += wxT(" - ") + clientModString;
1973 }
1974 m_fullClientVerString = m_clientSoftString + wxT(" ") + m_clientVerString;
1975
1976 UpdateStats();
1977 }
1978
1979 void CUpDownClient::RequestSharedFileList()
1980 {
1981 if (m_iFileListRequested == 0) {
1982 AddDebugLogLineN( logClient, wxString( wxT("Requesting shared files from ") ) + GetUserName() );
1983 m_iFileListRequested = 1;
1984 TryToConnect(true);
1985 } else {
1986 AddDebugLogLineN( logClient, CFormat( wxT("Requesting shared files from user %s (%u) is already in progress") ) % GetUserName() % GetUserIDHybrid() );
1987 }
1988 }
1989
1990
1991 void CUpDownClient::ProcessSharedFileList(const byte* pachPacket, uint32 nSize, wxString& pszDirectory)
1992 {
1993 if (m_iFileListRequested > 0) {
1994 m_iFileListRequested--;
1995 theApp->searchlist->ProcessSharedFileList(pachPacket, nSize, this, NULL, pszDirectory);
1996 }
1997 }
1998
1999
2000 void CUpDownClient::ResetFileStatusInfo()
2001 {
2002 m_nPartCount = 0;
2003
2004 if ( m_reqfile ) {
2005 m_reqfile->UpdatePartsFrequency( this, false );
2006 }
2007 m_downPartStatus.clear();
2008
2009 m_clientFilename.Clear();
2010
2011 m_bCompleteSource = false;
2012 m_dwLastAskedTime = 0;
2013 m_iRating = 0;
2014 m_strComment.Clear();
2015
2016 if (m_pReqFileAICHHash != NULL) {
2017 delete m_pReqFileAICHHash;
2018 m_pReqFileAICHHash = NULL;
2019 }
2020
2021 }
2022
2023 wxString CUpDownClient::GetUploadFileInfo()
2024 {
2025 // build info text and display it
2026 wxString sRet;
2027 sRet = (CFormat(_("NickName: %s ID: %u")) % GetUserName() % GetUserIDHybrid()) + wxT(" ");
2028 if (m_reqfile) {
2029 sRet += CFormat(_("Requested: %s\n")) % m_reqfile->GetFileName();
2030 sRet += CFormat(
2031 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())
2032 ) % m_reqfile->statistic.GetAccepts() % m_reqfile->statistic.GetRequests() % CastItoXBytes(m_reqfile->statistic.GetTransferred());
2033 sRet += CFormat(
2034 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())
2035 ) % m_reqfile->statistic.GetAllTimeAccepts() % m_reqfile->statistic.GetAllTimeRequests() % CastItoXBytes(m_reqfile->statistic.GetAllTimeTransferred());
2036 } else {
2037 sRet += _("Requested unknown file");
2038 }
2039 return sRet;
2040 }
2041
2042 // sends a packet, if needed it will establish a connection before
2043 // options used: ignore max connections, control packet, delete packet
2044 // !if the functions returns false it is _possible_ that this clientobject was deleted, because the connectiontry fails
2045 bool CUpDownClient::SafeSendPacket(CPacket* packet)
2046 {
2047 if (IsConnected()) {
2048 SendPacket(packet, true);
2049 return true;
2050 } else {
2051 m_WaitingPackets_list.push_back(packet);
2052 return TryToConnect(true);
2053 }
2054 }
2055
2056 void CUpDownClient::SendPublicKeyPacket(){
2057 // send our public key to the client who requested it
2058 if (m_socket == NULL || credits == NULL || m_SecureIdentState != IS_KEYANDSIGNEEDED){
2059 wxFAIL;
2060 return;
2061 }
2062 if (!theApp->CryptoAvailable())
2063 return;
2064
2065 CMemFile data;
2066 data.WriteUInt8(theApp->clientcredits->GetPubKeyLen());
2067 data.Write(theApp->clientcredits->GetPublicKey(), theApp->clientcredits->GetPubKeyLen());
2068 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_PUBLICKEY);
2069
2070 theStats::AddUpOverheadOther(packet->GetPacketSize());
2071 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_PUBLICKEY to ") + GetFullIP() );
2072 SendPacket(packet,true,true);
2073 m_SecureIdentState = IS_SIGNATURENEEDED;
2074 }
2075
2076
2077 void CUpDownClient::SendSignaturePacket(){
2078 // signate the public key of this client and send it
2079 if (m_socket == NULL || credits == NULL || m_SecureIdentState == 0){
2080 wxFAIL;
2081 return;
2082 }
2083
2084 if (!theApp->CryptoAvailable()) {
2085 return;
2086 }
2087 if (credits->GetSecIDKeyLen() == 0) {
2088 return; // We don't have his public key yet, will be back here later
2089 }
2090 // do we have a challenge value received (actually we should if we are in this function)
2091 if (credits->m_dwCryptRndChallengeFrom == 0){
2092 AddDebugLogLineN( logClient, wxString(wxT("Want to send signature but challenge value is invalid - User ")) + GetUserName());
2093 return;
2094 }
2095 // v2
2096 // we will use v1 as default, except if only v2 is supported
2097 bool bUseV2;
2098 if ( (m_bySupportSecIdent&1) == 1 )
2099 bUseV2 = false;
2100 else
2101 bUseV2 = true;
2102
2103 uint8 byChaIPKind = 0;
2104 uint32 ChallengeIP = 0;
2105 if (bUseV2){
2106 if (::IsLowID(theApp->GetED2KID())) {
2107 // we cannot do not know for sure our public ip, so use the remote clients one
2108 ChallengeIP = GetIP();
2109 byChaIPKind = CRYPT_CIP_REMOTECLIENT;
2110 } else {
2111 ChallengeIP = theApp->GetED2KID();
2112 byChaIPKind = CRYPT_CIP_LOCALCLIENT;
2113 }
2114 }
2115 //end v2
2116 byte achBuffer[250];
2117
2118 uint8 siglen = theApp->clientcredits->CreateSignature(credits, achBuffer, 250, ChallengeIP, byChaIPKind );
2119 if (siglen == 0){
2120 wxFAIL;
2121 return;
2122 }
2123 CMemFile data;
2124 data.WriteUInt8(siglen);
2125 data.Write(achBuffer, siglen);
2126 if (bUseV2) {
2127 data.WriteUInt8(byChaIPKind);
2128 }
2129
2130 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_SIGNATURE);
2131
2132 theStats::AddUpOverheadOther(packet->GetPacketSize());
2133 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_SIGNATURE to ") + GetFullIP() );
2134 SendPacket(packet,true,true);
2135 m_SecureIdentState = IS_ALLREQUESTSSEND;
2136 }
2137
2138
2139 void CUpDownClient::ProcessPublicKeyPacket(const byte* pachPacket, uint32 nSize)
2140 {
2141 theApp->clientlist->AddTrackClient(this);
2142
2143 if (m_socket == NULL || credits == NULL || pachPacket[0] != nSize-1
2144 || nSize == 0 || nSize > 250){
2145 wxFAIL;
2146 return;
2147 }
2148 if (!theApp->CryptoAvailable())
2149 return;
2150 // the function will handle everything (mulitple key etc)
2151 if (credits->SetSecureIdent(pachPacket+1, pachPacket[0])){
2152 // if this client wants a signature, now we can send him one
2153 if (m_SecureIdentState == IS_SIGNATURENEEDED){
2154 SendSignaturePacket();
2155 }
2156 else if (m_SecureIdentState == IS_KEYANDSIGNEEDED) {
2157 // something is wrong
2158 AddDebugLogLineN( logClient, wxT("Invalid State error: IS_KEYANDSIGNEEDED in ProcessPublicKeyPacket") );
2159 }
2160 } else {
2161 AddDebugLogLineN( logClient, wxT("Failed to use new received public key") );
2162 }
2163 }
2164
2165
2166 void CUpDownClient::ProcessSignaturePacket(const byte* pachPacket, uint32 nSize)
2167 {
2168 // here we spread the good guys from the bad ones ;)
2169
2170 if (m_socket == NULL || credits == NULL || nSize == 0 || nSize > 250){
2171 wxFAIL;
2172 return;
2173 }
2174
2175 uint8 byChaIPKind;
2176 if (pachPacket[0] == nSize-1)
2177 byChaIPKind = 0;
2178 else if (pachPacket[0] == nSize-2 && (m_bySupportSecIdent & 2) > 0) //v2
2179 byChaIPKind = pachPacket[nSize-1];
2180 else{
2181 wxFAIL;
2182 return;
2183 }
2184
2185 if (!theApp->CryptoAvailable())
2186 return;
2187
2188 // we accept only one signature per IP, to avoid floods which need a lot cpu time for cryptfunctions
2189 if (m_dwLastSignatureIP == GetIP()){
2190 AddDebugLogLineN( logClient, wxT("received multiple signatures from one client") );
2191 return;
2192 }
2193 // also make sure this client has a public key
2194 if (credits->GetSecIDKeyLen() == 0){
2195 AddDebugLogLineN( logClient, wxT("received signature for client without public key") );
2196 return;
2197 }
2198 // and one more check: did we ask for a signature and sent a challange packet?
2199 if (credits->m_dwCryptRndChallengeFor == 0){
2200 AddDebugLogLineN( logClient, wxT("received signature for client with invalid challenge value - User ") + GetUserName() );
2201 return;
2202 }
2203
2204 if (theApp->clientcredits->VerifyIdent(credits, pachPacket+1, pachPacket[0], GetIP(), byChaIPKind ) ) {
2205 // result is saved in function above
2206 AddDebugLogLineN( logClient, CFormat( wxT("'%s' has passed the secure identification, V2 State: %i") ) % GetUserName() % byChaIPKind );
2207 } else {
2208 AddDebugLogLineN( logClient, CFormat( wxT("'%s' has failed the secure identification, V2 State: %i") ) % GetUserName() % byChaIPKind );
2209 }
2210
2211 m_dwLastSignatureIP = GetIP();
2212 }
2213
2214 void CUpDownClient::SendSecIdentStatePacket(){
2215 // check if we need public key and signature
2216 uint8 nValue = 0;
2217 if (credits){
2218 if (theApp->CryptoAvailable()){
2219 if (credits->GetSecIDKeyLen() == 0) {
2220 nValue = IS_KEYANDSIGNEEDED;
2221 } else if (m_dwLastSignatureIP != GetIP()) {
2222 nValue = IS_SIGNATURENEEDED;
2223 }
2224 }
2225 if (nValue == 0){
2226 AddDebugLogLineN( logClient, wxT("Not sending SecIdentState Packet, because State is Zero") );
2227 return;
2228 }
2229 // crypt: send random data to sign
2230 uint32 dwRandom = rand()+1;
2231 credits->m_dwCryptRndChallengeFor = dwRandom;
2232
2233 CMemFile data;
2234 data.WriteUInt8(nValue);
2235 data.WriteUInt32(dwRandom);
2236 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_SECIDENTSTATE);
2237
2238 theStats::AddUpOverheadOther(packet->GetPacketSize());
2239 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_SECIDENTSTATE to ") + GetFullIP() );
2240 SendPacket(packet,true,true);
2241 } else {
2242 wxFAIL;
2243 }
2244 }
2245
2246
2247 void CUpDownClient::ProcessSecIdentStatePacket(const byte* pachPacket, uint32 nSize)
2248 {
2249 if ( nSize != 5 ) {
2250 return;
2251 }
2252
2253 if ( !credits ) {
2254 wxASSERT( credits );
2255 return;
2256 }
2257
2258 CMemFile data(pachPacket,nSize);
2259
2260 switch ( data.ReadUInt8() ) {
2261 case 0:
2262 m_SecureIdentState = IS_UNAVAILABLE;
2263 break;
2264 case 1:
2265 m_SecureIdentState = IS_SIGNATURENEEDED;
2266 break;
2267 case 2:
2268 m_SecureIdentState = IS_KEYANDSIGNEEDED;
2269 break;
2270 default:
2271 return;
2272 }
2273
2274 credits->m_dwCryptRndChallengeFrom = data.ReadUInt32();
2275 }
2276
2277
2278 void CUpDownClient::InfoPacketsReceived()
2279 {
2280 // indicates that both Information Packets has been received
2281 // needed for actions, which process data from both packets
2282 wxASSERT ( m_byInfopacketsReceived == IP_BOTH );
2283 m_byInfopacketsReceived = IP_NONE;
2284
2285 if (m_bySupportSecIdent){
2286 SendSecIdentStatePacket();
2287 }
2288 }
2289
2290
2291 bool CUpDownClient::CheckHandshakeFinished() const
2292 {
2293 if (m_bHelloAnswerPending) {
2294 // this triggers way too often.. need more time to look at this -> only create a warning
2295 // The reason for this is that 2 clients are connecting to each other at the same time..
2296 AddDebugLogLineN( logClient, wxT("Handshake not finished while processing packet.") );
2297 return false;
2298 }
2299
2300 return true;
2301 }
2302
2303
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
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 = wxEmptyString;
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 = wxEmptyString;
2765 m_strCaptchaPendingMsg = wxEmptyString;
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
2839 void CUpDownClient::SendFirewallCheckUDPRequest()
2840 {
2841 wxASSERT(GetKadState() == KS_FWCHECK_UDP);
2842
2843 if (!Kademlia::CKademlia::IsRunning()) {
2844 SetKadState(KS_NONE);
2845 return;
2846 } else if (GetUploadState() != US_NONE || GetDownloadState() != DS_NONE || GetChatState() != MS_NONE || GetKadVersion() <= 5 || GetKadPort() == 0) {
2847 Kademlia::CUDPFirewallTester::SetUDPFWCheckResult(false, true, wxUINT32_SWAP_ALWAYS(GetIP()), 0); // inform the tester that this test was cancelled
2848 SetKadState(KS_NONE);
2849 return;
2850 }
2851
2852 CMemFile data;
2853 data.WriteUInt16(Kademlia::CKademlia::GetPrefs()->GetInternKadPort());
2854 data.WriteUInt16(Kademlia::CKademlia::GetPrefs()->GetExternalKadPort());
2855 data.WriteUInt32(Kademlia::CKademlia::GetPrefs()->GetUDPVerifyKey(GetConnectIP()));
2856 CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_FWCHECKUDPREQ);
2857 theStats::AddUpOverheadKad(packet->GetPacketSize());
2858 SafeSendPacket(packet);
2859 }
2860
2861 void CUpDownClient::ProcessFirewallCheckUDPRequest(CMemFile* data)
2862 {
2863 if (!Kademlia::CKademlia::IsRunning() || Kademlia::CKademlia::GetUDPListener() == NULL) {
2864 //DebugLogWarning(_T("Ignored Kad Firewallrequest UDP because Kad is not running (%s)"), GetClientFullInfo());
2865 return;
2866 }
2867
2868 // first search if we know this IP already, if so the result might be biased and we need tell the requester
2869 bool errorAlreadyKnown = false;
2870 if (GetUploadState() != US_NONE || GetDownloadState() != DS_NONE || GetChatState() != MS_NONE) {
2871 errorAlreadyKnown = true;
2872 } else if (Kademlia::CKademlia::GetRoutingZone()->GetContact(wxUINT32_SWAP_ALWAYS(GetConnectIP()), 0, false) != NULL) {
2873 errorAlreadyKnown = true;
2874 }
2875
2876 uint16_t remoteInternPort = data->ReadUInt16();
2877 uint16_t remoteExternPort = data->ReadUInt16();
2878 uint32_t senderKey = data->ReadUInt32();
2879 if (remoteInternPort == 0) {
2880 //DebugLogError(_T("UDP Firewallcheck requested with Intern Port == 0 (%s)"), GetClientFullInfo());
2881 return;
2882 }
2883 // if (senderKey == 0)
2884 // DebugLogWarning(_T("UDP Firewallcheck requested with SenderKey == 0 (%s)"), GetClientFullInfo());
2885
2886 CMemFile testPacket1;
2887 testPacket1.WriteUInt8(errorAlreadyKnown ? 1 : 0);
2888 testPacket1.WriteUInt16(remoteInternPort);
2889 DebugSend(Kad2FirewallUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteInternPort);
2890 Kademlia::CKademlia::GetUDPListener()->SendPacket(testPacket1, KADEMLIA2_FIREWALLUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteInternPort, Kademlia::CKadUDPKey(senderKey, theApp->GetPublicIP(false)), NULL);
2891
2892 // if the client has a router with PAT (and therefore a different extern port than intern), test this port too
2893 if (remoteExternPort != 0 && remoteExternPort != remoteInternPort) {
2894 CMemFile testPacket2;
2895 testPacket2.WriteUInt8(errorAlreadyKnown ? 1 : 0);
2896 testPacket2.WriteUInt16(remoteExternPort);
2897 DebugSend(Kad2FirewalledUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteExternPort);
2898 Kademlia::CKademlia::GetUDPListener()->SendPacket(testPacket2, KADEMLIA2_FIREWALLUDP, wxUINT32_SWAP_ALWAYS(GetConnectIP()), remoteExternPort, Kademlia::CKadUDPKey(senderKey, theApp->GetPublicIP(false)), NULL);
2899 }
2900 //DebugLog(_T("Answered UDP Firewallcheck request (%s)"), GetClientFullInfo());
2901 }
2902
2903 void CUpDownClient::SetConnectOptions(uint8_t options, bool encryption, bool callback)
2904 {
2905 SetCryptLayerSupport((options & 0x01) != 0 && encryption);
2906 SetCryptLayerRequest((options & 0x02) != 0 && encryption);
2907 SetCryptLayerRequires((options & 0x04) != 0 && encryption);
2908 SetDirectUDPCallbackSupport((options & 0x08) != 0 && callback);
2909 }
2910
2911
2912 #ifdef DEBUG_ZOMBIE_CLIENTS
2913 void CUpDownClient::Unlink(const wxString& from)
2914 {
2915 std::multiset<wxString>::iterator it = m_linkedFrom.find(from);
2916 if (it != m_linkedFrom.end()) {
2917 m_linkedFrom.erase(it);
2918 }
2919 m_linked--;
2920 if (!m_linked) {
2921 if (m_linkedDebug) {
2922 AddLogLineN(CFormat(wxT("Last reference to client %d %p unlinked, delete it.")) % ECID() % this);
2923 }
2924 delete this;
2925 }
2926 }
2927
2928 #else
2929
2930 void CUpDownClient::Unlink()
2931 {
2932 m_linked--;
2933 if (!m_linked) {
2934 delete this;
2935 }
2936 }
2937 #endif
2938
2939
2940 // File_checked_for_headers
aMule P2P client