src/kademlia/net/KademliaUDPListener.cpp

   1 //
   2 // This file is part of aMule Project
   3 //
   4 // Copyright (c) 2004-2008 Angel Vidal (Kry) ( kry@amule.org )
   5 // Copyright (c) 2004-2008 aMule Project ( http://www.amule-project.net )
   6 // Copyright (C)2003 Barry Dunne (http://www.emule-project.net)
   7
   8 // This program is free software; you can redistribute it and/or
   9 // modify it under the terms of the GNU General Public License
  10 // as published by the Free Software Foundation; either
  11 // version 2 of the License, or (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  21
  22 // Note To Mods //
  23 /*
  24 Please do not change anything here and release it..
  25 There is going to be a new forum created just for the Kademlia side of the client..
  26 If you feel there is an error or a way to improve something, please
  27 post it in the forum first and let us look at it.. If it is a real improvement,
  28 it will be added to the offical client.. Changing something without knowing
  29 what all it does can cause great harm to the network if released in mass form..
  30 Any mod that changes anything within the Kademlia side will not be allowed to advertise
  31 there client on the eMule forum..
  32 */
  33
  34 #include <wx/wx.h>
  35
  36 #include "KademliaUDPListener.h"
  37
  38 #include <protocol/Protocols.h>
  39 #include <protocol/kad/Constants.h>
  40 #include <protocol/kad/Client2Client/UDP.h>
  41 #include <protocol/ed2k/Client2Client/TCP.h> // OP_CALLBACK is sent in some cases.
  42 #include <common/Macros.h>
  43 #include <common/Format.h>
  44 #include <tags/FileTags.h>
  45
  46 #include "../routing/Contact.h"
  47 #include "../routing/RoutingZone.h"
  48 #include "../kademlia/Indexed.h"
  49 #include "../kademlia/Defines.h"
  50 #include "../../amule.h"
  51 #include "../../ClientUDPSocket.h"
  52 #include "../../Packet.h"
  53 #include "../../ClientList.h"
  54 #include "../../Statistics.h"
  55 #include "../../MemFile.h"
  56 #include "../../updownclient.h"
  57 #include "../../ClientTCPSocket.h"
  58 #include "../../Logger.h"
  59 #include "../../Preferences.h"
  60 #include "../../ScopedPtr.h"
  61
  62 #include <wx/tokenzr.h>
  63
  64 #define THIS_DEBUG_IS_JUST_FOR_KRY_DONT_TOUCH_IT_KTHX 0
  65
  66 extern wxChar* InvKadKeywordChars;
  67
  68 ////////////////////////////////////////
  69 using namespace Kademlia;
  70 ////////////////////////////////////////
  71
  72 void CKademliaUDPListener::Bootstrap(uint32 ip, uint16 port)
  73 {
  74         wxASSERT(ip);
  75         SendMyDetails(KADEMLIA_BOOTSTRAP_REQ, ip, port);
  76 }
  77
  78 void CKademliaUDPListener::SendMyDetails(byte opcode, uint32 ip, uint16 port)
  79 {
  80         CMemFile packetdata(25);
  81         packetdata.WriteUInt128(CKademlia::GetPrefs()->GetKadID());
  82         packetdata.WriteUInt32(CKademlia::GetPrefs()->GetIPAddress());
  83         packetdata.WriteUInt16(thePrefs::GetEffectiveUDPPort());
  84         packetdata.WriteUInt16(thePrefs::GetPort());
  85         packetdata.WriteUInt8(0);
  86         SendPacket(packetdata, opcode, ip, port);
  87 }
  88
  89 void CKademliaUDPListener::FirewalledCheck(uint32 ip, uint16 port)
  90 {
  91         CMemFile packetdata(2);
  92         packetdata.WriteUInt16(thePrefs::GetPort());
  93         SendPacket(packetdata, KADEMLIA_FIREWALLED_REQ, ip, port);
  94 }
  95
  96 void CKademliaUDPListener::SendNullPacket(byte opcode,uint32 ip, uint16 port)
  97 {
  98         CMemFile packetdata(0);
  99         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadNullPacket %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 100         SendPacket(packetdata, opcode, ip, port);
 101 }
 102
 103 void CKademliaUDPListener::PublishPacket(uint32 ip, uint16 port, const CUInt128 &targetID, const CUInt128 &contactID, const TagPtrList& tags)
 104 {
 105         CMemFile packetdata;
 106         packetdata.WriteUInt128(targetID);
 107         //We only use this for publishing sources now.. So we always send one here..
 108         packetdata.WriteUInt16(1);
 109         packetdata.WriteUInt128(contactID);
 110         packetdata.WriteTagPtrList(tags);
 111         SendPacket(packetdata, KADEMLIA_PUBLISH_REQ, ip, port);
 112 }
 113
 114 void CKademliaUDPListener::ProcessPacket(const byte* data, uint32 lenData, uint32 ip, uint16 port)
 115 {
 116         //Update connection state only when it changes.
 117         bool curCon = CKademlia::GetPrefs()->HasHadContact();
 118         CKademlia::GetPrefs()->SetLastContact();
 119         if( curCon != CKademlia::GetPrefs()->HasHadContact()) {
 120                 theApp->ShowConnectionState();
 121         }
 122
 123         byte opcode = data[1];
 124         const byte *packetData = data + 2;
 125         uint32 lenPacket = lenData - 2;
 126
 127         switch (opcode) {
 128                 case KADEMLIA_BOOTSTRAP_REQ:
 129                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadBootstrapReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 130                         ProcessBootstrapRequest(packetData, lenPacket, ip, port);
 131                         break;
 132                 case KADEMLIA_BOOTSTRAP_RES:
 133                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadBootstrapRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 134                         ProcessBootstrapResponse(packetData, lenPacket, ip, port);
 135                         break;
 136                 case KADEMLIA_HELLO_REQ:
 137                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadHelloReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 138                         ProcessHelloRequest(packetData, lenPacket, ip, port);
 139                         break;
 140                 case KADEMLIA_HELLO_RES:
 141                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadHelloRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 142                         ProcessHelloResponse(packetData, lenPacket, ip, port);
 143                         break;
 144                 case KADEMLIA_REQ:
 145                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 146                         ProcessKademliaRequest(packetData, lenPacket, ip, port);
 147                         break;
 148                 case KADEMLIA_RES:
 149                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 150                         ProcessKademliaResponse(packetData, lenPacket, ip, port);
 151                         break;
 152                 case KADEMLIA_SEARCH_REQ:
 153                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadSearchReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 154                         ProcessSearchRequest(packetData, lenPacket, ip, port);
 155                         break;
 156                 case KADEMLIA_SEARCH_RES:
 157                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadSearchRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 158                         ProcessSearchResponse(packetData, lenPacket, ip, port);
 159                         break;
 160                 case KADEMLIA_PUBLISH_REQ:
 161                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadPublishReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 162                         ProcessPublishRequest(packetData, lenPacket, ip, port);
 163                         break;
 164                 case KADEMLIA_PUBLISH_RES:
 165                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadPublishRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 166                         ProcessPublishResponse(packetData, lenPacket, ip, port);
 167                         break;
 168                 case KADEMLIA_SRC_NOTES_REQ:
 169                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadSearchNotesReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 170                         ProcessSearchNotesRequest(packetData, lenPacket, ip, port);
 171                         break;
 172                 case KADEMLIA_SRC_NOTES_RES:
 173                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadSearchNotesRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 174                         ProcessSearchNotesResponse(packetData, lenPacket, ip, port);
 175                         break;
 176                 case KADEMLIA_PUB_NOTES_REQ:
 177                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadPublishNotesReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 178                         ProcessPublishNotesRequest(packetData, lenPacket, ip, port);
 179                         break;
 180                 case KADEMLIA_PUB_NOTES_RES:
 181                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadPublishNotesRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 182                         ProcessPublishNotesResponse(packetData, lenPacket, ip, port);
 183                         break;
 184                 case KADEMLIA_FIREWALLED_REQ:
 185                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFirewalledReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 186                         ProcessFirewalledRequest(packetData, lenPacket, ip, port);
 187                         break;
 188                 case KADEMLIA_FIREWALLED_RES:
 189                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFirewalledRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 190                         ProcessFirewalledResponse(packetData, lenPacket, ip, port);
 191                         break;
 192                 case KADEMLIA_FIREWALLED_ACK:
 193                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFirewalledAck from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 194                         ProcessFirewalledResponse2(packetData, lenPacket, ip, port);
 195                         break;
 196                 case KADEMLIA_FINDBUDDY_REQ:
 197                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFindBuddyReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 198                         ProcessFindBuddyRequest(packetData, lenPacket, ip, port);
 199                         break;
 200                 case KADEMLIA_FINDBUDDY_RES:
 201                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFindBuddyRes from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 202                         ProcessFindBuddyResponse(packetData, lenPacket, ip, port);
 203                         break;
 204                 case KADEMLIA_CALLBACK_REQ:
 205                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadCallbackReq from %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 206                         ProcessCallbackRequest(packetData, lenPacket, ip, port);
 207                         break;
 208                 default: {
 209                         throw wxString::Format(wxT("Unknown opcode %02x on CKademliaUDPListener::processPacket"), opcode);
 210                 }
 211         }
 212 }
 213
 214 void CKademliaUDPListener::AddContact( const byte *data, uint32 lenData, uint32 ip, uint16 port, uint16 tport)
 215 {
 216         CMemFile bio((byte*)data, lenData);
 217         CUInt128 id = bio.ReadUInt128();
 218         bio.ReadUInt32();
 219         bio.ReadUInt16();
 220         if( tport ) {
 221                 bio.ReadUInt16();
 222         } else {
 223                 tport = bio.ReadUInt16();
 224         }
 225         byte type = bio.ReadUInt8();
 226         //AddDebugLogLineM(false, logKadMain, wxT("Adding a contact with ip ") + Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip),port));
 227         // Look for existing client
 228         CContact *contact = CKademlia::GetRoutingZone()->GetContact(id);
 229         if (contact != NULL) {
 230                 contact->SetIPAddress(ip);
 231                 contact->SetUDPPort(port);
 232                 contact->SetTCPPort(tport);
 233         } else {
 234                 if(IsGoodIPPort(wxUINT32_SWAP_ALWAYS(ip),port)) {
 235                         // Ignore stated ip and port, use the address the packet came from
 236                         CKademlia::GetRoutingZone()->Add(id, ip, port, tport, type);
 237                 }
 238         }
 239 }
 240
 241 void CKademliaUDPListener::AddContacts( const byte *data, uint32 lenData, uint16 numContacts)
 242 {
 243         CMemFile bio((byte*)data, lenData );
 244         CRoutingZone *routingZone = CKademlia::GetRoutingZone();
 245         for (uint16 i=0; i<numContacts; i++) {
 246                 CUInt128 id = bio.ReadUInt128();
 247                 uint32 ip = bio.ReadUInt32();
 248                 ip = wxUINT32_SWAP_ALWAYS(ip);
 249                 uint16 port = bio.ReadUInt16();
 250                 uint16 tport = bio.ReadUInt16();
 251                 byte type = bio.ReadUInt8();
 252                 //AddDebugLogLineM(false, logKadMain, wxT("Adding contact(s) with ip ") + Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip),port));
 253                 if (IsGoodIPPort(wxUINT32_SWAP_ALWAYS(ip),port)) {
 254                         routingZone->Add(id, ip, port, tport, type);
 255                 }
 256         }
 257 }
 258
 259 //KADEMLIA_BOOTSTRAP_REQ
 260 void CKademliaUDPListener::ProcessBootstrapRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 261 {
 262         // Verify packet is expected size
 263         if (lenPacket != 25){
 264                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 265         }
 266
 267         // Add the sender to the list of contacts
 268         AddContact(packetData, lenPacket, ip, port);
 269
 270         // Get some contacts to return
 271         ContactList contacts;
 272         uint16 numContacts = 1 + (uint16)CKademlia::GetRoutingZone()->GetBootstrapContacts(&contacts, 20);
 273
 274         // Create response packet
 275         //We only collect a max of 20 contacts here.. Max size is 527.
 276         //2 + 25(20) + 15(1)
 277         CMemFile packetdata(527);
 278
 279         // Write packet info
 280         packetdata.WriteUInt16(numContacts);
 281         CContact *contact;
 282         ContactList::const_iterator it;
 283         for (it = contacts.begin(); it != contacts.end(); it++) {
 284                 contact = *it;
 285                 packetdata.WriteUInt128(contact->GetClientID());
 286                 packetdata.WriteUInt32(contact->GetIPAddress());
 287                 packetdata.WriteUInt16(contact->GetUDPPort());
 288                 packetdata.WriteUInt16(contact->GetTCPPort());
 289                 packetdata.WriteUInt8(contact->GetType());
 290         }
 291
 292         packetdata.WriteUInt128(CKademlia::GetPrefs()->GetKadID());
 293         packetdata.WriteUInt32(CKademlia::GetPrefs()->GetIPAddress());
 294         packetdata.WriteUInt16(thePrefs::GetEffectiveUDPPort());
 295         packetdata.WriteUInt16(thePrefs::GetPort());
 296         packetdata.WriteUInt8(0);
 297
 298         // Send response
 299         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadBootstrapRes %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 300
 301         SendPacket(packetdata, KADEMLIA_BOOTSTRAP_RES, ip, port);
 302 }
 303
 304 //KADEMLIA_BOOTSTRAP_RES
 305 void CKademliaUDPListener::ProcessBootstrapResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 306 {
 307         // Verify packet is expected size
 308         if (lenPacket < 27){
 309                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 310         }
 311
 312         // How many contacts were given
 313         CMemFile bio(packetData, lenPacket);
 314         uint16 numContacts = bio.ReadUInt16();
 315
 316         // Verify packet is expected size
 317         if (lenPacket != (uint32)(2 + 25*numContacts)) {
 318                 return;
 319         }
 320
 321         // Add these contacts to the list.
 322         AddContacts(packetData+2, lenPacket-2, numContacts);
 323         // Send sender to alive.
 324         CKademlia::GetRoutingZone()->SetAlive(ip, port);
 325 }
 326
 327 //KADEMLIA_HELLO_REQ
 328 void CKademliaUDPListener::ProcessHelloRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 329 {
 330         // Verify packet is expected size
 331         if (lenPacket != 25){
 332                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 333         }
 334
 335         // Add the sender to the list of contacts
 336         AddContact(packetData, lenPacket, ip, port);
 337
 338         // Send response
 339         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadHelloRes %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 340         SendMyDetails(KADEMLIA_HELLO_RES, ip, port);
 341
 342         // Check if firewalled
 343         if(CKademlia::GetPrefs()->GetRecheckIP()) {
 344                 FirewalledCheck(ip, port);
 345         }
 346 }
 347
 348 //KADEMLIA_HELLO_RES
 349 void CKademliaUDPListener::ProcessHelloResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 350 {
 351         // Verify packet is expected size
 352         if (lenPacket != 25){
 353                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 354         }
 355
 356         // Add or Update contact.
 357         AddContact(packetData, lenPacket, ip, port);
 358
 359         // Set contact to alive.
 360         CKademlia::GetRoutingZone()->SetAlive(ip, port);
 361 }
 362
 363 //KADEMLIA_REQ
 364 void CKademliaUDPListener::ProcessKademliaRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 365 {
 366         // Verify packet is expected size
 367         if (lenPacket != 33){
 368                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 369         }
 370
 371         //RecheckIP and firewall status
 372         if(CKademlia::GetPrefs()->GetRecheckIP())
 373         {
 374                 FirewalledCheck(ip, port);
 375                 AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadHelloReq %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 376                 SendMyDetails(KADEMLIA_HELLO_REQ, ip, port);
 377         }
 378
 379         // Get target and type
 380         CMemFile bio(packetData, lenPacket);
 381         byte type = bio.ReadUInt8();
 382 //              bool flag1 = (type >> 6); //Reserved
 383 //              bool flag2 = (type >> 7); //Reserved
 384 //              bool flag3 = (type >> 8); //Reserved
 385
 386         type = type & 0x1F;
 387         if( type == 0 ) {
 388                 throw wxString::Format(wxT("***NOTE: Received wrong type (0x%02x) in "), type) + wxString::FromAscii(__FUNCTION__);
 389         }
 390
 391         //This is the target node trying to be found.
 392         CUInt128 target = bio.ReadUInt128();
 393         CUInt128 distance(CKademlia::GetPrefs()->GetKadID());
 394         distance.XOR(target);
 395
 396         //This makes sure we are not mistaken identify. Some client may have fresh installed and have a new hash.
 397         CUInt128 check = bio.ReadUInt128();
 398         if( CKademlia::GetPrefs()->GetKadID().CompareTo(check)) {
 399                 return;
 400         }
 401
 402         // Get required number closest to target
 403         ContactMap results;
 404         CKademlia::GetRoutingZone()->GetClosestTo(2, target, distance, (int)type, &results);
 405         uint16 count = (uint16)results.size();
 406
 407         // Write response
 408         // Max count is 32. size 817..
 409         // 16 + 1 + 25(32)
 410         CMemFile packetdata( 817 );
 411         packetdata.WriteUInt128(target);
 412         packetdata.WriteUInt8((byte)count);
 413         CContact *c;
 414         ContactMap::const_iterator it;
 415         for (it = results.begin(); it != results.end(); it++) {
 416                 c = it->second;
 417                 packetdata.WriteUInt128(c->GetClientID());
 418                 packetdata.WriteUInt32(c->GetIPAddress());
 419                 packetdata.WriteUInt16(c->GetUDPPort());
 420                 packetdata.WriteUInt16(c->GetTCPPort());
 421                 packetdata.WriteUInt8(c->GetType());
 422         }
 423
 424         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadRes %s Count=%u")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port) % count);
 425
 426         SendPacket(packetdata, KADEMLIA_RES, ip, port);
 427 }
 428
 429 //KADEMLIA_RES
 430 void CKademliaUDPListener::ProcessKademliaResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 431 {
 432         // Verify packet is expected size
 433         if (lenPacket < 17){
 434                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 435         }
 436
 437         //Used Pointers
 438         CRoutingZone *routingZone = CKademlia::GetRoutingZone();
 439
 440         if(CKademlia::GetPrefs()->GetRecheckIP()) {
 441                 FirewalledCheck(ip, port);
 442                 AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadHelloReq %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 443                 SendMyDetails(KADEMLIA_HELLO_REQ, ip, port);
 444         }
 445
 446         // What search does this relate to
 447         CMemFile bio(packetData, lenPacket);
 448         CUInt128 target = bio.ReadUInt128();
 449         uint16 numContacts = bio.ReadUInt8();
 450
 451         // Verify packet is expected size
 452         if (lenPacket != (uint32)(16+1 + (16+4+2+2+1)*numContacts)) {
 453                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 454         }
 455
 456         // Set contact to alive.
 457         routingZone->SetAlive(ip, port);
 458
 459
 460         CScopedPtr<ContactList> results(new ContactList);
 461
 462         for (uint16 i=0; i<numContacts; i++) {
 463                 CUInt128 id = bio.ReadUInt128();
 464                 uint32 contactIP = bio.ReadUInt32();
 465                 uint16 contactPort = bio.ReadUInt16();
 466                 uint16 tport = bio.ReadUInt16();
 467                 byte type = bio.ReadUInt8();
 468                 if(::IsGoodIPPort(wxUINT32_SWAP_ALWAYS(contactIP),contactPort)) {
 469                         routingZone->Add(id, contactIP, contactPort, tport, type);
 470                         results->push_back(new CContact(id, contactIP, contactPort, tport, target));
 471                 }
 472         }
 473
 474         CSearchManager::ProcessResponse(target, ip, port, results.release());
 475 }
 476
 477 void CKademliaUDPListener::Free(SSearchTerm* pSearchTerms)
 478 {
 479         if (!pSearchTerms) {
 480                 return;
 481         }
 482
 483         Free(pSearchTerms->left);
 484         Free(pSearchTerms->right);
 485         delete pSearchTerms;
 486 }
 487
 488 SSearchTerm* CKademliaUDPListener::CreateSearchExpressionTree(CMemFile& bio, int iLevel)
 489 {
 490         // the max. depth has to match our own limit for creating the search expression
 491         // (see also 'ParsedSearchExpression' and 'GetSearchPacket')
 492         if (iLevel >= 24){
 493                 AddDebugLogLineM(false, logClientKadUDP, wxT("***NOTE: Search expression tree exceeds depth limit!"));
 494                 return NULL;
 495         }
 496         iLevel++;
 497
 498         uint8 op = bio.ReadUInt8();
 499         if (op == 0x00) {
 500                 uint8 boolop = bio.ReadUInt8();
 501                 if (boolop == 0x00) { // AND
 502                         SSearchTerm* pSearchTerm = new SSearchTerm;
 503                         pSearchTerm->type = SSearchTerm::AND;
 504                         //TRACE(" AND");
 505                         if ((pSearchTerm->left = CreateSearchExpressionTree(bio, iLevel)) == NULL){
 506                                 wxASSERT(0);
 507                                 delete pSearchTerm;
 508                                 return NULL;
 509                         }
 510                         if ((pSearchTerm->right = CreateSearchExpressionTree(bio, iLevel)) == NULL){
 511                                 wxASSERT(0);
 512                                 Free(pSearchTerm->left);
 513                                 delete pSearchTerm;
 514                                 return NULL;
 515                         }
 516                         return pSearchTerm;
 517                 } else if (boolop == 0x01) { // OR
 518                         SSearchTerm* pSearchTerm = new SSearchTerm;
 519                         pSearchTerm->type = SSearchTerm::OR;
 520                         //TRACE(" OR");
 521                         if ((pSearchTerm->left = CreateSearchExpressionTree(bio, iLevel)) == NULL){
 522                                 wxASSERT(0);
 523                                 delete pSearchTerm;
 524                                 return NULL;
 525                         }
 526                         if ((pSearchTerm->right = CreateSearchExpressionTree(bio, iLevel)) == NULL){
 527                                 wxASSERT(0);
 528                                 Free(pSearchTerm->left);
 529                                 delete pSearchTerm;
 530                                 return NULL;
 531                         }
 532                         return pSearchTerm;
 533                 } else if (boolop == 0x02) { // NAND
 534                         SSearchTerm* pSearchTerm = new SSearchTerm;
 535                         pSearchTerm->type = SSearchTerm::NAND;
 536                         //TRACE(" NAND");
 537                         if ((pSearchTerm->left = CreateSearchExpressionTree(bio, iLevel)) == NULL){
 538                                 wxASSERT(0);
 539                                 delete pSearchTerm;
 540                                 return NULL;
 541                         }
 542                         if ((pSearchTerm->right = CreateSearchExpressionTree(bio, iLevel)) == NULL){
 543                                 wxASSERT(0);
 544                                 Free(pSearchTerm->left);
 545                                 delete pSearchTerm;
 546                                 return NULL;
 547                         }
 548                         return pSearchTerm;
 549                 } else{
 550                         AddDebugLogLineM(false, logKadSearch, wxString::Format(wxT("*** Unknown boolean search operator 0x%02x (CreateSearchExpressionTree)"), boolop));
 551                         return NULL;
 552                 }
 553         } else if (op == 0x01) { // String
 554                 wxString str(bio.ReadString(true));
 555
 556                 // Make lowercase, the search code expects lower case strings!
 557                 str.MakeLower();
 558
 559                 SSearchTerm* pSearchTerm = new SSearchTerm;
 560                 pSearchTerm->type = SSearchTerm::String;
 561                 pSearchTerm->astr = new wxArrayString;
 562
 563                 // pre-tokenize the string term
 564                 wxStringTokenizer token(str,InvKadKeywordChars,wxTOKEN_DEFAULT );
 565                 while (token.HasMoreTokens()) {
 566                         wxString strTok(token.GetNextToken());
 567                         if (!strTok.IsEmpty()) {
 568                                 pSearchTerm->astr->Add(strTok);
 569                         }
 570                 }
 571
 572                 return pSearchTerm;
 573         } else if (op == 0x02) { // Meta tag
 574                 // read tag value
 575                 wxString strValue(bio.ReadString(true));
 576                 // Make lowercase, the search code expects lower case strings!
 577                 strValue.MakeLower();
 578
 579                 // read tag name
 580                 wxString strTagName =  bio.ReadString(true);
 581
 582                 SSearchTerm* pSearchTerm = new SSearchTerm;
 583                 pSearchTerm->type = SSearchTerm::MetaTag;
 584                 pSearchTerm->tag = new CTagString(strTagName, strValue);
 585                 return pSearchTerm;
 586         }
 587         else if (op == 0x03) { // Min/Max
 588                 static const struct {
 589                         SSearchTerm::ESearchTermType eSearchTermOp;
 590                         wxString pszOp;
 591                 } _aOps[] =
 592                 {
 593                         { SSearchTerm::OpEqual,                 wxT("=")                }, // mmop=0x00
 594                         { SSearchTerm::OpGreaterEqual,  wxT(">=")       }, // mmop=0x01
 595                         { SSearchTerm::OpLessEqual,             wxT("<=")       }, // mmop=0x02
 596                         { SSearchTerm::OpGreater,               wxT(">")                }, // mmop=0x03
 597                         { SSearchTerm::OpLess,                  wxT("<")                }, // mmop=0x04
 598                         { SSearchTerm::OpNotEqual,              wxT("!=")       }  // mmop=0x05
 599                 };
 600
 601                 // read tag value
 602                 uint32 uValue = bio.ReadUInt32();
 603
 604                 // read integer operator
 605                 uint8 mmop = bio.ReadUInt8();
 606                 if (mmop >= itemsof(_aOps)){
 607                         AddDebugLogLineM(false, logClientKadUDP, wxString::Format(wxT("*** Unknown integer search op=0x%02x (CreateSearchExpressionTree)"), mmop));
 608                         return NULL;
 609                 }
 610
 611                 // read tag name
 612                 wxString strTagName = bio.ReadString(false);
 613
 614                 SSearchTerm* pSearchTerm = new SSearchTerm;
 615                 pSearchTerm->type = _aOps[mmop].eSearchTermOp;
 616                 pSearchTerm->tag = new CTagVarInt(strTagName, uValue);
 617
 618                 return pSearchTerm;
 619         } else{
 620                 AddDebugLogLineM(false, logClientKadUDP, wxString::Format(wxT("*** Unknown search op=0x%02x (CreateSearchExpressionTree)"), op));
 621                 return NULL;
 622         }
 623 }
 624
 625 //KADEMLIA_SEARCH_REQ
 626 void CKademliaUDPListener::ProcessSearchRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 627 {
 628         // Verify packet is expected size
 629         if (lenPacket < 17){
 630                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 631         }
 632
 633         CMemFile bio(packetData, lenPacket);
 634         CUInt128 target = bio.ReadUInt128();
 635         uint8 restrictive = bio.ReadUInt8();
 636
 637 #ifdef _DEBUG
 638         //DWORD dwNow = GetTickCount();
 639 #endif
 640         if(lenPacket == 17 ) {
 641                 if(restrictive) {
 642                         //Source request
 643                         CKademlia::GetIndexed()->SendValidSourceResult(target, ip, port);
 644                         //DEBUG_ONLY( Debug("SendValidSourceResult: Time=%.2f sec\n", (GetTickCount() - dwNow) / 1000.0) );
 645                 } else {
 646                         //Single keyword request
 647                         CKademlia::GetIndexed()->SendValidKeywordResult(target, NULL, ip, port );
 648                         //DEBUG_ONLY( Debug("SendValidKeywordResult (Single): Time=%.2f sec\n", (GetTickCount() - dwNow) / 1000.0) );
 649                 }
 650         } else if(lenPacket > 17) {
 651                 SSearchTerm* pSearchTerms = NULL;
 652                 if (restrictive) {
 653                         pSearchTerms = CreateSearchExpressionTree(bio, 0);
 654                 }
 655                 //Keyword request with added options.
 656                 CKademlia::GetIndexed()->SendValidKeywordResult(target, pSearchTerms, ip, port);
 657                 Free(pSearchTerms);
 658                 //DEBUG_ONLY( Debug("SendValidKeywordResult: Time=%.2f sec\n", (GetTickCount() - dwNow) / 1000.0) );
 659         }
 660 }
 661
 662 //KADEMLIA_SEARCH_RES
 663 void CKademliaUDPListener::ProcessSearchResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 664 {
 665         // Verify packet is expected size
 666         if (lenPacket < 37) {
 667                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 668         }
 669
 670         // Set contact to alive.
 671         CKademlia::GetRoutingZone()->SetAlive(ip, port);
 672
 673         // What search does this relate to
 674         CMemFile bio(packetData, lenPacket);
 675         CUInt128 target = bio.ReadUInt128();
 676
 677         // How many results.. Not supported yet..
 678         uint16 count = bio.ReadUInt16();
 679         while( count > 0 ) {
 680                 // What is the answer
 681                 CUInt128 answer = bio.ReadUInt128();
 682
 683                 // Get info about answer
 684                 // NOTE: this is the one and only place in Kad where we allow string conversion to local code page in
 685                 // case we did not receive an UTF8 string. this is for backward compatibility for search results which are
 686                 // supposed to be 'viewed' by user only and not feed into the Kad engine again!
 687                 // If that tag list is once used for something else than for viewing, special care has to be taken for any
 688                 // string conversion!
 689                 TagPtrList* tags = new TagPtrList;
 690                 try {
 691                         bio.ReadTagPtrList(tags, true/*bOptACP*/);
 692                 } catch(...){
 693                         DebugClientOutput(wxT("CKademliaUDPListener::processSearchResponse"),ip,port,packetData,lenPacket);
 694                         deleteTagPtrListEntries(tags);
 695                         delete tags;
 696                         tags = NULL;
 697                         throw;
 698                 }
 699                 CSearchManager::ProcessResult(target, ip, port, answer, tags);
 700                 count--;
 701         }
 702 }
 703
 704 //KADEMLIA_PUBLISH_REQ
 705 void CKademliaUDPListener::ProcessPublishRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 706 {
 707         //There are different types of publishing..
 708         //Keyword and File are Stored..
 709         // Verify packet is expected size
 710         if (lenPacket < 37) {
 711                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 712         }
 713
 714         //Used Pointers
 715         CIndexed *indexed = CKademlia::GetIndexed();
 716
 717         if( CKademlia::GetPrefs()->GetFirewalled() ) {
 718                 //We are firewalled. We should not index this entry and give publisher a false report.
 719                 return;
 720         }
 721
 722         CMemFile bio(packetData, lenPacket);
 723         CUInt128 file = bio.ReadUInt128();
 724
 725         CUInt128 distance(CKademlia::GetPrefs()->GetKadID());
 726         distance.XOR(file);
 727
 728         if( thePrefs::FilterLanIPs() && distance.Get32BitChunk(0) > SEARCHTOLERANCE) {
 729                 return;
 730         }
 731
 732         wxString strInfo;
 733         uint16 count = bio.ReadUInt16();
 734         uint16 totalcount = count;
 735         bool flag = false;
 736         uint8 load = 0;
 737         while( count > 0 ) {
 738                 strInfo.Clear();
 739
 740                 CUInt128 target = bio.ReadUInt128();
 741
 742                 Kademlia::CEntry* entry = new Kademlia::CEntry();
 743                 uint32 tags = 0, totaltags = 0;
 744                 try {
 745                         entry->m_iIP = ip;
 746                         entry->m_iUDPport = port;
 747                         entry->m_iKeyID.SetValue(file);
 748                         entry->m_iSourceID.SetValue(target);
 749                         tags = bio.ReadUInt8();
 750                         totaltags = tags;
 751                         while(tags > 0) {
 752                                 CTag* tag = bio.ReadTag();
 753                                 totaltags = tags;
 754                                 if(tag) {
 755                                         if (!tag->GetName().Cmp(TAG_SOURCETYPE) && tag->GetType() == 9) {
 756                                                 if( entry->m_bSource == false ) {
 757                                                         entry->m_lTagList.push_back(new CTagVarInt(TAG_SOURCEIP, entry->m_iIP));
 758                                                         entry->m_lTagList.push_back(new CTagVarInt(TAG_SOURCEUPORT, entry->m_iUDPport));
 759                                                 } else {
 760                                                         //More than one sourcetype tag found.
 761                                                         delete tag;
 762                                                 }
 763                                                 entry->m_bSource = true;
 764                                         }
 765
 766                                         if (!tag->GetName().Cmp(TAG_FILENAME)) {
 767                                                 if ( entry->m_sFileName.IsEmpty() ) {
 768                                                         entry->m_sFileName = tag->GetStr();
 769                                                         // Make lowercase, the search code expects lower case strings!
 770                                                         entry->m_sFileName.MakeLower();
 771                                                         strInfo += CFormat(wxT("  Name=\"%s\"")) % entry->m_sFileName;
 772                                                         // NOTE: always add the 'name' tag, even if it's stored separately in 'fileName'. the tag is still needed for answering search request
 773                                                         entry->m_lTagList.push_back(tag);
 774                                                 } else {
 775                                                         //More then one Name tag found.
 776                                                         delete tag;
 777                                                 }
 778                                         } else if (!tag->GetName().Cmp(TAG_FILESIZE)) {
 779                                                 if( entry->m_iSize == 0 ) {
 780                                                         if (tag->IsBsob() && (tag->GetBsobSize() == 8)) {
 781                                                                 // Kad1.0 uint64 type using a BSOB.
 782                                                                 entry->m_iSize = PeekUInt64(tag->GetBsob());
 783
 784                                                                 // Don't save as a BSOB tag ...
 785                                                                 delete tag;
 786                                                                 tag = new CTagVarInt(TAG_FILESIZE, entry->m_iSize);
 787                                                         } else {
 788                                                                 wxASSERT(tag->IsInt());
 789                                                                 entry->m_iSize = tag->GetInt();
 790                                                         }
 791                                                         strInfo += wxString::Format(wxT("  Size=%") wxLongLongFmtSpec wxT("u"), entry->m_iSize);
 792                                                         // NOTE: always add the 'size' tag, even if it's stored separately in 'size'. the tag is still needed for answering search request
 793                                                         entry->m_lTagList.push_back(tag);
 794                                                 } else {
 795                                                         //More then one size tag found
 796                                                         delete tag;
 797                                                 }
 798                                         } else if (!tag->GetName().Cmp(TAG_SOURCEPORT)) {
 799                                                 if( entry->m_iTCPport == 0 ) {
 800                                                         entry->m_iTCPport = tag->GetInt();
 801                                                         entry->m_lTagList.push_back(tag);
 802                                                 } else {
 803                                                         //More then one port tag found
 804                                                         delete tag;
 805                                                 }
 806                                         } else {
 807                                                 //TODO: Filter tags
 808                                                 entry->m_lTagList.push_back(tag);
 809                                         }
 810                                 }
 811                                 tags--;
 812                         }
 813                         if (!strInfo.IsEmpty()) {
 814                                 AddDebugLogLineM(false, logClientKadUDP, strInfo);
 815                         }
 816                 } catch(...) {
 817                         printf("Error on count %i tag %i\n",totalcount-count, totaltags-tags);
 818                         DebugClientOutput(wxT("CKademliaUDPListener::processPublishRequest"),ip,port,packetData,lenPacket);
 819                         delete entry;
 820                         throw;
 821                 }
 822
 823                 if( entry->m_bSource == true ) {
 824                         entry->m_tLifeTime = (uint32)time(NULL)+KADEMLIAREPUBLISHTIMES;
 825                         if( indexed->AddSources(file, target, entry, load ) ) {
 826                                 flag = true;
 827                         } else {
 828                                 delete entry;
 829                                 entry = NULL;
 830                         }
 831                 } else {
 832                         entry->m_tLifeTime = (uint32)time(NULL)+KADEMLIAREPUBLISHTIMEK;
 833                         if( indexed->AddKeyword(file, target, entry, load) ) {
 834                                 // This makes sure we send a publish response..
 835                                 // This also makes sure we index all the files for this keyword.
 836                                 flag = true;
 837                         } else {
 838                                 //We already indexed the maximum number of keywords.
 839                                 //We do not index anymore but we still send a success..
 840                                 //Reason: Because if a VERY busy node tells the publisher it failed,
 841                                 //this busy node will spread to all the surrounding nodes causing popular
 842                                 //keywords to be stored on MANY nodes..
 843                                 //So, once we are full, we will periodically clean our list until we can
 844                                 //begin storing again..
 845                                 flag = true;
 846                                 delete entry;
 847                                 entry = NULL;
 848                         }
 849                 }
 850                 count--;
 851         }
 852         if( flag ) {
 853                 CMemFile packetdata(17);
 854                 packetdata.WriteUInt128(file);
 855                 packetdata.WriteUInt8(load);
 856                 AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadPublishRes %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 857
 858                 SendPacket( packetdata, KADEMLIA_PUBLISH_RES, ip, port);
 859         }
 860 }
 861
 862 //KADEMLIA_PUBLISH_ACK
 863 void CKademliaUDPListener::ProcessPublishResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 864 {
 865         // Verify packet is expected size
 866         if (lenPacket < 16) {
 867                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 868         }
 869
 870         // Set contact to alive.
 871         CKademlia::GetRoutingZone()->SetAlive(ip, port);
 872
 873         CMemFile bio(packetData, lenPacket);
 874         CUInt128 file = bio.ReadUInt128();
 875
 876         bool loadResponse = false;
 877         uint8 load = 0;
 878         if( bio.GetLength() > bio.GetPosition() ) {
 879                 loadResponse = true;
 880                 load = bio.ReadUInt8();
 881         }
 882
 883         CSearchManager::ProcessPublishResult(file, load, loadResponse);
 884 }
 885
 886 //KADEMLIA_SRC_NOTES_REQ
 887 void CKademliaUDPListener::ProcessSearchNotesRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 888 {
 889         // Verify packet is expected size
 890         if (lenPacket < 32) {
 891                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 892         }
 893
 894         CMemFile bio(packetData, lenPacket);
 895         CUInt128 target = bio.ReadUInt128();
 896         CUInt128 source = bio.ReadUInt128();
 897
 898         CKademlia::GetIndexed()->SendValidNoteResult(target, source, ip, port);
 899 }
 900
 901 //KADEMLIA_SRC_NOTES_RES
 902 void CKademliaUDPListener::ProcessSearchNotesResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 903 {
 904         // Verify packet is expected size
 905         if (lenPacket < 37) {
 906                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 907         }
 908
 909         // Set contact to alive.
 910         CKademlia::GetRoutingZone()->SetAlive(ip, port);
 911
 912         // What search does this relate to
 913         CMemFile bio(packetData, lenPacket);
 914         CUInt128 target = bio.ReadUInt128();
 915
 916         uint16 count = bio.ReadUInt16();
 917         while( count > 0 ) {
 918                 // What is the answer
 919                 CUInt128 answer = bio.ReadUInt128();
 920
 921                 // Get info about answer
 922                 // NOTE: this is the one and only place in Kad where we allow string conversion to local code page in
 923                 // case we did not receive an UTF8 string. this is for backward compatibility for search results which are
 924                 // supposed to be 'viewed' by user only and not feed into the Kad engine again!
 925                 // If that tag list is once used for something else than for viewing, special care has to be taken for any
 926                 // string conversion!
 927                 TagPtrList* tags = new TagPtrList;
 928                 try{
 929                         bio.ReadTagPtrList(tags, true/*bOptACP*/);
 930                 } catch(...){
 931                         DebugClientOutput(wxT("CKademliaUDPListener::processSearchNotesResponse"),ip,port,packetData,lenPacket);
 932                         deleteTagPtrListEntries(tags);
 933                         delete tags;
 934                         tags = NULL;
 935                         throw;
 936                 }
 937                 CSearchManager::ProcessResult(target, ip, port, answer, tags);
 938                 count--;
 939         }
 940 }
 941
 942 //KADEMLIA_PUB_NOTES_REQ
 943 void CKademliaUDPListener::ProcessPublishNotesRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
 944 {
 945         // Verify packet is expected size
 946         if (lenPacket < 37) {
 947                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
 948         }
 949
 950         if( CKademlia::GetPrefs()->GetFirewalled() ) {
 951                 //We are firewalled. We should not index this entry and give publisher a false report.
 952                 return;
 953         }
 954
 955         CMemFile bio(packetData, lenPacket);
 956         CUInt128 target = bio.ReadUInt128();
 957
 958         CUInt128 distance(CKademlia::GetPrefs()->GetKadID());
 959         distance.XOR(target);
 960
 961         if( thePrefs::FilterLanIPs() && distance.Get32BitChunk(0) > SEARCHTOLERANCE) {
 962                 return;
 963         }
 964
 965         CUInt128 source = bio.ReadUInt128();
 966
 967         Kademlia::CEntry* entry = new Kademlia::CEntry();
 968         try {
 969                 entry->m_iIP = ip;
 970                 entry->m_iUDPport = port;
 971                 entry->m_iKeyID.SetValue(target);
 972                 entry->m_iSourceID.SetValue(source);
 973                 bio.ReadTagPtrList(&entry->m_lTagList);
 974                 entry->m_bSource = false;
 975         } catch(...) {
 976                 DebugClientOutput(wxT("CKademliaUDPListener::processPublishNotesRequest"),ip,port,packetData,lenPacket);
 977                 delete entry;
 978                 throw;
 979         }
 980
 981         if( entry == NULL ) {
 982                 throw wxString(wxT("CKademliaUDPListener::processPublishNotesRequest: entry == NULL"));
 983         } else if( entry->m_lTagList.size() == 0 || entry->m_lTagList.size() > 5) {
 984                 delete entry;
 985                 throw wxString(wxT("CKademliaUDPListener::processPublishNotesRequest: entry->m_lTagList.size() == 0 || entry->m_lTagList.size() > 5"));
 986         }
 987
 988         uint8 load = 0;
 989         if( CKademlia::GetIndexed()->AddNotes(target, source, entry, load ) ) {
 990                 CMemFile packetdata(17);
 991                 packetdata.WriteUInt128(target);
 992                 packetdata.WriteUInt8(load);
 993                 AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadPublishNotesRes %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
 994                 SendPacket( packetdata, KADEMLIA_PUB_NOTES_RES, ip, port);
 995         } else {
 996                 delete entry;
 997         }
 998 }
 999
1000 //KADEMLIA_PUB_NOTES_RES
1001 void CKademliaUDPListener::ProcessPublishNotesResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
1002 {
1003         // Verify packet is expected size
1004         if (lenPacket < 16){
1005                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1006         }
1007
1008         // Set contact to alive.
1009         CKademlia::GetRoutingZone()->SetAlive(ip, port);
1010
1011         CMemFile bio(packetData, lenPacket);
1012         CUInt128 file = bio.ReadUInt128();
1013
1014         bool loadResponse = false;
1015         uint8 load = 0;
1016         if( bio.GetLength() > bio.GetPosition() ) {
1017                 loadResponse = true;
1018                 load = bio.ReadUInt8();
1019         }
1020
1021         CSearchManager::ProcessPublishResult(file, load, loadResponse);
1022 }
1023
1024 //KADEMLIA_FIREWALLED_REQ
1025 void CKademliaUDPListener::ProcessFirewalledRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
1026 {
1027         // Verify packet is expected size
1028         if (lenPacket != 2){
1029                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1030         }
1031
1032         CMemFile bio(packetData, lenPacket);
1033         uint16 tcpport = bio.ReadUInt16();
1034
1035         CUInt128 zero((uint32)0);
1036         CContact contact(zero, ip, port, tcpport, zero);
1037         theApp->clientlist->RequestTCP(&contact);
1038
1039         // Send response
1040         CMemFile packetdata(4);
1041         packetdata.WriteUInt32(ip);
1042         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFirewalledRes %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
1043
1044         SendPacket(packetdata, KADEMLIA_FIREWALLED_RES, ip, port);
1045 }
1046
1047 //KADEMLIA_FIREWALLED_RES
1048 void CKademliaUDPListener::ProcessFirewalledResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
1049 {
1050         // Verify packet is expected size
1051         if (lenPacket != 4){
1052                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1053         }
1054
1055         // Set contact to alive.
1056         CKademlia::GetRoutingZone()->SetAlive(ip, port);
1057
1058         CMemFile bio(packetData, lenPacket);
1059         uint32 firewalledIP = bio.ReadUInt32();
1060
1061         //Update con state only if something changes.
1062         if( CKademlia::GetPrefs()->GetIPAddress() != firewalledIP ) {
1063                 CKademlia::GetPrefs()->SetIPAddress(firewalledIP);
1064                 theApp->ShowConnectionState();
1065         }
1066         CKademlia::GetPrefs()->IncRecheckIP();
1067 }
1068
1069 //KADEMLIA_FIREWALLED_ACK
1070 void CKademliaUDPListener::ProcessFirewalledResponse2 (const byte *WXUNUSED(packetData), uint32 lenPacket, uint32 ip, uint16 port)
1071 {
1072         // Verify packet is expected size
1073         if (lenPacket != 0) {
1074                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1075         }
1076
1077         // Set contact to alive.
1078         CKademlia::GetRoutingZone()->SetAlive(ip, port);
1079         CKademlia::GetPrefs()->IncFirewalled();
1080 }
1081
1082 //KADEMLIA_FINDBUDDY_REQ
1083 void CKademliaUDPListener::ProcessFindBuddyRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
1084 {
1085         // Verify packet is expected size
1086         if (lenPacket < 34) {
1087                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1088         }
1089
1090         if( CKademlia::GetPrefs()->GetFirewalled() ) {
1091                 //We are firewalled but somehow we still got this packet.. Don't send a response..
1092                 return;
1093         }
1094
1095         CMemFile bio(packetData, lenPacket);
1096         CUInt128 BuddyID = bio.ReadUInt128();
1097         CUInt128 userID = bio.ReadUInt128();
1098         uint16 tcpport = bio.ReadUInt16();
1099
1100         CUInt128 zero((uint32)0);
1101         CContact contact(userID, ip, port, tcpport, zero);
1102         theApp->clientlist->IncomingBuddy(&contact, &BuddyID);
1103
1104         CMemFile packetdata(34);
1105         packetdata.WriteUInt128(BuddyID);
1106         packetdata.WriteUInt128(CKademlia::GetPrefs()->GetClientHash());
1107         packetdata.WriteUInt16(thePrefs::GetPort());
1108         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadFindBuddyRes %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
1109
1110         SendPacket(packetdata, KADEMLIA_FINDBUDDY_RES, ip, port);
1111 }
1112
1113 //KADEMLIA_FINDBUDDY_RES
1114 void CKademliaUDPListener::ProcessFindBuddyResponse (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
1115 {
1116         // Verify packet is expected size
1117         if (lenPacket < 34) {
1118                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1119         }
1120
1121
1122         CMemFile bio(packetData, lenPacket);
1123         CUInt128 check = bio.ReadUInt128();
1124         check.XOR(CUInt128(true));
1125         if( CKademlia::GetPrefs()->GetKadID().CompareTo(check)) {
1126                 return;
1127         }
1128         CUInt128 userID = bio.ReadUInt128();
1129         uint16 tcpport = bio.ReadUInt16();
1130
1131         CUInt128 zero((uint32)0);
1132         CContact contact(userID, ip, port, tcpport, zero);
1133         theApp->clientlist->RequestBuddy(&contact);
1134 }
1135
1136 //KADEMLIA_CALLBACK_REQ
1137 void CKademliaUDPListener::ProcessCallbackRequest (const byte *packetData, uint32 lenPacket, uint32 ip, uint16 port)
1138 {
1139         // Verify packet is expected size
1140         if (lenPacket < 34) {
1141                 throw wxString::Format(wxT("***NOTE: Received wrong size (%u) packet in "), lenPacket) + wxString::FromAscii(__FUNCTION__);
1142         }
1143
1144         CUpDownClient* buddy = theApp->clientlist->GetBuddy();
1145         if( buddy != NULL ) {
1146                 CMemFile bio(packetData, lenPacket);
1147                 CUInt128 check = bio.ReadUInt128();
1148                 // JOHNTODO: Filter bad buddies
1149                 //CUInt128 bud(buddy->GetBuddyID());
1150                 CUInt128 file = bio.ReadUInt128();
1151                 uint16 tcp = bio.ReadUInt16();
1152                 CMemFile packetdata(16+16+4+2);
1153                 packetdata.WriteUInt128(check);
1154                 packetdata.WriteUInt128(file);
1155                 packetdata.WriteUInt32(ip);
1156                 packetdata.WriteUInt16(tcp);
1157                 CPacket* packet = new CPacket(packetdata, OP_EMULEPROT, OP_CALLBACK);
1158                 if( buddy->GetSocket() ) {
1159                         AddDebugLogLineM(false, logClientKadUDP, CFormat(wxT("KadCallback %s")) % Uint32_16toStringIP_Port(wxUINT32_SWAP_ALWAYS(ip), port));
1160                         theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
1161                 buddy->GetSocket()->SendPacket(packet);
1162                 } else {
1163                         wxASSERT(0);
1164                 }
1165         }
1166 }
1167
1168 void CKademliaUDPListener::SendPacket(const CMemFile &data, byte opcode, uint32 destinationHost, uint16 destinationPort)
1169 {
1170         CPacket* packet = new CPacket(data, OP_KADEMLIAHEADER, opcode);
1171         if( packet->GetPacketSize() > 200 ) {
1172                 packet->PackPacket();
1173         }
1174         theStats::AddUpOverheadKad(packet->GetPacketSize());
1175         theApp->clientudp->SendPacket(packet,wxUINT32_SWAP_ALWAYS(destinationHost), destinationPort, false, NULL, true, 0);
1176 }
1177
1178 void CKademliaUDPListener::DebugClientOutput(const wxString& place, uint32 kad_ip, uint32 port, const byte* data, int len)
1179 {
1180 #if THIS_DEBUG_IS_JUST_FOR_KRY_DONT_TOUCH_IT_KTHX
1181         uint32 ip = wxUINT32_SWAP_ALWAYS(kad_ip);
1182         printf("Error on %s received from: %s\n",(const char*)unicode2char(place),(const char*)unicode2char(Uint32_16toStringIP_Port(ip,port)));
1183         if (data) {
1184                 printf("Packet dump:\n");
1185                 DumpMem(data, len);
1186         }
1187         CClientList::SourceList clientslist = theApp->clientlist->GetClientsByIP(ip);
1188         if (!clientslist.empty()) {
1189                 for (CClientList::SourceList::iterator it = clientslist.begin(); it != clientslist.end(); ++it) {
1190                         printf("Ip Matches: %s\n",(const char*)unicode2char((*it)->GetClientFullInfo()));
1191                 }
1192         } else {
1193                 printf("No ip match, trying to create a client connection:\n");
1194                 printf("Trying port %d\n", port - 10);
1195                 CUpDownClient* client = new CUpDownClient(port-10,kad_ip,0,0,NULL,false,false);
1196                 client->SetConnectionReason(wxT("Error on ") + place);
1197                 client->TryToConnect(true);
1198         }
1199 #else
1200         // No need for warnings for the rest of us.
1201         (void)place;
1202         (void)kad_ip;
1203         (void)port;
1204         (void)data;
1205         (void)len;
1206 #endif
1207 }
1208 // File_checked_for_headers