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