src/DownloadClient.cpp

   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 "updownclient.h"       // Interface declarations
  27
  28 #include <protocol/Protocols.h>
  29 #include <protocol/ed2k/Client2Client/TCP.h>
  30 #include <protocol/ed2k/Client2Client/UDP.h>
  31 #include <common/EventIDs.h>
  32 #include <common/Macros.h>
  33 #include <common/Constants.h>
  34
  35 #include <zlib.h>
  36 #include <cmath>                // Needed for std:exp
  37
  38 #include "ClientCredits.h"      // Needed for CClientCredits
  39 #include "ClientUDPSocket.h"    // Needed for CClientUDPSocket
  40 #include "DownloadQueue.h"      // Needed for CDownloadQueue
  41 #include "Preferences.h"        // Needed for thePrefs
  42 #include "Packet.h"             // Needed for CPacket
  43 #include "MemFile.h"            // Needed for CMemFile
  44 #include "ClientTCPSocket.h"// Needed for CClientTCPSocket
  45 #include "ListenSocket.h"       // Needed for CListenSocket
  46 #include "amule.h"              // Needed for theApp
  47 #include "PartFile.h"           // Needed for CPartFile
  48 #include "SharedFileList.h"
  49 #include "Statistics.h"         // Needed for theStats
  50 #include "Logger.h"
  51 #include "GuiEvents.h"          // Needed for Notify_*
  52
  53
  54 #ifdef __MULE_UNUSED_CODE__
  55 // This function is left as a reminder.
  56 // Changes here _must_ be reflected in CClientList::FindMatchingClient.
  57 bool CUpDownClient::Compare(const CUpDownClient* tocomp, bool bIgnoreUserhash) const
  58 {
  59         if (!tocomp) {
  60                 // should we wxASSERT here?
  61                 return false;
  62         }
  63
  64         //Compare only the user hash..
  65         if(!bIgnoreUserhash && HasValidHash() && tocomp->HasValidHash()) {
  66             return GetUserHash() == tocomp->GetUserHash();
  67         }
  68
  69         if (HasLowID()) {
  70                 //User is firewalled.. Must do two checks..
  71                 if (GetIP()!=0  && GetIP() == tocomp->GetIP()) {
  72                         //The IP of both match
  73                         if (GetUserPort()!=0 && GetUserPort() == tocomp->GetUserPort()) {
  74                                 //IP-UserPort matches
  75                                 return true;
  76                         }
  77                         if (GetKadPort()!=0     && GetKadPort() == tocomp->GetKadPort()) {
  78                                 //IP-KadPort Matches
  79                                 return true;
  80                         }
  81                 }
  82
  83                 if (GetUserIDHybrid()!=0
  84                                                 && GetUserIDHybrid() == tocomp->GetUserIDHybrid()
  85                                                 && GetServerIP()!=0
  86                                                 && GetServerIP() == tocomp->GetServerIP()
  87                                                 && GetServerPort()!=0
  88                                                 && GetServerPort() == tocomp->GetServerPort()) {
  89                         //Both have the same lowID, Same serverIP and Port..
  90                         return true;
  91                 }
  92
  93                 //Both IP, and Server do not match..
  94                 return false;
  95     }
  96
  97         //User is not firewalled.
  98         if (GetUserPort()!=0) {
  99                 //User has a Port, lets check the rest.
 100                 if (GetIP() != 0 && tocomp->GetIP() != 0) {
 101                         //Both clients have a verified IP..
 102                         if(GetIP() == tocomp->GetIP() && GetUserPort() == tocomp->GetUserPort()) {
 103                                 //IP and UserPort match..
 104                                 return true;
 105                         }
 106                 } else {
 107                         //One of the two clients do not have a verified IP
 108                         if (GetUserIDHybrid() == tocomp->GetUserIDHybrid() && GetUserPort() == tocomp->GetUserPort()) {
 109                                 //ID and Port Match..
 110                                 return true;
 111                         }
 112                 }
 113     }
 114
 115         if(GetKadPort()!=0) {
 116                 //User has a Kad Port.
 117                 if(GetIP() != 0 && tocomp->GetIP() != 0) {
 118                         //Both clients have a verified IP.
 119                         if(GetIP() == tocomp->GetIP() && GetKadPort() == tocomp->GetKadPort()) {
 120                                 //IP and KadPort Match..
 121                                 return true;
 122                         }
 123                 } else {
 124                         //One of the users do not have a verified IP.
 125                         if (GetUserIDHybrid() == tocomp->GetUserIDHybrid() && GetKadPort() == tocomp->GetKadPort()) {
 126                                 //ID and KadProt Match..
 127                                 return true;
 128                         }
 129                 }
 130         }
 131
 132         //No Matches..
 133         return false;
 134 }
 135 #endif
 136
 137
 138 bool CUpDownClient::AskForDownload()
 139 {
 140         // 0.42e
 141         if (theApp->listensocket->TooManySockets()) {
 142                 if (!m_socket) {
 143                         if (GetDownloadState() != DS_TOOMANYCONNS) {
 144                                 SetDownloadState(DS_TOOMANYCONNS);
 145                         }
 146                         return true;
 147                 } else if (!m_socket->IsConnected()) {
 148                         if (GetDownloadState() != DS_TOOMANYCONNS) {
 149                                 SetDownloadState(DS_TOOMANYCONNS);
 150                         }
 151                         return true;
 152                 }
 153         }
 154         m_bUDPPending = false;
 155         m_dwLastAskedTime = ::GetTickCount();
 156         SetDownloadState(DS_CONNECTING);
 157         return TryToConnect();
 158 }
 159
 160
 161 void CUpDownClient::SendStartupLoadReq()
 162 {
 163         // 0.42e
 164         if (m_socket==NULL || m_reqfile==NULL) {
 165                 return;
 166         }
 167         SetDownloadState(DS_ONQUEUE);
 168         CMemFile dataStartupLoadReq(16);
 169         dataStartupLoadReq.WriteHash(m_reqfile->GetFileHash());
 170         CPacket* packet = new CPacket(dataStartupLoadReq, OP_EDONKEYPROT, OP_STARTUPLOADREQ);
 171         theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 172         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_STARTUPLOADREQ to ") + GetFullIP());
 173         SendPacket(packet, true, true);
 174 }
 175
 176
 177 bool CUpDownClient::IsSourceRequestAllowed()
 178 {
 179         //#warning REWRITE - Source swapping from eMule.
 180         // 0.42e
 181         uint32 dwTickCount = ::GetTickCount() + CONNECTION_LATENCY;
 182         uint32 nTimePassedClient = dwTickCount - GetLastSrcAnswerTime();
 183         uint32 nTimePassedFile   = dwTickCount - m_reqfile->GetLastAnsweredTime();
 184         bool bNeverAskedBefore = (GetLastAskedForSources() == 0);
 185
 186         uint32 uSources = m_reqfile->GetSourceCount();
 187         return (
 188                 // if client has the correct extended protocol
 189                 ExtProtocolAvailable() && (SupportsSourceExchange2() || GetSourceExchange1Version() > 1) &&
 190                 // AND if we need more sources
 191                 thePrefs::GetMaxSourcePerFileSoft() > uSources &&
 192                 // AND if...
 193                 (
 194                 //source is not complete and file is very rare
 195                         ( !m_bCompleteSource
 196                         && (bNeverAskedBefore || nTimePassedClient > SOURCECLIENTREASKS)
 197                         && (uSources <= RARE_FILE/5)
 198                         ) ||
 199                         //source is not complete and file is rare
 200                         ( !m_bCompleteSource
 201                         && (bNeverAskedBefore || nTimePassedClient > SOURCECLIENTREASKS)
 202                         && (uSources <= RARE_FILE || uSources - m_reqfile->GetValidSourcesCount() <= RARE_FILE / 2)
 203                         && (nTimePassedFile > SOURCECLIENTREASKF)
 204                         ) ||
 205                         // OR if file is not rare
 206                         ( (bNeverAskedBefore || nTimePassedClient > (unsigned)(SOURCECLIENTREASKS * MINCOMMONPENALTY))
 207                         && (nTimePassedFile > (unsigned)(SOURCECLIENTREASKF * MINCOMMONPENALTY))
 208                         )
 209                 )
 210         );
 211 }
 212
 213
 214 void CUpDownClient::SendFileRequest()
 215 {
 216         wxCHECK_RET(m_reqfile, wxT("Cannot request file when no reqfile is set"));
 217
 218         CMemFile dataFileReq(16+16);
 219         dataFileReq.WriteHash(m_reqfile->GetFileHash());
 220
 221         if (SupportMultiPacket()) {
 222                 wxString sent_opcodes;
 223
 224                 if (SupportExtMultiPacket()) {
 225                         dataFileReq.WriteUInt64(m_reqfile->GetFileSize());
 226                 }
 227
 228                 AddDebugLogLineM(false, logClient, wxT("Sending file request to client"));
 229
 230                 dataFileReq.WriteUInt8(OP_REQUESTFILENAME);
 231                 sent_opcodes += wxT("|RFNM|");
 232                 // Extended information
 233                 if (GetExtendedRequestsVersion() > 0) {
 234                         m_reqfile->WritePartStatus(&dataFileReq);
 235                 }
 236                 if (GetExtendedRequestsVersion() > 1) {
 237                         m_reqfile->WriteCompleteSourcesCount(&dataFileReq);
 238                 }
 239                 if (m_reqfile->GetPartCount() > 1) {
 240                         sent_opcodes += wxT("|RFID|");
 241                         dataFileReq.WriteUInt8(OP_SETREQFILEID);
 242                 }
 243                 if (IsEmuleClient()) {
 244                         SetRemoteQueueFull( true );
 245                         SetRemoteQueueRank(0);
 246                 }
 247                 if (IsSourceRequestAllowed()) {
 248                         if (SupportsSourceExchange2()){
 249                                 sent_opcodes += wxT("|RSRC2|");
 250                                 dataFileReq.WriteUInt8(OP_REQUESTSOURCES2);
 251                                 dataFileReq.WriteUInt8(SOURCEEXCHANGE2_VERSION);
 252                                 const uint16 nOptions = 0; // 16 ... Reserved
 253                                 dataFileReq.WriteUInt16(nOptions);
 254                         } else{
 255                                 sent_opcodes += wxT("|RSRC|");
 256                                 dataFileReq.WriteUInt8(OP_REQUESTSOURCES);
 257                         }
 258                         m_reqfile->SetLastAnsweredTimeTimeout();
 259                         SetLastAskedForSources();
 260                 }
 261                 if (IsSupportingAICH()) {
 262                         sent_opcodes += wxT("|AFHR|");
 263                         dataFileReq.WriteUInt8(OP_AICHFILEHASHREQ);
 264                 }
 265                 CPacket* packet = new CPacket(dataFileReq, OP_EMULEPROT, (SupportExtMultiPacket() ? OP_MULTIPACKET_EXT : OP_MULTIPACKET));
 266                 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 267                 AddDebugLogLineM( false, logLocalClient, wxString::Format(wxT("Local Client: %s "), (SupportExtMultiPacket() ? wxT("OP_MULTIPACKET_EXT (") : wxT("OP_MULTIPACKET (") )) + sent_opcodes + wxT(") to ") + GetFullIP());
 268                 SendPacket(packet, true);
 269         } else {
 270                 //This is extended information
 271                 if (GetExtendedRequestsVersion() > 0 ) {
 272                         m_reqfile->WritePartStatus(&dataFileReq);
 273                 }
 274                 if (GetExtendedRequestsVersion() > 1 ) {
 275                         m_reqfile->WriteCompleteSourcesCount(&dataFileReq);
 276                 }
 277                 CPacket* packet = new CPacket(dataFileReq, OP_EDONKEYPROT, OP_REQUESTFILENAME);
 278                 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 279                 AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_REQUESTFILENAME to ") + GetFullIP() );
 280                 SendPacket(packet, true);
 281
 282                 // 26-Jul-2003: removed requesting the file status for files <= PARTSIZE for better compatibility with ed2k protocol (eDonkeyHybrid).
 283                 // if the remote client answers the OP_REQUESTFILENAME with OP_REQFILENAMEANSWER the file is shared by the remote client. if we
 284                 // know that the file is shared, we know also that the file is complete and don't need to request the file status.
 285
 286                 // Sending the packet could have deleted the client, check m_reqfile
 287                 if (m_reqfile && (m_reqfile->GetPartCount() > 1)) {
 288                         CMemFile dataSetReqFileID(16);
 289                         dataSetReqFileID.WriteHash(m_reqfile->GetFileHash());
 290                         packet = new CPacket(dataSetReqFileID, OP_EDONKEYPROT, OP_SETREQFILEID);
 291                         theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 292                         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_SETREQFILEID to ") + GetFullIP());
 293                         SendPacket(packet, true);
 294                 }
 295
 296                 if (IsEmuleClient()) {
 297                         SetRemoteQueueFull( true );
 298                         SetRemoteQueueRank(0);
 299                 }
 300
 301                 // Sending the packet could have deleted the client, check m_reqfile
 302                 if (m_reqfile && IsSourceRequestAllowed()) {
 303                         m_reqfile->SetLastAnsweredTimeTimeout();
 304
 305                         CMemFile packetdata;
 306
 307                         if (SupportsSourceExchange2()) {
 308                                 packetdata.WriteUInt8(SOURCEEXCHANGE2_VERSION);
 309                                 packetdata.WriteUInt16(0 /* Reserved */);
 310                         }
 311
 312                         packetdata.WriteHash(m_reqfile->GetFileHash());
 313
 314                         packet = new CPacket(packetdata, OP_EMULEPROT, SupportsSourceExchange2() ? OP_REQUESTSOURCES2 : OP_REQUESTSOURCES);
 315
 316                         theStats::AddUpOverheadSourceExchange(packet->GetPacketSize());
 317                         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_REQUESTSOURCES to ") + GetFullIP() );
 318                         SendPacket(packet,true,true);
 319                         SetLastAskedForSources();
 320                 }
 321
 322                 // Sending the packet could have deleted the client, check m_reqfile
 323                 if (m_reqfile && IsSupportingAICH()) {
 324                         packet = new CPacket(OP_AICHFILEHASHREQ,16,OP_EMULEPROT);
 325                         packet->Copy16ToDataBuffer((const char *)m_reqfile->GetFileHash().GetHash());
 326                         theStats::AddUpOverheadOther(packet->GetPacketSize());
 327                         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_AICHFILEHASHREQ to ") + GetFullIP());
 328                         SendPacket(packet,true,true);
 329                 }
 330         }
 331 }
 332
 333
 334 void CUpDownClient::ProcessFileInfo(const CMemFile* data, const CPartFile* file)
 335 {
 336         // 0.42e
 337         if (file==NULL) {
 338                 throw wxString(wxT("ERROR: Wrong file ID (ProcessFileInfo; file==NULL)"));
 339         }
 340         if (m_reqfile==NULL) {
 341                 throw wxString(wxT("ERROR: Wrong file ID (ProcessFileInfo; m_reqfile==NULL)"));
 342         }
 343         if (file != m_reqfile) {
 344                 throw wxString(wxT("ERROR: Wrong file ID (ProcessFileInfo; m_reqfile!=file)"));
 345         }
 346
 347         m_clientFilename = data->ReadString((GetUnicodeSupport() != utf8strNone));
 348
 349         // 26-Jul-2003: removed requesting the file status for files <= PARTSIZE for better compatibility with ed2k protocol (eDonkeyHybrid).
 350         // if the remote client answers the OP_REQUESTFILENAME with OP_REQFILENAMEANSWER the file is shared by the remote client. if we
 351         // know that the file is shared, we know also that the file is complete and don't need to request the file status.
 352         if (m_reqfile->GetPartCount() == 1) {
 353                 m_nPartCount = m_reqfile->GetPartCount();
 354
 355                 m_reqfile->UpdatePartsFrequency( this, false ); // Decrement
 356                 m_downPartStatus.clear();
 357                 m_downPartStatus.resize( m_nPartCount, 1 );
 358                 m_reqfile->UpdatePartsFrequency( this, true );  // Increment
 359
 360                 m_bCompleteSource = true;
 361
 362                 UpdateDisplayedInfo();
 363                 // even if the file is <= PARTSIZE, we _may_ need the hashset for that file (if the file size == PARTSIZE)
 364                 if (m_reqfile->IsHashSetNeeded()) {
 365                         if (m_socket) {
 366                                 CPacket* packet = new CPacket(OP_HASHSETREQUEST,16, OP_EDONKEYPROT);
 367                                 packet->Copy16ToDataBuffer((const char *)m_reqfile->GetFileHash().GetHash());
 368                                 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 369                                 AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_HASHSETREQUEST to ") + GetFullIP());
 370                                 SendPacket(packet,true,true);
 371                                 SetDownloadState(DS_REQHASHSET);
 372                                 m_fHashsetRequesting = 1;
 373                                 m_reqfile->SetHashSetNeeded(false);
 374                         } else {
 375                                 wxFAIL;
 376                         }
 377                 } else {
 378                         SendStartupLoadReq();
 379                 }
 380                 m_reqfile->UpdatePartsInfo();
 381         }
 382 }
 383
 384 void CUpDownClient::ProcessFileStatus(bool bUdpPacket, const CMemFile* data, const CPartFile* file)
 385 {
 386         // 0.42e
 387         wxString strReqFileNull(wxT("ERROR: Wrong file ID (ProcessFileStatus; m_reqfile==NULL)"));
 388
 389         if ( !m_reqfile || file != m_reqfile ){
 390                 if (!m_reqfile) {
 391                         throw strReqFileNull;
 392                 }
 393                 throw wxString(wxT("ERROR: Wrong file ID (ProcessFileStatus; m_reqfile!=file)"));
 394         }
 395
 396         uint16 nED2KPartCount = data->ReadUInt16();
 397
 398         m_reqfile->UpdatePartsFrequency( this, false ); // Decrement
 399         m_downPartStatus.clear();
 400
 401         bool bPartsNeeded = false;
 402         int iNeeded = 0;
 403         if (!nED2KPartCount)
 404         {
 405                 m_nPartCount = m_reqfile->GetPartCount();
 406                 m_downPartStatus.resize( m_nPartCount, 1);
 407                 bPartsNeeded = true;
 408                 m_bCompleteSource = true;
 409         }
 410         else
 411         {
 412                 // Somehow this happened.
 413                 if (!m_reqfile) {
 414                         throw strReqFileNull;
 415                 }
 416                 if (m_reqfile->GetED2KPartCount() != nED2KPartCount)
 417                 {
 418                         wxString strError;
 419                         strError << wxT("ProcessFileStatus - wrong part number recv=") << nED2KPartCount <<
 420                                 wxT("  expected=") << m_reqfile->GetED2KPartCount() << wxT(" ") <<
 421                                 m_reqfile->GetFileHash().Encode();
 422                         m_nPartCount = 0;
 423                         throw strError;
 424                 }
 425                 m_nPartCount = m_reqfile->GetPartCount();
 426
 427                 m_bCompleteSource = false;
 428                 m_downPartStatus.resize( m_nPartCount, 0 );
 429                 uint16 done = 0;
 430
 431                 try {
 432                         while (done != m_nPartCount) {
 433                                 uint8 toread = data->ReadUInt8();
 434
 435                                 for ( uint8 i = 0;i < 8; i++ ) {
 436                                         m_downPartStatus[done] = ((toread>>i)&1)? 1:0;
 437
 438                                         if ( m_downPartStatus[done] ) {
 439                                                 if (!m_reqfile->IsComplete(done)){
 440                                                         bPartsNeeded = true;
 441                                                         iNeeded++;
 442                                                 }
 443                                         }
 444                                         done++;
 445                                         if (done == m_nPartCount) {
 446                                                 break;
 447                                         }
 448                                 }
 449                         }
 450                 } catch( ... ) {
 451                         // We want the counts to be updated, even if we fail to read everything
 452                         m_reqfile->UpdatePartsFrequency( this, true );  // Increment
 453
 454                         throw;
 455                 }
 456         }
 457
 458         m_reqfile->UpdatePartsFrequency( this, true );  // Increment
 459
 460         UpdateDisplayedInfo();
 461
 462         // NOTE: This function is invoked from TCP and UDP socket!
 463         if (!bUdpPacket) {
 464                 if (!bPartsNeeded) {
 465                         SetDownloadState(DS_NONEEDEDPARTS);
 466                 } else if (m_reqfile->IsHashSetNeeded()) {
 467                         //If we are using the eMule filerequest packets, this is taken care of in the Multipacket!
 468                         if (m_socket) {
 469                                 CPacket* packet = new CPacket(OP_HASHSETREQUEST,16, OP_EDONKEYPROT);
 470                                 packet->Copy16ToDataBuffer((const char *)m_reqfile->GetFileHash().GetHash());
 471                                 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 472                                 AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_HASHSETREQUEST to ") + GetFullIP());
 473                                 SendPacket(packet, true, true);
 474                                 SetDownloadState(DS_REQHASHSET);
 475                                 m_fHashsetRequesting = 1;
 476                                 m_reqfile->SetHashSetNeeded(false);
 477                         } else {
 478                                 wxFAIL;
 479                         }
 480                 }
 481                 else {
 482                         SendStartupLoadReq();
 483                 }
 484         }
 485         else {
 486                 if (!bPartsNeeded) {
 487                         SetDownloadState(DS_NONEEDEDPARTS);
 488                 } else {
 489                         SetDownloadState(DS_ONQUEUE);
 490                 }
 491         }
 492         m_reqfile->UpdatePartsInfo();
 493 }
 494
 495 bool CUpDownClient::AddRequestForAnotherFile(CPartFile* file)
 496 {
 497         if ( m_A4AF_list.find( file ) == m_A4AF_list.end() ) {
 498                 // When we access a non-existing entry entry, it will be zeroed by default,
 499                 // so we have to set NeededParts. All in one go.
 500                 m_A4AF_list[file].NeededParts = true;
 501                 file->AddA4AFSource( this );
 502                 return true;
 503         } else {
 504                 return false;
 505         }
 506 }
 507
 508 bool CUpDownClient::DeleteFileRequest(CPartFile* file)
 509 {
 510         return (m_A4AF_list.erase( file ) > 0);
 511 }
 512
 513 void CUpDownClient::DeleteAllFileRequests()
 514 {
 515         m_A4AF_list.clear();
 516 }
 517
 518
 519 /* eMule 0.30c implementation, i give it a try (Creteil) BEGIN ... */
 520 void CUpDownClient::SetDownloadState(uint8 byNewState)
 521 {
 522         if (m_nDownloadState != byNewState) {
 523                 if (m_reqfile) {
 524                         // Notify the client that this source has changed its state
 525                         m_reqfile->ClientStateChanged( m_nDownloadState, byNewState );
 526
 527                         if (byNewState == DS_DOWNLOADING) {
 528                                 m_reqfile->AddDownloadingSource(this);
 529                         } else if (m_nDownloadState == DS_DOWNLOADING) {
 530                                 m_reqfile->RemoveDownloadingSource(this);
 531                         }
 532                 }
 533                 if (byNewState == DS_DOWNLOADING) {
 534                         msReceivedPrev = GetTickCount();
 535                         theStats::AddDownloadingSource();
 536                 } else if (m_nDownloadState == DS_DOWNLOADING) {
 537                         theStats::RemoveDownloadingSource();
 538                 }
 539
 540                 if (m_nDownloadState == DS_DOWNLOADING) {
 541                         m_nDownloadState = byNewState;
 542                         ClearDownloadBlockRequests();
 543
 544                         kBpsDown = 0.0;
 545                         bytesReceivedCycle = 0;
 546                         msReceivedPrev = 0;
 547                         if (byNewState == DS_NONE) {
 548                                 if (m_reqfile) {
 549                                         m_reqfile->UpdatePartsFrequency( this, false ); // Decrement
 550                                 }
 551                                 m_downPartStatus.clear();
 552                                 m_nPartCount = 0;
 553                         }
 554                         if (m_socket && byNewState != DS_ERROR) {
 555                                 m_socket->DisableDownloadLimit();
 556                         }
 557                 }
 558                 m_nDownloadState = byNewState;
 559                 if(GetDownloadState() == DS_DOWNLOADING) {
 560                         if (IsEmuleClient()) {
 561                                 SetRemoteQueueFull(false);
 562                         }
 563                         SetRemoteQueueRank(0); // eMule 0.30c set like this ...
 564                 }
 565                 UpdateDisplayedInfo(true);
 566         }
 567 }
 568 /* eMule 0.30c implementation, i give it a try (Creteil) END ... */
 569
 570 void CUpDownClient::ProcessHashSet(const byte* packet, uint32 size)
 571 {
 572         if ((!m_reqfile) || md4cmp(packet,m_reqfile->GetFileHash().GetHash())) {
 573                 throw wxString(wxT("Wrong fileid sent (ProcessHashSet)"));
 574         }
 575         if (!m_fHashsetRequesting) {
 576                 throw wxString(wxT("Received unsolicited hashset, ignoring it."));
 577         }
 578         CMemFile data(packet,size);
 579         if (m_reqfile->LoadHashsetFromFile(&data,true)) {
 580                 m_fHashsetRequesting = 0;
 581         } else {
 582                 m_reqfile->SetHashSetNeeded(true);
 583                 throw wxString(wxT("Corrupted or invalid hashset received"));
 584         }
 585         SendStartupLoadReq();
 586 }
 587
 588 void CUpDownClient::SendBlockRequests()
 589 {
 590         uint32 current_time = ::GetTickCount();
 591         if (GetVBTTags()) {
 592
 593                 // Ask new blocks only when all completed
 594                 if (m_PendingBlocks_list.size()) {
 595                         return;
 596                 }
 597
 598                 if ((m_dwLastBlockReceived + SEC2MS(5)) > current_time) {
 599                         // We received last block in less than 5 secs? Let's request faster.
 600                         m_MaxBlockRequests = m_MaxBlockRequests << 1;
 601                         if ( m_MaxBlockRequests > 0x20) {
 602                                 m_MaxBlockRequests = 0x20;
 603                         }
 604                 } else {
 605                         m_MaxBlockRequests = m_MaxBlockRequests >> 1;
 606                         if ( m_MaxBlockRequests < STANDARD_BLOCKS_REQUEST) {
 607                                 m_MaxBlockRequests = STANDARD_BLOCKS_REQUEST;
 608                         }
 609                 }
 610         }
 611
 612         m_dwLastBlockReceived = current_time;
 613
 614         if (!m_reqfile) {
 615                 return;
 616         }
 617
 618         uint8 version = GetVBTTags() ? 2 : 1;
 619
 620         if (m_DownloadBlocks_list.empty()) {
 621                 // Barry - instead of getting 3, just get how many is needed
 622                 uint16 count = m_MaxBlockRequests - m_PendingBlocks_list.size();
 623                 std::vector<Requested_Block_Struct*> toadd;
 624                 if (m_reqfile->GetNextRequestedBlock(this, toadd, count)) {
 625                         for (int i = 0; i != count; i++) {
 626                                 m_DownloadBlocks_list.push_back(toadd[i]);
 627                         }
 628                 }
 629         }
 630
 631         // Barry - Why are unfinished blocks requested again, not just new ones?
 632
 633         while (m_PendingBlocks_list.size() < m_MaxBlockRequests && !m_DownloadBlocks_list.empty()) {
 634                 Pending_Block_Struct* pblock = new Pending_Block_Struct;
 635                 pblock->block = m_DownloadBlocks_list.front();
 636                 pblock->zStream = NULL;
 637                 pblock->totalUnzipped = 0;
 638                 pblock->fZStreamError = 0;
 639                 pblock->fRecovered = 0;
 640                 m_PendingBlocks_list.push_back(pblock);
 641                 m_DownloadBlocks_list.pop_front();
 642         }
 643
 644
 645         if (m_PendingBlocks_list.empty()) {
 646
 647                 CUpDownClient* slower_client = NULL;
 648
 649                 if (thePrefs::GetDropSlowSources()) {
 650                         slower_client = m_reqfile->GetSlowerDownloadingClient(m_lastaverage, this);
 651                 }
 652
 653                 if (slower_client == NULL) {
 654                         slower_client = this;
 655                 }
 656
 657                 if (!slower_client->GetSentCancelTransfer()) {
 658                         CPacket* packet = new CPacket(OP_CANCELTRANSFER, 0, OP_EDONKEYPROT);
 659                         theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 660                         if (slower_client != this) {
 661 //                              printf("Dropped client %p to allow client %p to download\n",slower_client, this);
 662                         }
 663                         slower_client->ClearDownloadBlockRequests();
 664                         slower_client->SendPacket(packet,true,true);
 665                         slower_client->SetSentCancelTransfer(1);
 666                 }
 667
 668                 slower_client->SetDownloadState(DS_NONEEDEDPARTS);
 669
 670                 if (slower_client != this) {
 671                         // Re-request freed blocks.
 672                         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_CANCELTRANSFER (faster source eager to transfer) to ") + slower_client->GetFullIP() );
 673                         wxASSERT(m_DownloadBlocks_list.empty());
 674                         wxASSERT(m_PendingBlocks_list.empty());
 675                         uint16 count = m_MaxBlockRequests;
 676                         std::vector<Requested_Block_Struct*> toadd;
 677                         if (m_reqfile->GetNextRequestedBlock(this, toadd, count)) {
 678                                 for (int i = 0; i != count; i++) {
 679                                         Pending_Block_Struct* pblock = new Pending_Block_Struct;
 680                                         pblock->block = toadd[i];
 681                                         pblock->zStream = NULL;
 682                                         pblock->totalUnzipped = 0;
 683                                         pblock->fZStreamError = 0;
 684                                         pblock->fRecovered = 0;
 685                                         m_PendingBlocks_list.push_back(pblock);
 686                                 }
 687                         }       else {
 688                                 // WTF, we just freed blocks.
 689                                 wxFAIL;
 690                                 return;
 691                         }
 692                 } else {
 693                         // Drop this one.
 694                         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_CANCELTRANSFER (no free blocks) to ") + GetFullIP() );
 695                         //#warning Kry - Would be nice to swap A4AF here.
 696                         return;
 697                 }
 698         }
 699
 700         CPacket* packet = NULL;
 701
 702         switch (version) {
 703                 case 2: {
 704                         // ED2Kv2 packet...
 705                         // Most common scenario: hash + blocks to request + every one
 706                         // having 2 uint32 tags
 707
 708                         uint8 nBlocks = m_PendingBlocks_list.size();
 709                         if (nBlocks > m_MaxBlockRequests) {
 710                                 nBlocks = m_MaxBlockRequests;
 711                         }
 712
 713                         CMemFile data(16 + 1 + nBlocks*((2+4)*2));
 714
 715                         data.WriteHash(m_reqfile->GetFileHash());
 716
 717                         data.WriteUInt8(nBlocks);
 718
 719                         std::list<Pending_Block_Struct*>::iterator it = m_PendingBlocks_list.begin();
 720                         while (nBlocks) {
 721                                 wxASSERT(it != m_PendingBlocks_list.end());
 722                                 wxASSERT( (*it)->block->StartOffset <= (*it)->block->EndOffset );
 723                                 (*it)->fZStreamError = 0;
 724                                 (*it)->fRecovered = 0;
 725                                 CTagVarInt(/*Noname*/0,(*it)->block->StartOffset).WriteTagToFile(&data);
 726                                 CTagVarInt(/*Noname*/0,(*it)->block->EndOffset).WriteTagToFile(&data);
 727                                 ++it;
 728                                 nBlocks--;
 729                         }
 730
 731                         packet = new CPacket(data, OP_ED2KV2HEADER, OP_REQUESTPARTS);
 732                         AddDebugLogLineM( false, logLocalClient, wxString::Format(wxT("Local Client ED2Kv2: OP_REQUESTPARTS(%i) to "),(m_PendingBlocks_list.size()<m_MaxBlockRequests) ? m_PendingBlocks_list.size() : m_MaxBlockRequests) + GetFullIP() );
 733
 734                         break;
 735                 }
 736                 case 1: {
 737                         wxASSERT(m_MaxBlockRequests == STANDARD_BLOCKS_REQUEST);
 738
 739                         //#warning Kry - I dont specially like this approach, we iterate one time too many
 740
 741                         bool bHasLongBlocks =  false;
 742
 743                         std::list<Pending_Block_Struct*>::iterator it = m_PendingBlocks_list.begin();
 744                         for (uint32 i = 0; i != m_MaxBlockRequests; i++){
 745                                 if (it != m_PendingBlocks_list.end()) {
 746                                         Pending_Block_Struct* pending = *it++;
 747                                         wxASSERT( pending->block->StartOffset <= pending->block->EndOffset );
 748                                         if (pending->block->StartOffset > 0xFFFFFFFF || pending->block->EndOffset > 0xFFFFFFFF){
 749                                                 bHasLongBlocks = true;
 750                                                 if (!SupportsLargeFiles()){
 751                                                         // Requesting a large block from a client that doesn't support large files?
 752                                                         wxFAIL;
 753                                                         if (!GetSentCancelTransfer()){
 754                                                                 CPacket* cancel_packet = new CPacket(OP_CANCELTRANSFER, 0, OP_EDONKEYPROT);
 755                                                                 theStats::AddUpOverheadFileRequest(cancel_packet->GetPacketSize());
 756                                                                 AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_CANCELTRANSFER to ") + GetFullIP() );
 757                                                                 SendPacket(cancel_packet,true,true);
 758                                                                 SetSentCancelTransfer(1);
 759                                                         }
 760                                                         SetDownloadState(DS_ERROR);
 761                                                 }
 762                                                 break;
 763                                         }
 764                                 }
 765                         }
 766
 767                         CMemFile data(16 /*Hash*/ + (m_MaxBlockRequests*(bHasLongBlocks ? 8 : 4) /* uint32/64 start*/) + (3*(bHasLongBlocks ? 8 : 4)/* uint32/64 end*/));
 768                         data.WriteHash(m_reqfile->GetFileHash());
 769
 770                         it = m_PendingBlocks_list.begin();
 771                         for (uint32 i = 0; i != m_MaxBlockRequests; i++) {
 772                                 if (it != m_PendingBlocks_list.end()) {
 773                                         Pending_Block_Struct* pending = *it++;
 774                                         wxASSERT( pending->block->StartOffset <= pending->block->EndOffset );
 775                                         pending->fZStreamError = 0;
 776                                         pending->fRecovered = 0;
 777                                         if (bHasLongBlocks) {
 778                                                 data.WriteUInt64(pending->block->StartOffset);
 779                                         } else {
 780                                                 data.WriteUInt32(pending->block->StartOffset);
 781                                         }
 782                                 } else {
 783                                         if (bHasLongBlocks) {
 784                                                 data.WriteUInt64(0);
 785                                         } else {
 786                                                 data.WriteUInt32(0);
 787                                         }
 788                                 }
 789                         }
 790
 791                         it = m_PendingBlocks_list.begin();
 792                         for (uint32 i = 0; i != m_MaxBlockRequests; i++) {
 793                                 if (it != m_PendingBlocks_list.end()) {
 794                                         Requested_Block_Struct* block = (*it++)->block;
 795                                         if (bHasLongBlocks) {
 796                                                 data.WriteUInt64(block->EndOffset+1);
 797                                         } else {
 798                                                 data.WriteUInt32(block->EndOffset+1);
 799                                         }
 800                                 } else {
 801                                         if (bHasLongBlocks) {
 802                                                 data.WriteUInt64(0);
 803                                         } else {
 804                                                 data.WriteUInt32(0);
 805                                         }
 806                                 }
 807                         }
 808                         packet = new CPacket(data, (bHasLongBlocks ? OP_EMULEPROT : OP_EDONKEYPROT), (bHasLongBlocks ? (uint8)OP_REQUESTPARTS_I64 : (uint8)OP_REQUESTPARTS));
 809                         AddDebugLogLineM( false, logLocalClient, wxString::Format(wxT("Local Client: %s to "),(bHasLongBlocks ? wxT("OP_REQUESTPARTS_I64") : wxT("OP_REQUESTPARTS"))) + GetFullIP() );
 810                         break;
 811                 }
 812                 default:
 813                         wxFAIL;
 814         }
 815
 816         if (packet) {
 817                 theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
 818                 SendPacket(packet, true, true);
 819         } else {
 820                 wxFAIL;
 821         }
 822 }
 823
 824 /*
 825 Barry - Originally this only wrote to disk when a full 180k block
 826 had been received from a client, and only asked for data in
 827 180k blocks.
 828
 829 This meant that on average 90k was lost for every connection
 830 to a client data source. That is a lot of wasted data.
 831
 832 To reduce the lost data, packets are now written to a buffer
 833 and flushed to disk regularly regardless of size downloaded.
 834
 835 This includes compressed packets.
 836
 837 Data is also requested only where gaps are, not in 180k blocks.
 838 The requests will still not exceed 180k, but may be smaller to
 839 fill a gap.
 840 */
 841
 842 void CUpDownClient::ProcessBlockPacket(const byte* packet, uint32 size, bool packed, bool largeblocks)
 843 {
 844         // Ignore if no data required
 845         if (!(GetDownloadState() == DS_DOWNLOADING || GetDownloadState() == DS_NONEEDEDPARTS)) {
 846                 return;
 847         }
 848
 849         // This vars are defined here to be able to use them on the catch
 850         int header_size = 16;
 851         uint64 nStartPos = 0;
 852         uint64 nEndPos = 0;
 853         uint32 nBlockSize = 0;
 854         uint32 lenUnzipped = 0;
 855
 856         // Update stats
 857         m_dwLastBlockReceived = ::GetTickCount();
 858
 859         try {
 860
 861                 // Read data from packet
 862                 const CMemFile data(packet, size);
 863
 864                 // Check that this data is for the correct file
 865                 if ((!m_reqfile) || data.ReadHash() != m_reqfile->GetFileHash()) {
 866                         throw wxString(wxT("Wrong fileid sent (ProcessBlockPacket)"));
 867                 }
 868
 869                 // Find the start & end positions, and size of this chunk of data
 870
 871                 if (largeblocks) {
 872                         nStartPos = data.ReadUInt64();
 873                         header_size += 8;
 874                 } else {
 875                         nStartPos = data.ReadUInt32();
 876                         header_size += 4;
 877                 }
 878
 879                 if (packed) {
 880                         nBlockSize = data.ReadUInt32();
 881                         header_size += 4;
 882                         nEndPos = nStartPos + (size - header_size);
 883                 } else {
 884                         if (largeblocks) {
 885                                 nEndPos = data.ReadUInt64();
 886                                 header_size += 8;
 887                         } else {
 888                                 nEndPos = data.ReadUInt32();
 889                                 header_size += 4;
 890                         }
 891                 }
 892
 893                 // Check that packet size matches the declared data size + header size
 894                 if ( nEndPos == nStartPos || size != ((nEndPos - nStartPos) + header_size)) {
 895                         throw wxString(wxT("Corrupted or invalid DataBlock received (ProcessBlockPacket)"));
 896                 }
 897                 theStats::AddDownloadFromSoft(GetClientSoft(),size - header_size);
 898                 bytesReceivedCycle += size - header_size;
 899
 900                 credits->AddDownloaded(size - header_size, GetIP(), theApp->CryptoAvailable());
 901
 902                 // Move end back one, should be inclusive
 903                 nEndPos--;
 904
 905                 // Loop through to find the reserved block that this is within
 906                 std::list<Pending_Block_Struct*>::iterator it = m_PendingBlocks_list.begin();
 907                 for (; it != m_PendingBlocks_list.end(); ++it) {
 908                         Pending_Block_Struct* cur_block = *it;
 909
 910                         if ((cur_block->block->StartOffset <= nStartPos) && (cur_block->block->EndOffset >= nStartPos)) {
 911                                 // Found reserved block
 912
 913                                 if (cur_block->block->StartOffset == nStartPos) {
 914                                         // This block just started transfering. Set the start time.
 915                                         m_last_block_start = ::GetTickCountFullRes();
 916                                 }
 917
 918                                 if (cur_block->fZStreamError){
 919                                         AddDebugLogLineM( false, logZLib,
 920                                                 CFormat(wxT("Ignoring %u bytes of block %u-%u because of erroneous zstream state for file: %s"))
 921                                                         % (size - header_size) % nStartPos % nEndPos % m_reqfile->GetFileName());
 922                                         m_reqfile->RemoveBlockFromList(cur_block->block->StartOffset, cur_block->block->EndOffset);
 923                                         return;
 924                                 }
 925
 926                                 // Remember this start pos, used to draw part downloading in list
 927                                 m_nLastBlockOffset = nStartPos;
 928
 929                                 // Occasionally packets are duplicated, no point writing it twice
 930                                 // This will be 0 in these cases, or the length written otherwise
 931                                 uint32 lenWritten = 0;
 932
 933                                 // Handle differently depending on whether packed or not
 934                                 if (!packed) {
 935                                         // security sanitize check
 936                                         if (nEndPos > cur_block->block->EndOffset) {
 937                                                 AddDebugLogLineM(false, logRemoteClient, CFormat(wxT("Received Blockpacket exceeds requested boundaries (requested end: %u, Part: %u, received end: %u, Part: %u), file: %s remote IP: %s")) % cur_block->block->EndOffset % (uint32)(cur_block->block->EndOffset / PARTSIZE) % nEndPos % (uint32)(nEndPos / PARTSIZE) % m_reqfile->GetFileName() % Uint32toStringIP(GetIP()));
 938                                                 m_reqfile->RemoveBlockFromList(cur_block->block->StartOffset, cur_block->block->EndOffset);
 939                                                 return;
 940                                         }
 941                                         // Write to disk (will be buffered in part file class)
 942                                         lenWritten = m_reqfile->WriteToBuffer( size - header_size, (byte*)(packet + header_size), nStartPos, nEndPos, cur_block->block );
 943                                 } else {
 944                                         // Packed
 945                                         wxASSERT( (long int)size > 0 );
 946                                         // Create space to store unzipped data, the size is
 947                                         // only an initial guess, will be resized in unzip()
 948                                         // if not big enough
 949                                         lenUnzipped = (size * 2);
 950                                         // Don't get too big
 951                                         if (lenUnzipped > (BLOCKSIZE + 300)) {
 952                                                 lenUnzipped = (BLOCKSIZE + 300);
 953                                         }
 954                                         byte *unzipped = new byte[lenUnzipped];
 955
 956                                         // Try to unzip the packet
 957                                         int result = unzip(cur_block, (byte*)(packet + header_size), (size - header_size), &unzipped, &lenUnzipped);
 958
 959                                         // no block can be uncompressed to >2GB, 'lenUnzipped' is obviously erroneous.
 960                                         if (result == Z_OK && ((int)lenUnzipped >= 0)) {
 961
 962                                                 // Write any unzipped data to disk
 963                                                 if (lenUnzipped > 0) {
 964                                                         wxASSERT( (int)lenUnzipped > 0 );
 965
 966                                                         // Use the current start and end positions for the uncompressed data
 967                                                         nStartPos = cur_block->block->StartOffset + cur_block->totalUnzipped - lenUnzipped;
 968                                                         nEndPos = cur_block->block->StartOffset + cur_block->totalUnzipped - 1;
 969
 970                                                         if (nStartPos > cur_block->block->EndOffset || nEndPos > cur_block->block->EndOffset) {
 971                                                                 AddDebugLogLineM( false, logZLib,
 972                                                                         CFormat(wxT("Corrupted compressed packet for '%s' received (error 666)")) % m_reqfile->GetFileName());
 973                                                                 m_reqfile->RemoveBlockFromList(cur_block->block->StartOffset, cur_block->block->EndOffset);
 974                                                         } else {
 975                                                                 // Write uncompressed data to file
 976                                                                 lenWritten = m_reqfile->WriteToBuffer( size - header_size,
 977                                                                                                                                            unzipped,
 978                                                                                                                                            nStartPos,
 979                                                                                                                                            nEndPos,
 980                                                                                                                                            cur_block->block );
 981                                                         }
 982                                                 }
 983                                         } else {
 984                                                 wxString strZipError;
 985                                                 if (cur_block->zStream && cur_block->zStream->msg) {
 986                                                         strZipError = wxT(" - ") + wxString::FromAscii(cur_block->zStream->msg);
 987                                                 }
 988
 989                                                 AddDebugLogLineM( false, logZLib,
 990                                                         CFormat(wxT("Corrupted compressed packet for '%s' received (error %i): %s"))
 991                                                                 % m_reqfile->GetFileName() % result % strZipError);
 992
 993                                                 m_reqfile->RemoveBlockFromList(cur_block->block->StartOffset, cur_block->block->EndOffset);
 994
 995                                                 // If we had an zstream error, there is no chance that we could recover from it nor that we
 996                                                 // could use the current zstream (which is in error state) any longer.
 997                                                 if (cur_block->zStream){
 998                                                         inflateEnd(cur_block->zStream);
 999                                                         delete cur_block->zStream;
1000                                                         cur_block->zStream = NULL;
1001                                                 }
1002
1003                                                 // Although we can't further use the current zstream, there is no need to disconnect the sending
1004                                                 // client because the next zstream (a series of 10K-blocks which build a 180K-block) could be
1005                                                 // valid again. Just ignore all further blocks for the current zstream.
1006                                                 cur_block->fZStreamError = 1;
1007                                                 cur_block->totalUnzipped = 0; // bluecow's fix
1008                                         }
1009                                         delete [] unzipped;
1010                                 }
1011                                 // These checks only need to be done if any data was written
1012                                 if (lenWritten > 0) {
1013                                         m_nTransferredDown += lenWritten;
1014
1015                                         // If finished reserved block
1016                                         if (nEndPos == cur_block->block->EndOffset) {
1017
1018                                                 // Save last average speed based on data and time.
1019                                                 // This should do bytes/sec.
1020                                                 uint32 average_time = (::GetTickCountFullRes() - m_last_block_start);
1021
1022                                                 // Avoid divide by 0.
1023                                                 if (average_time == 0) {
1024                                                         average_time++;
1025                                                 }
1026
1027                                                 m_lastaverage = ((cur_block->block->EndOffset - cur_block->block->StartOffset) * 1000) / average_time;
1028
1029                                                 m_reqfile->RemoveBlockFromList(cur_block->block->StartOffset, cur_block->block->EndOffset);
1030                                                 delete cur_block->block;
1031                                                 // Not always allocated
1032                                                 if (cur_block->zStream) {
1033                                                         inflateEnd(cur_block->zStream);
1034                                                         delete cur_block->zStream;
1035                                                 }
1036                                                 delete cur_block;
1037                                                 m_PendingBlocks_list.erase(it);
1038
1039                                                 // Request next block
1040                                                 SendBlockRequests();
1041                                         }
1042                                 }
1043                                 // Stop looping and exit method
1044                                 return;
1045                         }
1046                 }
1047         } catch (const CEOFException& e) {
1048                 wxString error = wxString(wxT("Error reading "));
1049                 if (packed) error += wxString::Format(wxT("packed (LU: %i) "),lenUnzipped);
1050                 if (packed) error += wxT("largeblocks ");
1051                 error += wxString::Format(wxT("data packet: RS: %i HS: %i SP: %i EP: %i BS: %i -> "),size,header_size,nStartPos,nEndPos,nBlockSize);
1052                 AddDebugLogLineM(true, logRemoteClient, error + e.what());
1053                 return;
1054         }
1055 }
1056
1057 int CUpDownClient::unzip(Pending_Block_Struct *block, byte *zipped, uint32 lenZipped, byte **unzipped, uint32 *lenUnzipped, int iRecursion)
1058 {
1059         int err = Z_DATA_ERROR;
1060
1061         // Save some typing
1062         z_stream *zS = block->zStream;
1063
1064         // Is this the first time this block has been unzipped
1065         if (zS == NULL) {
1066                 // Create stream
1067                 block->zStream = new z_stream;
1068                 zS = block->zStream;
1069
1070                 // Initialise stream values
1071                 zS->zalloc = (alloc_func)0;
1072                 zS->zfree = (free_func)0;
1073                 zS->opaque = (voidpf)0;
1074
1075                 // Set output data streams, do this here to avoid overwriting on recursive calls
1076                 zS->next_out = (*unzipped);
1077                 zS->avail_out = (*lenUnzipped);
1078
1079                 // Initialise the z_stream
1080                 err = inflateInit(zS);
1081                 if (err != Z_OK) {
1082                         return err;
1083                 }
1084         }
1085
1086         // Use whatever input is provided
1087         zS->next_in  = zipped;
1088         zS->avail_in = lenZipped;
1089
1090         // Only set the output if not being called recursively
1091         if (iRecursion == 0) {
1092                 zS->next_out = (*unzipped);
1093                 zS->avail_out = (*lenUnzipped);
1094         }
1095
1096         // Try to unzip the data
1097         err = inflate(zS, Z_SYNC_FLUSH);
1098
1099         // Is zip finished reading all currently available input and writing
1100         // all generated output
1101         if (err == Z_STREAM_END) {
1102                 // Finish up
1103                 err = inflateEnd(zS);
1104                 if (err != Z_OK) {
1105                         return err;
1106                 }
1107
1108                 // Got a good result, set the size to the amount unzipped in this call
1109                 //  (including all recursive calls)
1110                 (*lenUnzipped) = (zS->total_out - block->totalUnzipped);
1111                 block->totalUnzipped = zS->total_out;
1112         } else if ((err == Z_OK) && (zS->avail_out == 0) && (zS->avail_in != 0)) {
1113
1114                 // Output array was not big enough,
1115                 // call recursively until there is enough space
1116
1117                 // What size should we try next
1118                 uint32 newLength = (*lenUnzipped) *= 2;
1119                 if (newLength == 0) {
1120                         newLength = lenZipped * 2;
1121                 }
1122                 // Copy any data that was successfully unzipped to new array
1123                 byte *temp = new byte[newLength];
1124                 wxASSERT( zS->total_out - block->totalUnzipped <= newLength );
1125                 memcpy(temp, (*unzipped), (zS->total_out - block->totalUnzipped));
1126                 delete [] (*unzipped);
1127                 (*unzipped) = temp;
1128                 (*lenUnzipped) = newLength;
1129
1130                 // Position stream output to correct place in new array
1131                 zS->next_out = (*unzipped) + (zS->total_out - block->totalUnzipped);
1132                 zS->avail_out = (*lenUnzipped) - (zS->total_out - block->totalUnzipped);
1133
1134                 // Try again
1135                 err = unzip(block, zS->next_in, zS->avail_in, unzipped, lenUnzipped, iRecursion + 1);
1136         } else if ((err == Z_OK) && (zS->avail_in == 0)) {
1137                 // All available input has been processed, everything ok.
1138                 // Set the size to the amount unzipped in this call
1139                 // (including all recursive calls)
1140                 (*lenUnzipped) = (zS->total_out - block->totalUnzipped);
1141                 block->totalUnzipped = zS->total_out;
1142         } else {
1143                 // Should not get here unless input data is corrupt
1144                 wxString strZipError;
1145
1146                 if ( zS->msg ) {
1147                         strZipError = wxString::Format(wxT(" %d '"), err) + wxString::FromAscii(zS->msg) + wxT("'");
1148                 } else if (err != Z_OK) {
1149                         strZipError = wxString::Format(wxT(" %d"), err);
1150                 }
1151
1152                 AddDebugLogLineM(false, logZLib,
1153                         CFormat(wxT("Unexpected zip error %s in file '%s'"))
1154                                 % strZipError % (m_reqfile ? m_reqfile->GetFileName() : CPath(wxT("?"))));
1155         }
1156
1157         if (err != Z_OK) {
1158                 (*lenUnzipped) = 0;
1159         }
1160
1161         return err;
1162 }
1163
1164
1165 // Speed is now updated only when data was received, calculated as
1166 // (data received) / (time since last receiption)
1167 // and slightly filtered (10s average).
1168 // Result is quite precise now and makes the DownloadRateAdjust workaround obsolete.
1169
1170 float CUpDownClient::CalculateKBpsDown()
1171 {
1172         const   float tAverage = 10.0;
1173         uint32  msCur = GetTickCount();
1174
1175         if (bytesReceivedCycle) {
1176                 float dt = (msCur - msReceivedPrev) / 1000.0; // time since last reception
1177                 if (dt < 0.01) {        // (safeguard against divide-by-zero)
1178                         dt = 0.01f;             //  diff should be 100ms actually
1179                 }
1180                 float kBpsDownCur = bytesReceivedCycle / 1024.0 / dt;
1181                 if (dt >= tAverage) {
1182                         kBpsDown = kBpsDownCur;
1183                 } else {
1184                         kBpsDown = (kBpsDown * (tAverage - dt) + kBpsDownCur * dt) / tAverage;
1185                 }
1186                 AddDebugLogLineM( false, logLocalClient, CFormat(wxT("CalculateKBpsDown %p kbps %.1f kbpsCur %.1f dt %.3f rcv %d "))
1187                                         % this % kBpsDown  % kBpsDownCur % dt % bytesReceivedCycle);
1188                 bytesReceivedCycle = 0;
1189                 msReceivedPrev = msCur;
1190         }
1191
1192         m_cShowDR++;
1193         if (m_cShowDR == 30){
1194                 m_cShowDR = 0;
1195                 UpdateDisplayedInfo();
1196         }
1197         if (msCur - m_dwLastBlockReceived > DOWNLOADTIMEOUT) {
1198                 if (!GetSentCancelTransfer()){
1199                         CPacket* packet = new CPacket(OP_CANCELTRANSFER, 0, OP_EDONKEYPROT);
1200                         theStats::AddUpOverheadFileRequest(packet->GetPacketSize());
1201                         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_CANCELTRANSFER to ") + GetFullIP() );
1202                         SendPacket(packet,true,true);
1203                         SetSentCancelTransfer(1);
1204                 }
1205                 SetDownloadState(DS_ONQUEUE);
1206         }
1207
1208         return kBpsDown;
1209 }
1210
1211 uint16 CUpDownClient::GetAvailablePartCount() const
1212 {
1213         uint16 result = 0;
1214         for (int i = 0;i != m_nPartCount;i++){
1215                 if (IsPartAvailable(i))
1216                         result++;
1217         }
1218         return result;
1219 }
1220
1221 void CUpDownClient::SetRemoteQueueRank(uint16 nr)
1222 {
1223         m_nOldRemoteQueueRank = m_nRemoteQueueRank;
1224         m_nRemoteQueueRank = nr;
1225         UpdateDisplayedInfo();
1226 }
1227
1228 void CUpDownClient::UDPReaskACK(uint16 nNewQR)
1229 {
1230         // 0.42e
1231         m_bUDPPending = false;
1232         SetRemoteQueueRank(nNewQR);
1233         m_dwLastAskedTime = ::GetTickCount();
1234 }
1235
1236 void CUpDownClient::UDPReaskFNF()
1237 {
1238         m_bUDPPending = false;
1239
1240         // avoid premature deletion of 'this' client
1241         if (GetDownloadState() != DS_DOWNLOADING){
1242                 if (m_reqfile) {
1243                         m_reqfile->AddDeadSource(this);
1244                 }
1245
1246                 theApp->downloadqueue->RemoveSource(this);
1247                 if (!m_socket) {
1248                         if (Disconnected(wxT("UDPReaskFNF m_socket=NULL"))) {
1249                                 Safe_Delete();
1250                         }
1251                 }
1252         } else {
1253                 AddDebugLogLineM( false, logRemoteClient, wxT("UDP ANSWER FNF : ") + GetUserName() + wxT(" - did not remove client because of current download state") );
1254         }
1255 }
1256
1257 void CUpDownClient::UDPReaskForDownload()
1258 {
1259
1260         wxASSERT(m_reqfile);
1261
1262         if(!m_reqfile || m_bUDPPending ) {
1263                 return;
1264         }
1265
1266         //#warning We should implement the quality tests for udp reliability
1267         /*
1268         if( m_nTotalUDPPackets > 3 && ((float)(m_nFailedUDPPackets/m_nTotalUDPPackets) > .3)) {
1269                 return;
1270         }
1271         */
1272
1273         if (thePrefs::GetEffectiveUDPPort() == 0) {
1274                 return;
1275         }
1276
1277         if (m_nUDPPort != 0 && !theApp->IsFirewalled() && !IsConnected()) {
1278                 //don't use udp to ask for sources
1279                 if(IsSourceRequestAllowed()) {
1280                         return;
1281                 }
1282
1283                 m_bUDPPending = true;
1284
1285                 CMemFile data(128);
1286                 data.WriteHash(m_reqfile->GetFileHash());
1287
1288                 if (GetUDPVersion() > 3) {
1289                         if (m_reqfile->IsPartFile()) {
1290                                 ((CPartFile*)m_reqfile)->WritePartStatus(&data);
1291                         }
1292                         else {
1293                                 data.WriteUInt16(0);
1294                         }
1295                 }
1296
1297                 if (GetUDPVersion() > 2) {
1298                         data.WriteUInt16(m_reqfile->m_nCompleteSourcesCount);
1299                 }
1300
1301                 CPacket* response = new CPacket(data, OP_EMULEPROT, OP_REASKFILEPING);
1302                 AddDebugLogLineM( false, logClientUDP, wxT("Client UDP socket: send OP_REASKFILEPING") );
1303                 theStats::AddUpOverheadFileRequest(response->GetPacketSize());
1304                 theApp->clientudp->SendPacket(response,GetConnectIP(),GetUDPPort(), ShouldReceiveCryptUDPPackets(), GetUserHash().GetHash(), false, 0);
1305         } else  if (HasLowID() && GetBuddyIP() && GetBuddyPort() && HasValidBuddyID()) {
1306
1307                 m_bUDPPending = true;
1308
1309                 CMemFile data(128);
1310
1311                 data.WriteHash(CMD4Hash(GetBuddyID()));
1312                 data.WriteHash(m_reqfile->GetFileHash());
1313
1314                 if (GetUDPVersion() > 3) {
1315                         if (m_reqfile->IsPartFile()) {
1316                                 ((CPartFile*)m_reqfile)->WritePartStatus(&data);
1317                         } else {
1318                                 data.WriteUInt16(0);
1319                         }
1320                 }
1321
1322                 if (GetUDPVersion() > 2) {
1323                         data.WriteUInt16(m_reqfile->m_nCompleteSourcesCount);
1324                 }
1325
1326                 CPacket* response = new CPacket(data, OP_EMULEPROT, OP_REASKCALLBACKUDP);
1327                 AddDebugLogLineM( false, logClientUDP, wxT("Client UDP socket: send OP_REASKCALLBACKUDP") );
1328                 theStats::AddUpOverheadFileRequest(response->GetPacketSize());
1329                 theApp->clientudp->SendPacket(response, GetBuddyIP(), GetBuddyPort(), false, NULL, true, 0 );
1330         }
1331 }
1332
1333
1334 //! Barry - Sets string to show parts downloading, eg NNNYNNNNYYNYN
1335 wxString CUpDownClient::ShowDownloadingParts() const
1336 {
1337         // Initialise to all N's
1338         wxString Parts(wxT('N'), m_nPartCount);
1339
1340         std::list<Pending_Block_Struct*>::const_iterator it = m_PendingBlocks_list.begin();
1341         for (; it != m_PendingBlocks_list.end(); ++it) {
1342                 Parts.SetChar(((*it)->block->StartOffset / PARTSIZE), 'Y');
1343         }
1344
1345         return Parts;
1346 }
1347
1348
1349 void CUpDownClient::UpdateDisplayedInfo(bool force)
1350 {
1351         uint32 curTick = ::GetTickCount();
1352         if(force || curTick-m_lastRefreshedDLDisplay > MINWAIT_BEFORE_DLDISPLAY_WINDOWUPDATE) {
1353                 // Check if we actually need to notify of changes
1354                 bool update = m_reqfile && m_reqfile->ShowSources();
1355
1356                 // Check A4AF files only if needed
1357                 if ( !update ) {
1358                         A4AFList::iterator it = m_A4AF_list.begin();
1359                         for ( ; it != m_A4AF_list.end(); ++it ) {
1360                                 if ( it->first->ShowSources() ) {
1361                                         update = true;
1362                                         break;
1363                                 }
1364                         }
1365                 }
1366
1367                 // And finnaly trigger an event if there's any reason
1368                 if ( update ) {
1369                         Notify_DownloadCtrlUpdateItem(this);
1370                 }
1371
1372                 m_lastRefreshedDLDisplay = curTick;
1373         }
1374 }
1375
1376
1377 // IgnoreNoNeeded = will switch to files of which this source has no needed parts (if no better fiels found)
1378 // ignoreSuspensions = ignore timelimit for A4Af jumping
1379 // bRemoveCompletely = do not readd the file which the source is swapped from to the A4AF lists (needed if deleting or stopping a file)
1380 // toFile = Try to swap to this partfile only
1381
1382 bool CUpDownClient::SwapToAnotherFile(bool bIgnoreNoNeeded, bool ignoreSuspensions, bool bRemoveCompletely, CPartFile* toFile)
1383 {
1384         // Fail if m_reqfile is invalid
1385         if ( m_reqfile == NULL ) {
1386                 return false;
1387         }
1388
1389         // It would be stupid to swap away a downloading source
1390         if (GetDownloadState() == DS_DOWNLOADING) {
1391                 return false;
1392         }
1393
1394         // The iterator of the final target
1395         A4AFList::iterator target = m_A4AF_list.end();
1396
1397         // Do we want to swap to a specific file?
1398         if ( toFile != NULL ) {
1399                 A4AFList::iterator it = m_A4AF_list.find( toFile );
1400                 if ( it != m_A4AF_list.end() ) {
1401
1402                         // We force ignoring of noneeded flag and timestamps
1403                         if ( IsValidSwapTarget( it, true, true ) ) {
1404                                 // Set the target
1405                                 target = it;
1406                         }
1407                 }
1408         } else {
1409                 // We want highest priority possible, but need to start with
1410                 // a value less than any other priority
1411                 char priority = -1;
1412
1413                 A4AFList::iterator it = m_A4AF_list.begin();
1414                 for ( ; it != m_A4AF_list.end(); ++it ) {
1415                         if ( IsValidSwapTarget( it, bIgnoreNoNeeded, ignoreSuspensions ) ) {
1416                                 char cur_priority = it->first->GetDownPriority();
1417
1418                                 // We would prefer to get files with needed parts, thus rate them higher.
1419                                 // However, this really only matters if bIgnoreNoNeeded is true.
1420                                 if ( it->second.NeededParts )
1421                                                 cur_priority += 10;
1422
1423                                 // Change target if the current file has a higher rate than the previous
1424                                 if ( cur_priority > priority ) {
1425                                         priority = cur_priority;
1426
1427                                         // Set the new target
1428                                         target = it;
1429
1430                                         // Break on the first High-priority file with needed parts
1431                                         if ( priority == PR_HIGH + 10 ) {
1432                                                 break;
1433                                         }
1434                                 }
1435                         }
1436                 }
1437         }
1438
1439         // Try to swap if we found a valid target
1440         if ( target != m_A4AF_list.end() ) {
1441
1442                 // Sainity check, if reqfile doesn't own the source, then something
1443                 // is wrong and the swap cannot proceed.
1444                 if ( m_reqfile->DelSource( this ) ) {
1445                         CPartFile* SwapTo = target->first;
1446
1447                         // remove this client from the A4AF list of our new m_reqfile
1448                         if ( SwapTo->RemoveA4AFSource( this ) ) {
1449                                 Notify_DownloadCtrlRemoveSource(this, SwapTo);
1450                         }
1451
1452                         m_reqfile->RemoveDownloadingSource( this );
1453
1454                         // Do we want to remove it completly? Say if the old file is getting deleted
1455                         if ( !bRemoveCompletely ) {
1456                                 m_reqfile->AddA4AFSource( this );
1457
1458                                 // Set the status of the old file
1459                                 m_A4AF_list[m_reqfile].NeededParts = (GetDownloadState() != DS_NONEEDEDPARTS);
1460
1461                                 // Avoid swapping to this file for a while
1462                                 m_A4AF_list[m_reqfile].timestamp = ::GetTickCount();
1463
1464                                 Notify_DownloadCtrlAddSource(m_reqfile, this, A4AF_SOURCE);
1465                         } else {
1466                                 Notify_DownloadCtrlRemoveSource( this, m_reqfile );
1467                         }
1468
1469                         SetDownloadState(DS_NONE);
1470                         ResetFileStatusInfo();
1471
1472                         m_nRemoteQueueRank = 0;
1473                         m_nOldRemoteQueueRank = 0;
1474
1475                         m_reqfile->UpdatePartsInfo();
1476
1477                         SetRequestFile( SwapTo );
1478
1479                         SwapTo->AddSource( this );
1480
1481                         Notify_DownloadCtrlAddSource(SwapTo, this, UNAVAILABLE_SOURCE);
1482
1483                         // Remove the new reqfile from the list of other files
1484                         m_A4AF_list.erase( target );
1485
1486                         return true;
1487                 }
1488         }
1489
1490         return false;
1491 }
1492
1493
1494 bool CUpDownClient::IsValidSwapTarget( A4AFList::iterator it, bool ignorenoneeded, bool ignoresuspended )
1495 {
1496         wxASSERT( it != m_A4AF_list.end() && it->first );
1497
1498         // Check if this file has been suspended
1499         if ( !ignoresuspended ) {
1500                 if ( ::GetTickCount() - it->second.timestamp >= PURGESOURCESWAPSTOP ) {
1501                         // The wait-time has been exceeded and the file is now a valid target
1502                         it->second.timestamp = 0;
1503                 } else {
1504                         // The file was still suspended and we are not ignoring suspensions
1505                         return false;
1506                 }
1507         }
1508
1509         // Check if the client has needed parts
1510         if ( !ignorenoneeded ) {
1511                 if ( !it->second.NeededParts ) {
1512                         return false;
1513                 }
1514         }
1515
1516         // Final checks to see if the client is a valid target
1517         CPartFile* cur_file = it->first;
1518         if ( ( cur_file != m_reqfile && !cur_file->IsStopped() ) &&
1519              ( cur_file->GetStatus() == PS_READY || cur_file->GetStatus() == PS_EMPTY ) &&
1520                  ( cur_file->IsPartFile() ) )
1521         {
1522                 return true;
1523         } else {
1524                 return false;
1525         }
1526 }
1527
1528
1529 void CUpDownClient::SetRequestFile(CPartFile* reqfile)
1530 {
1531         if ( m_reqfile != reqfile ) {
1532                 // Decrement the source-count of the old request-file
1533                 if ( m_reqfile ) {
1534                         m_reqfile->ClientStateChanged( GetDownloadState(), -1 );
1535                         m_reqfile->UpdatePartsFrequency( this, false );
1536                 }
1537
1538                 m_nPartCount = 0;
1539                 m_downPartStatus.clear();
1540
1541                 m_reqfile = reqfile;
1542
1543                 if ( reqfile ) {
1544                         // Increment the source-count of the new request-file
1545                         m_reqfile->ClientStateChanged( -1, GetDownloadState() );
1546
1547                         m_nPartCount = reqfile->GetPartCount();
1548                 }
1549         }
1550 }
1551
1552 void CUpDownClient::SetReqFileAICHHash(CAICHHash* val){
1553         if(m_pReqFileAICHHash != NULL && m_pReqFileAICHHash != val)
1554                 delete m_pReqFileAICHHash;
1555         m_pReqFileAICHHash = val;
1556 }
1557
1558 void CUpDownClient::SendAICHRequest(CPartFile* pForFile, uint16 nPart){
1559         CAICHRequestedData request;
1560         request.m_nPart = nPart;
1561         request.m_pClient = this;
1562         request.m_pPartFile = pForFile;
1563         CAICHHashSet::m_liRequestedData.push_back(request);
1564         m_fAICHRequested = TRUE;
1565         CMemFile data;
1566         data.WriteHash(pForFile->GetFileHash());
1567         data.WriteUInt16(nPart);
1568         pForFile->GetAICHHashset()->GetMasterHash().Write(&data);
1569         CPacket* packet = new CPacket(data, OP_EMULEPROT, OP_AICHREQUEST);
1570         theStats::AddUpOverheadOther(packet->GetPacketSize());
1571         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_AICHREQUEST to") + GetFullIP());
1572         SafeSendPacket(packet);
1573 }
1574
1575 void CUpDownClient::ProcessAICHAnswer(const byte* packet, uint32 size)
1576 {
1577         if (m_fAICHRequested == FALSE){
1578                 throw wxString(wxT("Received unrequested AICH Packet"));
1579         }
1580         m_fAICHRequested = FALSE;
1581
1582         CMemFile data(packet, size);
1583         if (size <= 16){
1584                 CAICHHashSet::ClientAICHRequestFailed(this);
1585                 return;
1586         }
1587
1588         CMD4Hash hash = data.ReadHash();
1589         CPartFile* pPartFile = theApp->downloadqueue->GetFileByID(hash);
1590         CAICHRequestedData request = CAICHHashSet::GetAICHReqDetails(this);
1591         uint16 nPart = data.ReadUInt16();
1592         if (pPartFile != NULL && request.m_pPartFile == pPartFile && request.m_pClient == this && nPart == request.m_nPart){
1593                 CAICHHash ahMasterHash(&data);
1594                 if ( (pPartFile->GetAICHHashset()->GetStatus() == AICH_TRUSTED || pPartFile->GetAICHHashset()->GetStatus() == AICH_VERIFIED)
1595                          && ahMasterHash == pPartFile->GetAICHHashset()->GetMasterHash())
1596                 {
1597                         if(pPartFile->GetAICHHashset()->ReadRecoveryData(request.m_nPart*PARTSIZE, &data)){
1598                                 // finally all checks passed, everythings seem to be fine
1599                                 AddDebugLogLineM( false, logAICHTransfer, wxT("AICH Packet Answer: Succeeded to read and validate received recoverydata"));
1600                                 CAICHHashSet::RemoveClientAICHRequest(this);
1601                                 pPartFile->AICHRecoveryDataAvailable(request.m_nPart);
1602                                 return;
1603                         } else {
1604                                 AddDebugLogLineM( false, logAICHTransfer, wxT("AICH Packet Answer: Succeeded to read and validate received recoverydata"));
1605                         }
1606                 } else {
1607                         AddDebugLogLineM( false, logAICHTransfer, wxT("AICH Packet Answer: Masterhash differs from packethash or hashset has no trusted Masterhash") );
1608                 }
1609         } else {
1610                 AddDebugLogLineM( false, logAICHTransfer, wxT("AICH Packet Answer: requested values differ from values in packet") );
1611         }
1612
1613         CAICHHashSet::ClientAICHRequestFailed(this);
1614 }
1615
1616
1617 void CUpDownClient::ProcessAICHRequest(const byte* packet, uint32 size)
1618 {
1619         if (size != 16 + 2 + CAICHHash::GetHashSize()) {
1620                 throw wxString(wxT("Received AICH Request Packet with wrong size"));
1621         }
1622
1623         CMemFile data(packet, size);
1624
1625         CMD4Hash hash = data.ReadHash();
1626         uint16 nPart = data.ReadUInt16();
1627         CAICHHash ahMasterHash(&data);
1628         CKnownFile* pKnownFile = theApp->sharedfiles->GetFileByID(hash);
1629         if (pKnownFile != NULL){
1630                 if (pKnownFile->GetAICHHashset()->GetStatus() == AICH_HASHSETCOMPLETE && pKnownFile->GetAICHHashset()->HasValidMasterHash()
1631                         && pKnownFile->GetAICHHashset()->GetMasterHash() == ahMasterHash && pKnownFile->GetPartCount() > nPart
1632                         && pKnownFile->GetFileSize() > EMBLOCKSIZE && pKnownFile->GetFileSize() - PARTSIZE*nPart > EMBLOCKSIZE)
1633                 {
1634                         CMemFile fileResponse;
1635                         fileResponse.WriteHash(pKnownFile->GetFileHash());
1636                         fileResponse.WriteUInt16(nPart);
1637                         pKnownFile->GetAICHHashset()->GetMasterHash().Write(&fileResponse);
1638                         if (pKnownFile->GetAICHHashset()->CreatePartRecoveryData(nPart*PARTSIZE, &fileResponse)){
1639                                 AddDebugLogLineM(false, logAICHTransfer,
1640                                         CFormat(wxT("AICH Packet Request: Sucessfully created and send recoverydata for '%s' to %s"))
1641                                                 % pKnownFile->GetFileName() % GetClientFullInfo());
1642
1643                                 CPacket* packAnswer = new CPacket(fileResponse, OP_EMULEPROT, OP_AICHANSWER);
1644                                 theStats::AddUpOverheadOther(packAnswer->GetPacketSize());
1645                                 AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_AICHANSWER to") + GetFullIP());
1646                                 SafeSendPacket(packAnswer);
1647                                 return;
1648                         } else {
1649                                 AddDebugLogLineM(false, logAICHTransfer,
1650                                         CFormat(wxT("AICH Packet Request: Failed to create recoverydata for '%s' to %s"))
1651                                                 % pKnownFile->GetFileName() % GetClientFullInfo());
1652                         }
1653                 } else {
1654                         AddDebugLogLineM(false, logAICHTransfer,
1655                                 CFormat(wxT("AICH Packet Request: Failed to create recoverydata - Hashset not ready or requested Hash differs from Masterhash for '%s' to %s"))
1656                                         % pKnownFile->GetFileName() % GetClientFullInfo());
1657                 }
1658         } else {
1659                 AddDebugLogLineM( false, logAICHTransfer, wxT("AICH Packet Request: Failed to find requested shared file - ") + GetClientFullInfo() );
1660         }
1661
1662         CPacket* packAnswer = new CPacket(OP_AICHANSWER, 16, OP_EMULEPROT);
1663         packAnswer->Copy16ToDataBuffer(hash.GetHash());
1664         theStats::AddUpOverheadOther(packAnswer->GetPacketSize());
1665         AddDebugLogLineM( false, logLocalClient, wxT("Local Client: OP_AICHANSWER to") + GetFullIP());
1666         SafeSendPacket(packAnswer);
1667 }
1668
1669 void CUpDownClient::ProcessAICHFileHash(CMemFile* data, const CPartFile* file){
1670         CPartFile* pPartFile;
1671         if (file == NULL){
1672                 pPartFile = theApp->downloadqueue->GetFileByID(data->ReadHash());
1673         } else {
1674                 pPartFile = (CPartFile*)file;
1675         }
1676         CAICHHash ahMasterHash(data);
1677
1678         if(pPartFile != NULL && pPartFile == GetRequestFile()){
1679                 SetReqFileAICHHash(new CAICHHash(ahMasterHash));
1680                 pPartFile->GetAICHHashset()->UntrustedHashReceived(ahMasterHash, GetConnectIP());
1681         } else {
1682                 AddDebugLogLineM( false, logAICHTransfer, wxT("ProcessAICHFileHash(): PartFile not found or Partfile differs from requested file, ") + GetClientFullInfo() );
1683         }
1684 }
1685 // File_checked_for_headers