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