?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added cmake
[amule.git] / src / PartFile.cpp
blob52ee65b0f59d9b15b3d1af864a19dcc8d2142b4d
1 //
2 // This file is part of the aMule Project.
3 //
4 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
5 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
6 //
7 // Any parts of this program derived from the xMule, lMule or eMule project,
8 // or contributed by third-party developers are copyrighted by their
9 // respective authors.
10 //
11 // This program is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation; either version 2 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 //
25
26 #include <wx/wx.h>
27
28 #include "PartFile.h" // Interface declarations.
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h" // Needed for VERSION
32 #endif
33
34 #include <protocol/kad/Constants.h>
35 #include <protocol/ed2k/Client2Client/TCP.h>
36 #include <protocol/Protocols.h>
37 #include <common/DataFileVersion.h>
38 #include <common/Constants.h>
39 #include <tags/FileTags.h>
40
41 #include <wx/utils.h>
42 #include <wx/tokenzr.h> // Needed for wxStringTokenizer
43 #ifndef AMULE_DAEMON
44 #include <wx/notifmsg.h> // Needed for wxNotificationMessage
45 #endif
46
47 #include "KnownFileList.h" // Needed for CKnownFileList
48 #include "CanceledFileList.h"
49 #include "UploadQueue.h" // Needed for CFileHash
50 #include "IPFilter.h" // Needed for CIPFilter
51 #include "Server.h" // Needed for CServer
52 #include "ServerConnect.h" // Needed for CServerConnect
53
54 #ifdef CLIENT_GUI
55 #include "UpDownClientEC.h" // Needed for CUpDownClient
56 #else
57 #include "updownclient.h" // Needed for CUpDownClient
58 #endif
59
60 #include "MemFile.h" // Needed for CMemFile
61 #include "Preferences.h" // Needed for CPreferences
62 #include "DownloadQueue.h" // Needed for CDownloadQueue
63 #include "amule.h" // Needed for theApp
64 #include "ED2KLink.h" // Needed for CED2KLink
65 #include "Packet.h" // Needed for CTag
66 #include "SearchList.h" // Needed for CSearchFile
67 #include "ClientList.h" // Needed for clientlist
68 #include "Statistics.h" // Needed for theStats
69 #include "Logger.h"
70 #include <common/Format.h> // Needed for CFormat
71 #include <common/FileFunctions.h> // Needed for GetLastModificationTime
72 #include "ThreadTasks.h" // Needed for CHashingTask/CCompletionTask/CAllocateFileTask
73 #include "GuiEvents.h" // Needed for Notify_*
74 #include "DataToText.h" // Needed for OriginToText()
75 #include "PlatformSpecific.h" // Needed for CreateSparseFile()
76 #include "FileArea.h" // Needed for CFileArea
77 #include "ScopedPtr.h" // Needed for CScopedArray
78 #include "CorruptionBlackBox.h"
79
80 #include "kademlia/kademlia/Kademlia.h"
81 #include "kademlia/kademlia/Search.h"
82
83
84 SFileRating::SFileRating(const wxString &u, const wxString &f, sint16 r, const wxString &c)
85 :
86 UserName(u),
87 FileName(f),
88 Rating(r),
89 Comment(c)
90 {
91 }
92
93
94 SFileRating::SFileRating(const SFileRating &fr)
95 :
96 UserName(fr.UserName),
97 FileName(fr.FileName),
98 Rating(fr.Rating),
99 Comment(fr.Comment)
100 {
101 }
102
103
104 #ifndef CLIENT_GUI
105 SFileRating::SFileRating(const CUpDownClient &client)
106 :
107 UserName(client.GetUserName()),
108 FileName(client.GetClientFilename()),
109 Rating(client.GetFileRating()),
110 Comment(client.GetFileComment())
111 {
112 }
113 #endif
114
115
116 SFileRating::~SFileRating()
117 {
118 }
119
120
121 class PartFileBufferedData
122 {
123 public:
124 CFileArea area; // File area to be written
125 uint64 start; // This is the start offset of the data
126 uint64 end; // This is the end offset of the data
127 Requested_Block_Struct *block; // This is the requested block that this data relates to
128
129 PartFileBufferedData(CFileAutoClose& file, byte * data, uint64 _start, uint64 _end, Requested_Block_Struct *_block)
130 : start(_start), end(_end), block(_block)
131 {
132 area.StartWriteAt(file, start, end-start+1);
133 memcpy(area.GetBuffer(), data, end-start+1);
134 }
135 };
136
137
138 typedef std::list<Chunk> ChunkList;
139
140
141 #ifndef CLIENT_GUI
142
143 CPartFile::CPartFile()
144 {
145 Init();
146 }
147
148 CPartFile::CPartFile(CSearchFile* searchresult)
149 {
150 Init();
151
152 m_abyFileHash = searchresult->GetFileHash();
153 SetFileName(searchresult->GetFileName());
154 SetFileSize(searchresult->GetFileSize());
155
156 for (unsigned int i = 0; i < searchresult->m_taglist.size(); ++i){
157 const CTag& pTag = searchresult->m_taglist[i];
158
159 bool bTagAdded = false;
160 if (pTag.GetNameID() == 0 && !pTag.GetName().IsEmpty() && (pTag.IsStr() || pTag.IsInt())) {
161 static const struct {
162 wxString pszName;
163 uint8 nType;
164 } _aMetaTags[] =
165 {
166 { wxT(FT_ED2K_MEDIA_ARTIST), 2 },
167 { wxT(FT_ED2K_MEDIA_ALBUM), 2 },
168 { wxT(FT_ED2K_MEDIA_TITLE), 2 },
169 { wxT(FT_ED2K_MEDIA_LENGTH), 2 },
170 { wxT(FT_ED2K_MEDIA_BITRATE), 3 },
171 { wxT(FT_ED2K_MEDIA_CODEC), 2 }
172 };
173
174 for (unsigned int t = 0; t < itemsof(_aMetaTags); ++t) {
175 if ( pTag.GetType() == _aMetaTags[t].nType &&
176 (pTag.GetName() == _aMetaTags[t].pszName)) {
177 // skip string tags with empty string values
178 if (pTag.IsStr() && pTag.GetStr().IsEmpty()) {
179 break;
180 }
181
182 // skip "length" tags with "0: 0" values
183 if (pTag.GetName() == wxT(FT_ED2K_MEDIA_LENGTH)) {
184 if (pTag.GetStr().IsSameAs(wxT("0: 0")) ||
185 pTag.GetStr().IsSameAs(wxT("0:0"))) {
186 break;
187 }
188 }
189
190 // skip "bitrate" tags with '0' values
191 if ((pTag.GetName() == wxT(FT_ED2K_MEDIA_BITRATE)) && !pTag.GetInt()) {
192 break;
193 }
194
195 AddDebugLogLineN( logPartFile,
196 wxT("CPartFile::CPartFile(CSearchFile*): added tag ") +
197 pTag.GetFullInfo() );
198 m_taglist.push_back(pTag);
199 bTagAdded = true;
200 break;
201 }
202 }
203 } else if (pTag.GetNameID() != 0 && pTag.GetName().IsEmpty() && (pTag.IsStr() || pTag.IsInt())) {
204 static const struct {
205 uint8 nID;
206 uint8 nType;
207 } _aMetaTags[] =
208 {
209 { FT_FILETYPE, 2 },
210 { FT_FILEFORMAT, 2 }
211 };
212 for (unsigned int t = 0; t < itemsof(_aMetaTags); ++t) {
213 if (pTag.GetType() == _aMetaTags[t].nType && pTag.GetNameID() == _aMetaTags[t].nID) {
214 // skip string tags with empty string values
215 if (pTag.IsStr() && pTag.GetStr().IsEmpty()) {
216 break;
217 }
218
219 AddDebugLogLineN( logPartFile,
220 wxT("CPartFile::CPartFile(CSearchFile*): added tag ") +
221 pTag.GetFullInfo() );
222 m_taglist.push_back(pTag);
223 bTagAdded = true;
224 break;
225 }
226 }
227 }
228
229 if (!bTagAdded) {
230 AddDebugLogLineN( logPartFile,
231 wxT("CPartFile::CPartFile(CSearchFile*): ignored tag ") +
232 pTag.GetFullInfo() );
233 }
234 }
235
236 CreatePartFile();
237 }
238
239
240 CPartFile::CPartFile(const CED2KFileLink* fileLink)
241 {
242 Init();
243
244 SetFileName(CPath(fileLink->GetName()));
245 SetFileSize(fileLink->GetSize());
246 m_abyFileHash = fileLink->GetHashKey();
247
248 CreatePartFile();
249
250 if (fileLink->m_hashset) {
251 if (!LoadHashsetFromFile(fileLink->m_hashset, true)) {
252 AddDebugLogLineC(logPartFile, wxT("eD2K link contained invalid hashset: ") + fileLink->GetLink());
253 }
254 }
255 }
256
257
258 CPartFile::~CPartFile()
259 {
260 // if it's not opened, it was completed or deleted
261 if (m_hpartfile.IsOpened()) {
262 FlushBuffer();
263 m_hpartfile.Close();
264 // Update met file (with current directory entry)
265 SavePartFile();
266 }
267
268 DeleteContents(m_BufferedData_list);
269 delete m_CorruptionBlackBox;
270
271 wxASSERT(m_SrcList.empty());
272 wxASSERT(m_A4AFsrclist.empty());
273 }
274
275 void CPartFile::CreatePartFile(bool isImporting)
276 {
277 // use lowest free partfilenumber for free file (InterCeptor)
278 int i = 0;
279 do {
280 ++i;
281 m_partmetfilename = CPath(CFormat(wxT("%03i.part.met")) % i);
282 m_fullname = thePrefs::GetTempDir().JoinPaths(m_partmetfilename);
283 } while (m_fullname.FileExists());
284
285 m_CorruptionBlackBox->SetPartFileInfo(GetFileName().GetPrintable(), m_partmetfilename.RemoveAllExt().GetPrintable());
286
287 m_gaplist.Init(GetFileSize(), true); // Init empty
288
289 m_PartPath = m_fullname.RemoveExt();
290 bool fileCreated;
291 if (thePrefs::GetAllocFullFile() || !thePrefs::CreateFilesSparse()) {
292 fileCreated = m_hpartfile.Create(m_PartPath, true);
293 m_hpartfile.Close();
294 } else {
295 fileCreated = PlatformSpecific::CreateSparseFile(m_PartPath, GetFileSize());
296 }
297 if (!fileCreated) {
298 AddLogLineN(_("ERROR: Failed to create partfile"));
299 SetStatus(PS_ERROR);
300 }
301
302 SetFilePath(thePrefs::GetTempDir());
303
304 if (!isImporting && thePrefs::GetAllocFullFile()) {
305 SetStatus(PS_ALLOCATING);
306 CThreadScheduler::AddTask(new CAllocateFileTask(this, thePrefs::AddNewFilesPaused()));
307 } else {
308 AllocationFinished();
309 }
310
311 m_hashsetneeded = (GetED2KPartHashCount() > 0);
312
313 SavePartFile(true);
314 SetActive(theApp->IsConnected());
315 }
316
317
318 uint8 CPartFile::LoadPartFile(const CPath& in_directory, const CPath& filename, bool from_backup, bool getsizeonly)
319 {
320 bool isnewstyle = false;
321 uint8 version,partmettype=PMT_UNKNOWN;
322
323 std::map<uint16, Gap_Struct*> gap_map; // Slugfiller
324 transferred = 0;
325
326 m_partmetfilename = filename;
327 m_CorruptionBlackBox->SetPartFileInfo(GetFileName().GetPrintable(), m_partmetfilename.RemoveAllExt().GetPrintable());
328 m_filePath = in_directory;
329 m_fullname = m_filePath.JoinPaths(m_partmetfilename);
330 m_PartPath = m_fullname.RemoveExt();
331
332 // readfile data form part.met file
333 CPath curMetFilename = m_fullname;
334 if (from_backup) {
335 curMetFilename = curMetFilename.AppendExt(PARTMET_BAK_EXT);
336 AddLogLineN(CFormat( _("Trying to load backup of met-file from %s") )
337 % curMetFilename );
338 }
339
340 try {
341 CFile metFile(curMetFilename, CFile::read);
342 if (!metFile.IsOpened()) {
343 AddLogLineN(CFormat( _("ERROR: Failed to open part.met file: %s ==> %s") )
344 % curMetFilename
345 % GetFileName() );
346
347 return false;
348 } else if (metFile.GetLength() == 0) {
349 AddLogLineN(CFormat( _("ERROR: part.met file is 0 size: %s ==> %s") )
350 % m_partmetfilename
351 % GetFileName() );
352
353 return false;
354 }
355
356 version = metFile.ReadUInt8();
357 if (version != PARTFILE_VERSION && version != PARTFILE_SPLITTEDVERSION && version != PARTFILE_VERSION_LARGEFILE){
358 metFile.Close();
359 //if (version == 83) return ImportShareazaTempFile(...)
360 AddLogLineN(CFormat( _("ERROR: Invalid part.met file version: %s ==> %s") )
361 % m_partmetfilename
362 % GetFileName() );
363 return false;
364 }
365
366 isnewstyle = (version == PARTFILE_SPLITTEDVERSION);
367 partmettype = isnewstyle ? PMT_SPLITTED : PMT_DEFAULTOLD;
368
369 if (version == PARTFILE_VERSION) {// Do we still need this check ?
370 uint8 test[4]; // It will fail for certain files.
371 metFile.Seek(24, wxFromStart);
372 metFile.Read(test,4);
373
374 metFile.Seek(1, wxFromStart);
375 if (test[0]==0 && test[1]==0 && test[2]==2 && test[3]==1) {
376 isnewstyle=true; // edonkeys so called "old part style"
377 partmettype=PMT_NEWOLD;
378 }
379 }
380
381 if (isnewstyle) {
382 uint32 temp = metFile.ReadUInt32();
383
384 if (temp==0) { // 0.48 partmets - different again
385 LoadHashsetFromFile(&metFile, false);
386 } else {
387 metFile.Seek(2, wxFromStart);
388 LoadDateFromFile(&metFile);
389 m_abyFileHash = metFile.ReadHash();
390 }
391
392 } else {
393 LoadDateFromFile(&metFile);
394 LoadHashsetFromFile(&metFile, false);
395 }
396
397 uint32 tagcount = metFile.ReadUInt32();
398
399 for (uint32 j = 0; j < tagcount; ++j) {
400 CTag newtag(metFile,true);
401 if ( !getsizeonly ||
402 (getsizeonly &&
403 (newtag.GetNameID() == FT_FILESIZE ||
404 newtag.GetNameID() == FT_FILENAME))) {
405 switch(newtag.GetNameID()) {
406 case FT_FILENAME: {
407 if (!GetFileName().IsOk()) {
408 // If it's not empty, we already loaded the unicoded one
409 SetFileName(CPath(newtag.GetStr()));
410 }
411 break;
412 }
413 case FT_LASTSEENCOMPLETE: {
414 lastseencomplete = newtag.GetInt();
415 break;
416 }
417 case FT_FILESIZE: {
418 SetFileSize(newtag.GetInt());
419 break;
420 }
421 case FT_TRANSFERRED: {
422 transferred = newtag.GetInt();
423 break;
424 }
425 case FT_FILETYPE:{
426 //#warning needs setfiletype string
427 //SetFileType(newtag.GetStr());
428 break;
429 }
430 case FT_CATEGORY: {
431 m_category = newtag.GetInt();
432 if (m_category > theApp->glob_prefs->GetCatCount() - 1 ) {
433 m_category = 0;
434 }
435 break;
436 }
437 case FT_OLDDLPRIORITY:
438 case FT_DLPRIORITY: {
439 if (!isnewstyle){
440 m_iDownPriority = newtag.GetInt();
441 if( m_iDownPriority == PR_AUTO ){
442 m_iDownPriority = PR_HIGH;
443 SetAutoDownPriority(true);
444 }
445 else{
446 if ( m_iDownPriority != PR_LOW &&
447 m_iDownPriority != PR_NORMAL &&
448 m_iDownPriority != PR_HIGH)
449 m_iDownPriority = PR_NORMAL;
450 SetAutoDownPriority(false);
451 }
452 }
453 break;
454 }
455 case FT_STATUS: {
456 m_paused = (newtag.GetInt() == 1);
457 m_stopped = m_paused;
458 break;
459 }
460 case FT_OLDULPRIORITY:
461 case FT_ULPRIORITY: {
462 if (!isnewstyle){
463 SetUpPriority(newtag.GetInt(), false);
464 if( GetUpPriority() == PR_AUTO ){
465 SetUpPriority(PR_HIGH, false);
466 SetAutoUpPriority(true);
467 } else {
468 SetAutoUpPriority(false);
469 }
470 }
471 break;
472 }
473 case FT_KADLASTPUBLISHSRC:{
474 SetLastPublishTimeKadSrc(newtag.GetInt(), 0);
475 if(GetLastPublishTimeKadSrc() > (uint32)time(NULL)+KADEMLIAREPUBLISHTIMES) {
476 //There may be a posibility of an older client that saved a random number here.. This will check for that..
477 SetLastPublishTimeKadSrc(0,0);
478 }
479 break;
480 }
481 case FT_KADLASTPUBLISHNOTES:{
482 SetLastPublishTimeKadNotes(newtag.GetInt());
483 break;
484 }
485 // old tags: as long as they are not needed, take the chance to purge them
486 case FT_PERMISSIONS:
487 case FT_KADLASTPUBLISHKEY:
488 case FT_PARTFILENAME:
489 break;
490 case FT_DL_ACTIVE_TIME:
491 if (newtag.IsInt()) {
492 m_nDlActiveTime = newtag.GetInt();
493 }
494 break;
495 case FT_CORRUPTEDPARTS: {
496 wxASSERT(m_corrupted_list.empty());
497 wxString strCorruptedParts(newtag.GetStr());
498 wxStringTokenizer tokenizer(strCorruptedParts, wxT(","));
499 while ( tokenizer.HasMoreTokens() ) {
500 wxString token = tokenizer.GetNextToken();
501 unsigned long uPart;
502 if (token.ToULong(&uPart)) {
503 if (uPart < GetPartCount() && !IsCorruptedPart(uPart)) {
504 m_corrupted_list.push_back(uPart);
505 }
506 }
507 }
508 break;
509 }
510 case FT_AICH_HASH:{
511 CAICHHash hash;
512 bool hashSizeOk =
513 hash.DecodeBase32(newtag.GetStr()) == CAICHHash::GetHashSize();
514 wxASSERT(hashSizeOk);
515 if (hashSizeOk) {
516 m_pAICHHashSet->SetMasterHash(hash, AICH_VERIFIED);
517 }
518 break;
519 }
520 case FT_ATTRANSFERRED:{
521 statistic.SetAllTimeTransferred(statistic.GetAllTimeTransferred() + (uint64)newtag.GetInt());
522 break;
523 }
524 case FT_ATTRANSFERREDHI:{
525 statistic.SetAllTimeTransferred(statistic.GetAllTimeTransferred() + (((uint64)newtag.GetInt()) << 32));
526 break;
527 }
528 case FT_ATREQUESTED:{
529 statistic.SetAllTimeRequests(newtag.GetInt());
530 break;
531 }
532 case FT_ATACCEPTED:{
533 statistic.SetAllTimeAccepts(newtag.GetInt());
534 break;
535 }
536 default: {
537 // Start Changes by Slugfiller for better exception handling
538
539 wxCharBuffer tag_ansi_name = newtag.GetName().ToAscii();
540 char gap_mark = tag_ansi_name.data() ? tag_ansi_name[0u] : 0;
541 if ( newtag.IsInt() && (newtag.GetName().Length() > 1) &&
542 ((gap_mark == FT_GAPSTART) ||
543 (gap_mark == FT_GAPEND))) {
544 Gap_Struct *gap = NULL;
545 unsigned long int gapkey;
546 if (newtag.GetName().Mid(1).ToULong(&gapkey)) {
547 if ( gap_map.find( gapkey ) == gap_map.end() ) {
548 gap = new Gap_Struct;
549 gap_map[gapkey] = gap;
550 gap->start = (uint64)-1;
551 gap->end = (uint64)-1;
552 } else {
553 gap = gap_map[ gapkey ];
554 }
555 if (gap_mark == FT_GAPSTART) {
556 gap->start = newtag.GetInt();
557 }
558 if (gap_mark == FT_GAPEND) {
559 gap->end = newtag.GetInt()-1;
560 }
561 } else {
562 AddDebugLogLineN(logPartFile, wxT("Wrong gap map key while reading met file!"));
563 wxFAIL;
564 }
565 // End Changes by Slugfiller for better exception handling
566 } else {
567 m_taglist.push_back(newtag);
568 }
569 }
570 }
571 } else {
572 // Nothing. Else, nothing.
573 }
574 }
575
576 // load the hashsets from the hybridstylepartmet
577 if (isnewstyle && !getsizeonly && (metFile.GetPosition()<metFile.GetLength()) ) {
578 metFile.Seek(1, wxFromCurrent);
579
580 uint16 parts=GetPartCount(); // assuming we will get all hashsets
581
582 for (uint16 i = 0; i < parts && (metFile.GetPosition()+16<metFile.GetLength()); ++i){
583 CMD4Hash cur_hash = metFile.ReadHash();
584 m_hashlist.push_back(cur_hash);
585 }
586
587 CMD4Hash checkhash;
588 if (!m_hashlist.empty()) {
589 CreateHashFromHashlist(m_hashlist, &checkhash);
590 }
591 if (m_abyFileHash != checkhash) {
592 m_hashlist.clear();
593 }
594 }
595 } catch (const CInvalidPacket& e) {
596 AddLogLineC(CFormat(_("Error: %s (%s) is corrupt (bad tags: %s), unable to load file."))
597 % m_partmetfilename
598 % GetFileName()
599 % e.what());
600 return false;
601 } catch (const CIOFailureException& e) {
602 AddDebugLogLineC(logPartFile, CFormat( wxT("IO failure while loading '%s': %s") )
603 % m_partmetfilename
604 % e.what() );
605 return false;
606 } catch (const CEOFException& WXUNUSED(e)) {
607 AddLogLineC(CFormat( _("ERROR: %s (%s) is corrupt (wrong tagcount), unable to load file.") )
608 % m_partmetfilename
609 % GetFileName() );
610 AddLogLineC(_("Trying to recover file info..."));
611
612 // Safe file is that who have
613 // - FileSize
614 if (GetFileSize()) {
615 // We have filesize, try other needed info
616
617 // Do we need to check gaps? I think not,
618 // because they are checked below. Worst
619 // scenario will only mark file as 0 bytes downloaded.
620
621 // -Filename
622 if (!GetFileName().IsOk()) {
623 // Not critical, let's put a random filename.
624 AddLogLineC(_(
625 "Recovering no-named file - will try to recover it as RecoveredFile.dat"));
626 SetFileName(CPath(wxT("RecoveredFile.dat")));
627 }
628
629 AddLogLineC(_("Recovered all available file info :D - Trying to use it..."));
630 } else {
631 AddLogLineC(_("Unable to recover file info :("));
632 return false;
633 }
634 }
635
636 if (getsizeonly) {
637 return partmettype;
638 }
639 // Init Gaplist
640 m_gaplist.Init(GetFileSize(), false); // Init full, then add gaps
641 // Now to flush the map into the list (Slugfiller)
642 std::map<uint16, Gap_Struct*>::iterator it = gap_map.begin();
643 for ( ; it != gap_map.end(); ++it ) {
644 Gap_Struct* gap = it->second;
645 // SLUGFILLER: SafeHash - revised code, and extra safety
646 if ( (gap->start != (uint64)-1) &&
647 (gap->end != (uint64)-1) &&
648 gap->start <= gap->end &&
649 gap->start < GetFileSize()) {
650 if (gap->end >= GetFileSize()) {
651 gap->end = GetFileSize()-1; // Clipping
652 }
653 m_gaplist.AddGap(gap->start, gap->end); // All tags accounted for, use safe adding
654 }
655 delete gap;
656 // SLUGFILLER: SafeHash
657 }
658
659 //check if this is a backup
660 if ( m_fullname.GetExt().MakeLower() == wxT("backup" )) {
661 m_fullname = m_fullname.RemoveExt();
662 }
663
664 // open permanent handle
665 if ( !m_hpartfile.Open(m_PartPath, CFile::read_write)) {
666 AddLogLineN(CFormat( _("Failed to open %s (%s)") )
667 % m_fullname
668 % GetFileName() );
669 return false;
670 }
671
672 SetStatus(PS_EMPTY);
673
674 try {
675 // SLUGFILLER: SafeHash - final safety, make sure any missing part of the file is gap
676 if (m_hpartfile.GetLength() < GetFileSize())
677 AddGap(m_hpartfile.GetLength(), GetFileSize()-1);
678 // Goes both ways - Partfile should never be too large
679 if (m_hpartfile.GetLength() > GetFileSize()) {
680 AddDebugLogLineC(logPartFile, CFormat( wxT("Partfile \"%s\" is too large! Truncating %llu bytes.") ) % GetFileName() % (m_hpartfile.GetLength() - GetFileSize()));
681 m_hpartfile.SetLength(GetFileSize());
682 }
683 // SLUGFILLER: SafeHash
684 } catch (const CIOFailureException& e) {
685 AddDebugLogLineC(logPartFile, CFormat( wxT("Error while accessing partfile \"%s\": %s") ) % GetFileName() % e.what());
686 SetStatus(PS_ERROR);
687 }
688
689 // now close the file again until needed
690 m_hpartfile.Release(true);
691
692 // check hashcount, file status etc
693 if (GetHashCount() != GetED2KPartHashCount()){
694 m_hashsetneeded = true;
695 return true;
696 } else {
697 m_hashsetneeded = false;
698 for (size_t i = 0; i < m_hashlist.size(); ++i) {
699 if (IsComplete(i)) {
700 SetStatus(PS_READY);
701 }
702 }
703 }
704
705 if (m_gaplist.IsComplete()) { // is this file complete already?
706 CompleteFile(false);
707 return true;
708 }
709
710 if (!isnewstyle) { // not for importing
711 const time_t file_date = CPath::GetModificationTime(m_PartPath);
712 if (m_lastDateChanged != file_date) {
713 // It's pointless to rehash an empty file, since the case
714 // where a user has zero'd a file is handled above ...
715 if (m_hpartfile.GetLength()) {
716 AddLogLineN(CFormat( _("WARNING: %s might be corrupted (%i)") )
717 % m_PartPath
718 % (m_lastDateChanged - file_date) );
719 // rehash
720 SetStatus(PS_WAITINGFORHASH);
721
722 CPath partFileName = m_partmetfilename.RemoveExt();
723 CThreadScheduler::AddTask(new CHashingTask(m_filePath, partFileName, this));
724 }
725 }
726 }
727
728 UpdateCompletedInfos();
729 if (completedsize > transferred) {
730 m_iGainDueToCompression = completedsize - transferred;
731 } else if (completedsize != transferred) {
732 m_iLostDueToCorruption = transferred - completedsize;
733 }
734
735 return true;
736 }
737
738
739 bool CPartFile::SavePartFile(bool Initial)
740 {
741 switch (status) {
742 case PS_WAITINGFORHASH:
743 case PS_HASHING:
744 case PS_COMPLETE:
745 return false;
746 }
747
748 /* Don't write anything to disk if less than 100 KB of free space is left. */
749 sint64 free = CPath::GetFreeSpaceAt(GetFilePath());
750 if ((free != wxInvalidOffset) && (free < (100 * 1024))) {
751 return false;
752 }
753
754 CFile file;
755 try {
756 if (!m_PartPath.FileExists()) {
757 throw wxString(wxT(".part file not found"));
758 }
759
760 uint32 lsc = lastseencomplete;
761
762 if (!Initial) {
763 CPath::BackupFile(m_fullname, wxT(".backup"));
764 CPath::RemoveFile(m_fullname);
765 }
766
767 file.Open(m_fullname, CFile::write);
768 if (!file.IsOpened()) {
769 throw wxString(wxT("Failed to open part.met file"));
770 }
771
772 // version
773 file.WriteUInt8(IsLargeFile() ? PARTFILE_VERSION_LARGEFILE : PARTFILE_VERSION);
774
775 file.WriteUInt32(CPath::GetModificationTime(m_PartPath));
776 // hash
777 file.WriteHash(m_abyFileHash);
778 uint16 parts = m_hashlist.size();
779 file.WriteUInt16(parts);
780 for (int x = 0; x < parts; ++x) {
781 file.WriteHash(m_hashlist[x]);
782 }
783 // tags
784 #define FIXED_TAGS 15
785 uint32 tagcount = m_taglist.size() + FIXED_TAGS + (m_gaplist.size()*2);
786 if (!m_corrupted_list.empty()) {
787 ++tagcount;
788 }
789
790 if (m_pAICHHashSet->HasValidMasterHash() && (m_pAICHHashSet->GetStatus() == AICH_VERIFIED)){
791 ++tagcount;
792 }
793
794 if (GetLastPublishTimeKadSrc()){
795 ++tagcount;
796 }
797
798 if (GetLastPublishTimeKadNotes()){
799 ++tagcount;
800 }
801
802 if (GetDlActiveTime()){
803 ++tagcount;
804 }
805
806 file.WriteUInt32(tagcount);
807
808 //#warning Kry - Where are lost by coruption and gained by compression?
809
810 // 0 (unicoded part file name)
811 // We write it with BOM to keep eMule compatibility. Note that the 'printable' filename is saved,
812 // as presently the filename does not represent an actual file.
813 CTagString( FT_FILENAME, GetFileName().GetPrintable()).WriteTagToFile( &file, utf8strOptBOM );
814 CTagString( FT_FILENAME, GetFileName().GetPrintable()).WriteTagToFile( &file ); // 1
815
816 CTagIntSized( FT_FILESIZE, GetFileSize(), IsLargeFile() ? 64 : 32).WriteTagToFile( &file );// 2
817 CTagIntSized( FT_TRANSFERRED, transferred, IsLargeFile() ? 64 : 32).WriteTagToFile( &file ); // 3
818 CTagInt32( FT_STATUS, (m_paused?1:0)).WriteTagToFile( &file ); // 4
819
820 if ( IsAutoDownPriority() ) {
821 CTagInt32( FT_DLPRIORITY, (uint8)PR_AUTO ).WriteTagToFile( &file ); // 5
822 CTagInt32( FT_OLDDLPRIORITY, (uint8)PR_AUTO ).WriteTagToFile( &file ); // 6
823 } else {
824 CTagInt32( FT_DLPRIORITY, m_iDownPriority ).WriteTagToFile( &file ); // 5
825 CTagInt32( FT_OLDDLPRIORITY, m_iDownPriority ).WriteTagToFile( &file ); // 6
826 }
827
828 CTagInt32( FT_LASTSEENCOMPLETE, lsc ).WriteTagToFile( &file ); // 7
829
830 if ( IsAutoUpPriority() ) {
831 CTagInt32( FT_ULPRIORITY, (uint8)PR_AUTO ).WriteTagToFile( &file ); // 8
832 CTagInt32( FT_OLDULPRIORITY, (uint8)PR_AUTO ).WriteTagToFile( &file ); // 9
833 } else {
834 CTagInt32( FT_ULPRIORITY, GetUpPriority() ).WriteTagToFile( &file ); // 8
835 CTagInt32( FT_OLDULPRIORITY, GetUpPriority() ).WriteTagToFile( &file ); // 9
836 }
837
838 CTagInt32(FT_CATEGORY, m_category).WriteTagToFile( &file ); // 10
839 CTagInt32(FT_ATTRANSFERRED, statistic.GetAllTimeTransferred() & 0xFFFFFFFF).WriteTagToFile( &file );// 11
840 CTagInt32(FT_ATTRANSFERREDHI, statistic.GetAllTimeTransferred() >>32).WriteTagToFile( &file );// 12
841 CTagInt32(FT_ATREQUESTED, statistic.GetAllTimeRequests()).WriteTagToFile( &file ); // 13
842 CTagInt32(FT_ATACCEPTED, statistic.GetAllTimeAccepts()).WriteTagToFile( &file ); // 14
843
844 // currupt part infos
845 if (!m_corrupted_list.empty()) {
846 wxString strCorruptedParts;
847 std::list<uint16>::iterator it = m_corrupted_list.begin();
848 for (; it != m_corrupted_list.end(); ++it) {
849 uint16 uCorruptedPart = *it;
850 if (!strCorruptedParts.IsEmpty()) {
851 strCorruptedParts += wxT(",");
852 }
853 strCorruptedParts += CFormat(wxT("%u")) % uCorruptedPart;
854 }
855 wxASSERT( !strCorruptedParts.IsEmpty() );
856
857 CTagString( FT_CORRUPTEDPARTS, strCorruptedParts ).WriteTagToFile( &file); // 11?
858 }
859
860 //AICH Filehash
861 if (m_pAICHHashSet->HasValidMasterHash() && (m_pAICHHashSet->GetStatus() == AICH_VERIFIED)){
862 CTagString aichtag(FT_AICH_HASH, m_pAICHHashSet->GetMasterHash().GetString() );
863 aichtag.WriteTagToFile(&file); // 12?
864 }
865
866 if (GetLastPublishTimeKadSrc()){
867 CTagInt32(FT_KADLASTPUBLISHSRC, GetLastPublishTimeKadSrc()).WriteTagToFile(&file); // 15?
868 }
869
870 if (GetLastPublishTimeKadNotes()){
871 CTagInt32(FT_KADLASTPUBLISHNOTES, GetLastPublishTimeKadNotes()).WriteTagToFile(&file); // 16?
872 }
873
874 if (GetDlActiveTime()){
875 CTagInt32(FT_DL_ACTIVE_TIME, GetDlActiveTime()).WriteTagToFile(&file); // 17
876 }
877
878 for (uint32 j = 0; j < (uint32)m_taglist.size();++j) {
879 m_taglist[j].WriteTagToFile(&file);
880 }
881
882 // gaps
883 unsigned i_pos = 0;
884 for (CGapList::const_iterator it = m_gaplist.begin(); it != m_gaplist.end(); ++it) {
885 wxString tagName = CFormat(wxT(" %u")) % i_pos;
886
887 // gap start = first missing byte but gap ends = first non-missing byte
888 // in edonkey but I think its easier to user the real limits
889 tagName[0] = FT_GAPSTART;
890 CTagIntSized(tagName, it.start(), IsLargeFile() ? 64 : 32).WriteTagToFile( &file );
891
892 tagName[0] = FT_GAPEND;
893 CTagIntSized(tagName, it.end() + 1, IsLargeFile() ? 64 : 32).WriteTagToFile( &file );
894
895 ++i_pos;
896 }
897 } catch (const wxString& error) {
898 AddLogLineNS(CFormat( _("ERROR while saving partfile: %s (%s ==> %s)") )
899 % error
900 % m_partmetfilename
901 % GetFileName() );
902
903 return false;
904 } catch (const CIOFailureException& e) {
905 AddLogLineCS(_("IO failure while saving partfile: ") + e.what());
906
907 return false;
908 }
909
910 file.Close();
911
912 if (!Initial) {
913 CPath::RemoveFile(m_fullname.AppendExt(wxT(".backup")));
914 }
915
916 sint64 metLength = m_fullname.GetFileSize();
917 if (metLength == wxInvalidOffset) {
918 theApp->ShowAlert( CFormat( _("Could not retrieve length of '%s' - using %s file.") )
919 % m_fullname
920 % PARTMET_BAK_EXT,
921 _("Message"), wxOK);
922
923 CPath::CloneFile(m_fullname.AppendExt(PARTMET_BAK_EXT), m_fullname, true);
924 } else if (metLength == 0) {
925 // Don't backup if it's 0 size but raise a warning!!!
926 theApp->ShowAlert( CFormat( _("'%s' is 0 size somehow - using %s file.") )
927 % m_fullname
928 % PARTMET_BAK_EXT,
929 _("Message"), wxOK);
930
931 CPath::CloneFile(m_fullname.AppendExt(PARTMET_BAK_EXT), m_fullname, true);
932 } else {
933 // no error, just backup
934 CPath::BackupFile(m_fullname, PARTMET_BAK_EXT);
935 }
936
937 return true;
938 }
939
940
941 void CPartFile::SaveSourceSeeds()
942 {
943 #define MAX_SAVED_SOURCES 10
944
945 // Kry - Sources seeds
946 // Based on a Feature request, this saves the last MAX_SAVED_SOURCES
947 // sources of the file, giving a 'seed' for the next run.
948 // We save the last sources because:
949 // 1 - They could be the hardest to get
950 // 2 - They will more probably be available
951 // However, if we have downloading sources, they have preference because
952 // we probably have more credits on them.
953 // Anyway, source exchange will get us the rest of the sources
954 // This feature is currently used only on rare files (< 20 sources)
955 //
956
957 if (GetSourceCount()>20) {
958 return;
959 }
960
961 CClientRefList source_seeds;
962 int n_sources = 0;
963
964 CClientRefList::iterator it = m_downloadingSourcesList.begin();
965 for( ; it != m_downloadingSourcesList.end() && n_sources < MAX_SAVED_SOURCES; ++it) {
966 if (!it->HasLowID()) {
967 source_seeds.push_back(*it);
968 ++n_sources;
969 }
970 }
971
972 if (n_sources < MAX_SAVED_SOURCES) {
973 // Not enough downloading sources to fill the list, going to sources list
974 if (GetSourceCount() > 0) {
975 SourceSet::reverse_iterator rit = m_SrcList.rbegin();
976 for ( ; ((rit != m_SrcList.rend()) && (n_sources<MAX_SAVED_SOURCES)); ++rit) {
977 if (!rit->HasLowID()) {
978 source_seeds.push_back(*rit);
979 ++n_sources;
980 }
981 }
982 }
983 }
984
985 // Write the file
986 if (!n_sources) {
987 return;
988 }
989
990 const CPath seedsPath = m_fullname.AppendExt(wxT(".seeds"));
991
992 CFile file;
993 file.Create(seedsPath, true);
994 if (!file.IsOpened()) {
995 AddLogLineN(CFormat( _("Failed to save part.met.seeds file for %s") )
996 % m_fullname);
997 return;
998 }
999
1000 try {
1001 file.WriteUInt8(0); // v3, to avoid v2 clients choking on it.
1002 file.WriteUInt8(source_seeds.size());
1003
1004 CClientRefList::iterator it2 = source_seeds.begin();
1005 for (; it2 != source_seeds.end(); ++it2) {
1006 CUpDownClient* cur_src = it2->GetClient();
1007 file.WriteUInt32(cur_src->GetUserIDHybrid());
1008 file.WriteUInt16(cur_src->GetUserPort());
1009 file.WriteHash(cur_src->GetUserHash());
1010 // CryptSettings - See SourceExchange V4
1011 const uint8 uSupportsCryptLayer = cur_src->SupportsCryptLayer() ? 1 : 0;
1012 const uint8 uRequestsCryptLayer = cur_src->RequestsCryptLayer() ? 1 : 0;
1013 const uint8 uRequiresCryptLayer = cur_src->RequiresCryptLayer() ? 1 : 0;
1014 const uint8 byCryptOptions = (uRequiresCryptLayer << 2) | (uRequestsCryptLayer << 1) | (uSupportsCryptLayer << 0);
1015 file.WriteUInt8(byCryptOptions);
1016 }
1017
1018 /* v2: Added to keep track of too old seeds */
1019 file.WriteUInt32(wxDateTime::Now().GetTicks());
1020
1021 AddLogLineN(CFormat( wxPLURAL("Saved %i source seed for partfile: %s (%s)", "Saved %i source seeds for partfile: %s (%s)", n_sources) )
1022 % n_sources
1023 % m_fullname
1024 % GetFileName());
1025 } catch (const CIOFailureException& e) {
1026 AddDebugLogLineC( logPartFile, CFormat( wxT("Error saving partfile's seeds file (%s - %s): %s") )
1027 % m_partmetfilename
1028 % GetFileName()
1029 % e.what() );
1030
1031 n_sources = 0;
1032 file.Close();
1033 CPath::RemoveFile(seedsPath);
1034 }
1035 }
1036
1037 void CPartFile::LoadSourceSeeds()
1038 {
1039 CMemFile sources_data;
1040
1041 bool valid_sources = false;
1042
1043 const CPath seedsPath = m_fullname.AppendExt(wxT(".seeds"));
1044 if (!seedsPath.FileExists()) {
1045 return;
1046 }
1047
1048 CFile file(seedsPath, CFile::read);
1049 if (!file.IsOpened()) {
1050 // Exists but can't be opened. Should not happen. Probably permission problem, try to remove it.
1051 AddLogLineN(CFormat( _("Can't read seeds file for Partfile %s (%s)") )
1052 % m_partmetfilename
1053 % GetFileName() );
1054 CPath::RemoveFile(seedsPath);
1055 return;
1056 }
1057
1058 bool badSeedsFile = false;
1059 try {
1060 uint8 src_count = file.ReadUInt8();
1061
1062 bool bUseSX2Format = (src_count == 0);
1063
1064 if (bUseSX2Format) {
1065 // v3 sources seeds
1066 src_count = file.ReadUInt8();
1067 }
1068
1069 sources_data.WriteUInt16(src_count);
1070
1071 for (int i = 0; i< src_count; ++i) {
1072 uint32 dwID = file.ReadUInt32();
1073 uint16 nPort = file.ReadUInt16();
1074
1075 sources_data.WriteUInt32(bUseSX2Format ? dwID : wxUINT32_SWAP_ALWAYS(dwID));
1076 sources_data.WriteUInt16(nPort);
1077 sources_data.WriteUInt32(0);
1078 sources_data.WriteUInt16(0);
1079
1080 if (bUseSX2Format) {
1081 sources_data.WriteHash(file.ReadHash());
1082 sources_data.WriteUInt8(file.ReadUInt8());
1083 }
1084
1085 }
1086
1087 if (!file.Eof()) {
1088
1089 // v2: Added to keep track of too old seeds
1090 time_t time = (time_t)file.ReadUInt32();
1091
1092 // Time frame is 2 hours. More than enough to compile
1093 // your new aMule version!.
1094 if ((time + MIN2S(120)) >= wxDateTime::Now().GetTicks()) {
1095 valid_sources = true;
1096 }
1097
1098 } else {
1099 // v1 has no time data. We can safely use
1100 // the sources, next time will be saved.
1101 valid_sources = true;
1102 }
1103
1104 if (valid_sources) {
1105 sources_data.Seek(0);
1106 AddClientSources(&sources_data, SF_SOURCE_SEEDS, bUseSX2Format ? 4 : 1, bUseSX2Format);
1107 }
1108
1109 } catch (const CSafeIOException& e) {
1110 AddLogLineN(CFormat( _("Error reading partfile's seeds file (%s - %s): %s") )
1111 % m_partmetfilename
1112 % GetFileName()
1113 % e.what() );
1114 badSeedsFile = true;
1115 }
1116
1117 file.Close();
1118 if (badSeedsFile) {
1119 // If we got an exception reading it remove it.
1120 CPath::RemoveFile(seedsPath);
1121 }
1122 }
1123
1124 void CPartFile::PartFileHashFinished(CKnownFile* result)
1125 {
1126 m_lastDateChanged = result->m_lastDateChanged;
1127 bool errorfound = false;
1128 if (GetED2KPartHashCount() == 0){
1129 if (IsComplete(0, GetFileSize()-1)){
1130 if (result->GetFileHash() != GetFileHash()){
1131 // cppcheck-suppress zerodiv
1132 AddLogLineN(CFormat(wxPLURAL(
1133 "Found corrupted part (%d) in %d part file %s - FileResultHash |%s| FileHash |%s|",
1134 "Found corrupted part (%d) in %d parts file %s - FileResultHash |%s| FileHash |%s|",
1135 0)
1136 )
1137 % 1
1138 % 0
1139 % GetFileName()
1140 % result->GetFileHash().Encode()
1141 % GetFileHash().Encode() );
1142 AddGap(0, GetFileSize()-1);
1143 errorfound = true;
1144 }
1145 }
1146 }
1147 else{
1148 for (size_t i = 0; i < m_hashlist.size(); ++i){
1149 // Kry - trel_ar's completed parts check on rehashing.
1150 // Very nice feature, if a file is completed but .part.met don't believe it,
1151 // update it.
1152
1153 if (!( i < result->GetHashCount() && (result->GetPartHash(i) == GetPartHash(i)))){
1154 if (IsComplete(i)) {
1155 CMD4Hash wronghash;
1156 if ( i < result->GetHashCount() )
1157 wronghash = result->GetPartHash(i);
1158
1159 AddLogLineN(CFormat(wxPLURAL(
1160 "Found corrupted part (%d) in %d part file %s - FileResultHash |%s| FileHash |%s|",
1161 "Found corrupted part (%d) in %d parts file %s - FileResultHash |%s| FileHash |%s|",
1162 GetED2KPartHashCount())
1163 )
1164 % ( i + 1 )
1165 % GetED2KPartHashCount()
1166 % GetFileName()
1167 % wronghash.Encode()
1168 % GetPartHash(i).Encode() );
1169
1170 AddGap(i);
1171 errorfound = true;
1172 }
1173 } else {
1174 if (!IsComplete(i)){
1175 AddLogLineN(CFormat( _("Found completed part (%i) in %s") )
1176 % ( i + 1 )
1177 % GetFileName() );
1178
1179 FillGap(i);
1180 uint64 partStart = i * PARTSIZE;
1181 uint64 partEnd = partStart + GetPartSize(i) - 1;
1182 RemoveBlockFromList(partStart, partEnd);
1183 }
1184 }
1185 }
1186 }
1187
1188 if ( !errorfound &&
1189 result->GetAICHHashset()->GetStatus() == AICH_HASHSETCOMPLETE &&
1190 status == PS_COMPLETING) {
1191 delete m_pAICHHashSet;
1192 m_pAICHHashSet = result->GetAICHHashset();
1193 result->SetAICHHashset(NULL);
1194 m_pAICHHashSet->SetOwner(this);
1195 }
1196 else if (status == PS_COMPLETING) {
1197 AddDebugLogLineN(logPartFile,
1198 CFormat(wxT("Failed to store new AICH Hashset for completed file: %s"))
1199 % GetFileName());
1200 }
1201
1202
1203 delete result;
1204 if (!errorfound){
1205 if (status == PS_COMPLETING){
1206 CompleteFile(true);
1207 return;
1208 }
1209 else {
1210 AddLogLineN(CFormat( _("Finished rehashing %s") ) % GetFileName());
1211 }
1212 }
1213 else{
1214 SetStatus(PS_READY);
1215 SavePartFile();
1216 return;
1217 }
1218 SetStatus(PS_READY);
1219 SavePartFile();
1220 theApp->sharedfiles->SafeAddKFile(this);
1221 }
1222
1223 void CPartFile::AddGap(uint64 start, uint64 end)
1224 {
1225 m_gaplist.AddGap(start, end);
1226 UpdateDisplayedInfo();
1227 }
1228
1229 void CPartFile::AddGap(uint16 part)
1230 {
1231 m_gaplist.AddGap(part);
1232 UpdateDisplayedInfo();
1233 }
1234
1235 bool CPartFile::IsAlreadyRequested(uint64 start, uint64 end)
1236 {
1237 std::list<Requested_Block_Struct*>::iterator it = m_requestedblocks_list.begin();
1238 for (; it != m_requestedblocks_list.end(); ++it) {
1239 Requested_Block_Struct* cur_block = *it;
1240
1241 if ((start <= cur_block->EndOffset) && (end >= cur_block->StartOffset)) {
1242 return true;
1243 }
1244 }
1245 return false;
1246 }
1247
1248 bool CPartFile::GetNextEmptyBlockInPart(uint16 partNumber, Requested_Block_Struct *result)
1249 {
1250 // Find start of this part
1251 uint64 partStart = (PARTSIZE * partNumber);
1252 uint64 start = partStart;
1253
1254 // What is the end limit of this block, i.e. can't go outside part (or filesize)
1255 uint64 partEnd = partStart + GetPartSize(partNumber) - 1;
1256 // Loop until find a suitable gap and return true, or no more gaps and return false
1257 CGapList::const_iterator it = m_gaplist.begin();
1258 while (true) {
1259 bool noGap = true;
1260 uint64 gapStart, end;
1261
1262 // Find the first gap from the start position
1263 for (; it != m_gaplist.end(); ++it) {
1264 gapStart = it.start();
1265 end = it.end();
1266
1267 // Want gaps that overlap start<->partEnd
1268 if (gapStart <= partEnd && end >= start) {
1269 noGap = false;
1270 break;
1271 } else if (gapStart > partEnd) {
1272 break;
1273 }
1274 }
1275
1276 // If no gaps after start, exit
1277 if (noGap) {
1278 return false;
1279 }
1280 // Update start position if gap starts after current pos
1281 if (start < gapStart) {
1282 start = gapStart;
1283 }
1284 // Find end, keeping within the max block size and the part limit
1285 uint64 blockLimit = partStart + (BLOCKSIZE * (((start - partStart) / BLOCKSIZE) + 1)) - 1;
1286 if (end > blockLimit) {
1287 end = blockLimit;
1288 }
1289 if (end > partEnd) {
1290 end = partEnd;
1291 }
1292 // If this gap has not already been requested, we have found a valid entry
1293 if (!IsAlreadyRequested(start, end)) {
1294 // Was this block to be returned
1295 if (result != NULL) {
1296 result->StartOffset = start;
1297 result->EndOffset = end;
1298 md4cpy(result->FileID, GetFileHash().GetHash());
1299 result->transferred = 0;
1300 }
1301 return true;
1302 } else {
1303 // Reposition to end of that gap
1304 start = end + 1;
1305 }
1306 // If tried all gaps then break out of the loop
1307 if (end == partEnd) {
1308 break;
1309 }
1310 }
1311 // No suitable gap found
1312 return false;
1313 }
1314
1315
1316 void CPartFile::FillGap(uint64 start, uint64 end)
1317 {
1318 m_gaplist.FillGap(start, end);
1319 UpdateCompletedInfos();
1320 UpdateDisplayedInfo();
1321 }
1322
1323 void CPartFile::FillGap(uint16 part)
1324 {
1325 m_gaplist.FillGap(part);
1326 UpdateCompletedInfos();
1327 UpdateDisplayedInfo();
1328 }
1329
1330
1331 void CPartFile::UpdateCompletedInfos()
1332 {
1333 uint64 allgaps = m_gaplist.GetGapSize();
1334
1335 percentcompleted = (1.0 - (double)allgaps/GetFileSize()) * 100.0;
1336 completedsize = GetFileSize() - allgaps;
1337 }
1338
1339
1340 void CPartFile::WritePartStatus(CMemFile* file)
1341 {
1342 uint16 parts = GetED2KPartCount();
1343 file->WriteUInt16(parts);
1344 uint16 done = 0;
1345 while (done != parts){
1346 uint8 towrite = 0;
1347 for (uint32 i = 0;i != 8;++i) {
1348 if (IsComplete(done)) {
1349 towrite |= (1<<i);
1350 }
1351 ++done;
1352 if (done == parts) {
1353 break;
1354 }
1355 }
1356 file->WriteUInt8(towrite);
1357 }
1358 }
1359
1360 void CPartFile::WriteCompleteSourcesCount(CMemFile* file)
1361 {
1362 file->WriteUInt16(m_nCompleteSourcesCount);
1363 }
1364
1365 uint32 CPartFile::Process(uint32 reducedownload/*in percent*/,uint8 m_icounter)
1366 {
1367 uint16 old_trans;
1368 uint32 dwCurTick = ::GetTickCount();
1369
1370 // If buffer size exceeds limit, or if not written within time limit, flush data
1371 if ( (m_nTotalBufferData > thePrefs::GetFileBufferSize()) ||
1372 (dwCurTick > (m_nLastBufferFlushTime + BUFFER_TIME_LIMIT))) {
1373 FlushBuffer();
1374 }
1375
1376
1377 // check if we want new sources from server --> MOVED for 16.40 version
1378 old_trans=transferingsrc;
1379 transferingsrc = 0;
1380 kBpsDown = 0.0;
1381
1382 if (m_icounter < 10) {
1383 // Update only downloading sources.
1384 CClientRefList::iterator it = m_downloadingSourcesList.begin();
1385 for( ; it != m_downloadingSourcesList.end(); ) {
1386 CUpDownClient *cur_src = it++->GetClient();
1387 if(cur_src->GetDownloadState() == DS_DOWNLOADING) {
1388 ++transferingsrc;
1389 kBpsDown += cur_src->SetDownloadLimit(reducedownload);
1390 }
1391 }
1392 } else {
1393 // Update all sources (including downloading sources)
1394 for ( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ) {
1395 CUpDownClient* cur_src = it++->GetClient();
1396 switch (cur_src->GetDownloadState()) {
1397 case DS_DOWNLOADING: {
1398 ++transferingsrc;
1399 kBpsDown += cur_src->SetDownloadLimit(reducedownload);
1400 break;
1401 }
1402 case DS_BANNED: {
1403 break;
1404 }
1405 case DS_ERROR: {
1406 break;
1407 }
1408 case DS_LOWTOLOWIP: {
1409 if (cur_src->HasLowID() && !theApp->CanDoCallback(cur_src->GetServerIP(), cur_src->GetServerPort())) {
1410 // If we are almost maxed on sources,
1411 // slowly remove these client to see
1412 // if we can find a better source.
1413 if (((dwCurTick - lastpurgetime) > 30000) &&
1414 (GetSourceCount() >= (thePrefs::GetMaxSourcePerFile()*.8))) {
1415 RemoveSource(cur_src);
1416 lastpurgetime = dwCurTick;
1417 break;
1418 }
1419 } else {
1420 cur_src->SetDownloadState(DS_ONQUEUE);
1421 }
1422
1423 break;
1424 }
1425 case DS_NONEEDEDPARTS: {
1426 // we try to purge noneeded source, even without reaching the limit
1427 if((dwCurTick - lastpurgetime) > 40000) {
1428 if(!cur_src->SwapToAnotherFile(false , false, false , NULL)) {
1429 //however we only delete them if reaching the limit
1430 if (GetSourceCount() >= (thePrefs::GetMaxSourcePerFile()*.8 )) {
1431 RemoveSource(cur_src);
1432 lastpurgetime = dwCurTick;
1433 break; //Johnny-B - nothing more to do here (good eye!)
1434 }
1435 } else {
1436 lastpurgetime = dwCurTick;
1437 break;
1438 }
1439 }
1440 // doubled reasktime for no needed parts - save connections and traffic
1441 if ( !((!cur_src->GetLastAskedTime()) ||
1442 (dwCurTick - cur_src->GetLastAskedTime()) > FILEREASKTIME*2)) {
1443 break;
1444 }
1445 // Recheck this client to see if still NNP..
1446 // Set to DS_NONE so that we force a TCP reask next time..
1447 cur_src->SetDownloadState(DS_NONE);
1448
1449 break;
1450 }
1451 case DS_ONQUEUE: {
1452 if( cur_src->IsRemoteQueueFull()) {
1453 if( ((dwCurTick - lastpurgetime) > 60000) &&
1454 (GetSourceCount() >= (thePrefs::GetMaxSourcePerFile()*.8 )) ) {
1455 RemoveSource( cur_src );
1456 lastpurgetime = dwCurTick;
1457 break; //Johnny-B - nothing more to do here (good eye!)
1458 }
1459 }
1460
1461 // Give up to 1 min for UDP to respond..
1462 // If we are within on min on TCP, do not try..
1463 if ( theApp->IsConnected() &&
1464 ( (!cur_src->GetLastAskedTime()) ||
1465 (dwCurTick - cur_src->GetLastAskedTime()) > FILEREASKTIME-20000)) {
1466 cur_src->UDPReaskForDownload();
1467 }
1468
1469 // No break here, since the next case takes care of asking for downloads.
1470 }
1471 /* fall through */
1472 case DS_CONNECTING:
1473 case DS_TOOMANYCONNS:
1474 case DS_NONE:
1475 case DS_WAITCALLBACK:
1476 case DS_WAITCALLBACKKAD: {
1477 if ( theApp->IsConnected() &&
1478 ( (!cur_src->GetLastAskedTime()) ||
1479 (dwCurTick - cur_src->GetLastAskedTime()) > FILEREASKTIME)) {
1480 if (!cur_src->AskForDownload()) {
1481 // I left this break here just as a reminder
1482 // just in case re rearange things..
1483 break;
1484 }
1485 }
1486 break;
1487 }
1488 }
1489 }
1490
1491 /* eMule 0.30c implementation, i give it a try (Creteil) BEGIN ... */
1492 if (IsA4AFAuto() && ((!m_LastNoNeededCheck) || (dwCurTick - m_LastNoNeededCheck > 900000))) {
1493 m_LastNoNeededCheck = dwCurTick;
1494 for ( SourceSet::iterator it = m_A4AFsrclist.begin(); it != m_A4AFsrclist.end(); ) {
1495 CUpDownClient *cur_source = it++->GetClient();
1496 uint8 download_state=cur_source->GetDownloadState();
1497 if( download_state != DS_DOWNLOADING
1498 && cur_source->GetRequestFile()
1499 && ((!cur_source->GetRequestFile()->IsA4AFAuto()) || download_state == DS_NONEEDEDPARTS))
1500 {
1501 cur_source->SwapToAnotherFile(false, false, false, this);
1502 }
1503 }
1504 }
1505 /* eMule 0.30c implementation, i give it a try (Creteil) END ... */
1506
1507 // swap No needed partfiles if possible
1508
1509 if (((old_trans==0) && (transferingsrc>0)) || ((old_trans>0) && (transferingsrc==0))) {
1510 SetStatus(status);
1511 }
1512
1513 // Kad source search
1514 if( GetMaxSourcePerFileUDP() > GetSourceCount()){
1515 //Once we can handle lowID users in Kad, we remove the second IsConnected
1516 if (theApp->downloadqueue->DoKademliaFileRequest() && (Kademlia::CKademlia::GetTotalFile() < KADEMLIATOTALFILE) && (dwCurTick > m_LastSearchTimeKad) && Kademlia::CKademlia::IsConnected() && theApp->IsConnected() && !IsStopped()){
1517 //Kademlia
1518 theApp->downloadqueue->SetLastKademliaFileRequest();
1519
1520 if (GetKadFileSearchID()) {
1521 /* This will never happen anyway. We're talking a
1522 1h timespan and searches are at max 45secs */
1523 Kademlia::CSearchManager::StopSearch(GetKadFileSearchID(), false);
1524 }
1525
1526 Kademlia::CUInt128 kadFileID(GetFileHash().GetHash());
1527 Kademlia::CSearch* pSearch = Kademlia::CSearchManager::PrepareLookup(Kademlia::CSearch::FILE, true, kadFileID);
1528 AddDebugLogLineN(logKadSearch, CFormat(wxT("Preparing a Kad Search for '%s'")) % GetFileName());
1529 if (pSearch) {
1530 AddDebugLogLineN(logKadSearch, CFormat(wxT("Kad lookup started for '%s'")) % GetFileName());
1531 if(m_TotalSearchesKad < 7) {
1532 m_TotalSearchesKad++;
1533 }
1534 m_LastSearchTimeKad = dwCurTick + (KADEMLIAREASKTIME*m_TotalSearchesKad);
1535 SetKadFileSearchID(pSearch->GetSearchID());
1536 }
1537 }
1538 } else {
1539 if(GetKadFileSearchID()) {
1540 Kademlia::CSearchManager::StopSearch(GetKadFileSearchID(), true);
1541 }
1542 }
1543
1544 // check if we want new sources from server
1545 if ( !m_localSrcReqQueued &&
1546 ( (!m_lastsearchtime) ||
1547 (dwCurTick - m_lastsearchtime) > SERVERREASKTIME) &&
1548 theApp->IsConnectedED2K() &&
1549 thePrefs::GetMaxSourcePerFileSoft() > GetSourceCount() &&
1550 !m_stopped ) {
1551 m_localSrcReqQueued = true;
1552 theApp->downloadqueue->SendLocalSrcRequest(this);
1553 }
1554
1555 // calculate datarate, set limit etc.
1556 }
1557
1558 ++m_count;
1559
1560 // Kry - does the 3 / 30 difference produce too much flickering or CPU?
1561 if (m_count >= 30) {
1562 m_count = 0;
1563 UpdateAutoDownPriority();
1564 UpdateDisplayedInfo();
1565 if(m_bPercentUpdated == false) {
1566 UpdateCompletedInfos();
1567 }
1568 m_bPercentUpdated = false;
1569 }
1570
1571 // release file handle if unused for some time
1572 m_hpartfile.Release();
1573
1574 return (uint32)(kBpsDown*1024.0);
1575 }
1576
1577 bool CPartFile::CanAddSource(uint32 userid, uint16 port, uint32 serverip, uint16 serverport, uint8* pdebug_lowiddropped, bool ed2kID)
1578 {
1579
1580 //The incoming ID could have the userid in the Hybrid format..
1581 uint32 hybridID = 0;
1582 if( ed2kID ) {
1583 if (IsLowID(userid)) {
1584 hybridID = userid;
1585 } else {
1586 hybridID = wxUINT32_SWAP_ALWAYS(userid);
1587 }
1588 } else {
1589 hybridID = userid;
1590 if (!IsLowID(userid)) {
1591 userid = wxUINT32_SWAP_ALWAYS(userid);
1592 }
1593 }
1594
1595 // MOD Note: Do not change this part - Merkur
1596 if (theApp->IsConnectedED2K()) {
1597 if(::IsLowID(theApp->GetED2KID())) {
1598 if(theApp->GetED2KID() == userid && theApp->serverconnect->GetCurrentServer()->GetIP() == serverip && theApp->serverconnect->GetCurrentServer()->GetPort() == serverport ) {
1599 return false;
1600 }
1601 if(theApp->GetPublicIP() == userid) {
1602 return false;
1603 }
1604 } else {
1605 if(theApp->GetED2KID() == userid && thePrefs::GetPort() == port) {
1606 return false;
1607 }
1608 }
1609 }
1610
1611 if (Kademlia::CKademlia::IsConnected()) {
1612 if(!Kademlia::CKademlia::IsFirewalled()) {
1613 if(Kademlia::CKademlia::GetIPAddress() == hybridID && thePrefs::GetPort() == port) {
1614 return false;
1615 }
1616 }
1617 }
1618
1619 //This allows *.*.*.0 clients to not be removed if Ed2kID == false
1620 if ( IsLowID(hybridID) && theApp->IsFirewalled()) {
1621 if (pdebug_lowiddropped) {
1622 (*pdebug_lowiddropped)++;
1623 }
1624 return false;
1625 }
1626 // MOD Note - end
1627 return true;
1628 }
1629
1630 void CPartFile::AddSources(CMemFile& sources,uint32 serverip, uint16 serverport, unsigned origin, bool bWithObfuscationAndHash)
1631 {
1632 uint8 count = sources.ReadUInt8();
1633 uint8 debug_lowiddropped = 0;
1634 uint8 debug_possiblesources = 0;
1635 CMD4Hash achUserHash;
1636
1637 if (m_stopped) {
1638 // since we may received multiple search source UDP results we have to "consume" all data of that packet
1639 AddDebugLogLineN(logPartFile, wxT("Trying to add sources for a stopped file"));
1640 sources.Seek(count*(4+2), wxFromCurrent);
1641 return;
1642 }
1643
1644 for (int i = 0;i != count;++i) {
1645 uint32 userid = sources.ReadUInt32();
1646 uint16 port = sources.ReadUInt16();
1647
1648 uint8 byCryptOptions = 0;
1649 if (bWithObfuscationAndHash){
1650 byCryptOptions = sources.ReadUInt8();
1651 if ((byCryptOptions & 0x80) > 0) {
1652 achUserHash = sources.ReadHash();
1653 }
1654
1655 if ((thePrefs::IsClientCryptLayerRequested() && (byCryptOptions & 0x01/*supported*/) > 0 && (byCryptOptions & 0x80) == 0)
1656 || (thePrefs::IsClientCryptLayerSupported() && (byCryptOptions & 0x02/*requested*/) > 0 && (byCryptOptions & 0x80) == 0)) {
1657 AddDebugLogLineN(logPartFile, CFormat(wxT("Server didn't provide UserHash for source %u, even if it was expected to (or local obfuscationsettings changed during serverconnect")) % userid);
1658 } else if (!thePrefs::IsClientCryptLayerRequested() && (byCryptOptions & 0x02/*requested*/) == 0 && (byCryptOptions & 0x80) != 0) {
1659 AddDebugLogLineN(logPartFile, CFormat(wxT("Server provided UserHash for source %u, even if it wasn't expected to (or local obfuscationsettings changed during serverconnect")) % userid);
1660 }
1661 }
1662
1663
1664 // "Filter LAN IPs" and "IPfilter" the received sources IP addresses
1665 if (!IsLowID(userid)) {
1666 // check for 0-IP, localhost and optionally for LAN addresses
1667 if ( !IsGoodIP(userid, thePrefs::FilterLanIPs()) ) {
1668 continue;
1669 }
1670 if (theApp->ipfilter->IsFiltered(userid)) {
1671 continue;
1672 }
1673 }
1674
1675 if (!CanAddSource(userid, port, serverip, serverport, &debug_lowiddropped)) {
1676 continue;
1677 }
1678
1679 if(thePrefs::GetMaxSourcePerFile() > GetSourceCount()) {
1680 ++debug_possiblesources;
1681 CUpDownClient* newsource = new CUpDownClient(port,userid,serverip,serverport,this, true, true);
1682
1683 newsource->SetSourceFrom((ESourceFrom)origin);
1684 newsource->SetConnectOptions(byCryptOptions, true, false);
1685
1686 if ((byCryptOptions & 0x80) != 0) {
1687 newsource->SetUserHash(achUserHash);
1688 }
1689
1690 theApp->downloadqueue->CheckAndAddSource(this,newsource);
1691 } else {
1692 AddDebugLogLineN(logPartFile, wxT("Consuming a packet because of max sources reached"));
1693 // Since we may receive multiple search source UDP results we have to "consume" all data of that packet
1694 // This '+1' is added because 'i' counts from 0.
1695 sources.Seek((count-(i+1))*(4+2), wxFromCurrent);
1696 if (GetKadFileSearchID()) {
1697 Kademlia::CSearchManager::StopSearch(GetKadFileSearchID(), false);
1698 }
1699 break;
1700 }
1701 }
1702 }
1703
1704 void CPartFile::UpdatePartsInfo()
1705 {
1706 if( !IsPartFile() ) {
1707 CKnownFile::UpdatePartsInfo();
1708 return;
1709 }
1710
1711 // Cache part count
1712 uint16 partcount = GetPartCount();
1713 bool flag = (time(NULL) - m_nCompleteSourcesTime > 0);
1714
1715 // Ensure the frequency-list is ready
1716 if ( m_SrcpartFrequency.size() != GetPartCount() ) {
1717 m_SrcpartFrequency.clear();
1718 m_SrcpartFrequency.insert(m_SrcpartFrequency.begin(), GetPartCount(), 0);
1719 }
1720
1721 // Find number of available parts
1722 uint16 availablecounter = 0;
1723 for ( uint16 i = 0; i < partcount; ++i ) {
1724 if ( m_SrcpartFrequency[i] )
1725 ++availablecounter;
1726 }
1727
1728 if ( ( availablecounter == partcount ) && ( m_availablePartsCount < partcount ) ) {
1729 lastseencomplete = time(NULL);
1730 }
1731
1732 m_availablePartsCount = availablecounter;
1733
1734 if ( flag ) {
1735 ArrayOfUInts16 count;
1736
1737 count.reserve(GetSourceCount());
1738
1739 for ( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ++it ) {
1740 CUpDownClient* client = it->GetClient();
1741 if ( !client->GetUpPartStatus().empty() && client->GetUpPartCount() == partcount ) {
1742 count.push_back(client->GetUpCompleteSourcesCount());
1743 }
1744 }
1745
1746 m_nCompleteSourcesCount = m_nCompleteSourcesCountLo = m_nCompleteSourcesCountHi = 0;
1747
1748 for (uint16 i = 0; i < partcount; ++i) {
1749 if( !i ) {
1750 m_nCompleteSourcesCount = m_SrcpartFrequency[i];
1751 }
1752 else if( m_nCompleteSourcesCount > m_SrcpartFrequency[i]) {
1753 m_nCompleteSourcesCount = m_SrcpartFrequency[i];
1754 }
1755 }
1756 count.push_back(m_nCompleteSourcesCount);
1757
1758 int32 n = count.size();
1759 if (n > 0) {
1760 std::sort(count.begin(), count.end(), std::less<uint16>());
1761
1762 // calculate range
1763 int32 i= n >> 1; // (n / 2)
1764 int32 j= (n * 3) >> 2; // (n * 3) / 4
1765 int32 k= (n * 7) >> 3; // (n * 7) / 8
1766
1767 //When still a part file, adjust your guesses by 20% to what you see..
1768
1769
1770 if (n < 5) {
1771 //Not many sources, so just use what you see..
1772 // welcome to 'plain stupid code'
1773 // m_nCompleteSourcesCount;
1774 m_nCompleteSourcesCountLo= m_nCompleteSourcesCount;
1775 m_nCompleteSourcesCountHi= m_nCompleteSourcesCount;
1776 } else if (n < 20) {
1777 // For low guess and normal guess count
1778 // If we see more sources then the guessed low and normal, use what we see.
1779 // If we see less sources then the guessed low, adjust network accounts for 80%,
1780 // we account for 20% with what we see and make sure we are still above the normal.
1781 // For high guess
1782 // Adjust 80% network and 20% what we see.
1783 if ( count[i] < m_nCompleteSourcesCount ) {
1784 m_nCompleteSourcesCountLo = m_nCompleteSourcesCount;
1785 } else {
1786 m_nCompleteSourcesCountLo =
1787 (uint16)((float)(count[i]*.8) +
1788 (float)(m_nCompleteSourcesCount*.2));
1789 }
1790 m_nCompleteSourcesCount = m_nCompleteSourcesCountLo;
1791 m_nCompleteSourcesCountHi =
1792 (uint16)((float)(count[j]*.8) +
1793 (float)(m_nCompleteSourcesCount*.2));
1794 if( m_nCompleteSourcesCountHi < m_nCompleteSourcesCount ) {
1795 m_nCompleteSourcesCountHi = m_nCompleteSourcesCount;
1796 }
1797 } else {
1798 // Many sources
1799 // ------------
1800 // For low guess
1801 // Use what we see.
1802 // For normal guess
1803 // Adjust network accounts for 80%, we account for 20% with what
1804 // we see and make sure we are still above the low.
1805 // For high guess
1806 // Adjust network accounts for 80%, we account for 20% with what
1807 // we see and make sure we are still above the normal.
1808
1809 m_nCompleteSourcesCountLo= m_nCompleteSourcesCount;
1810 m_nCompleteSourcesCount= (uint16)((float)(count[j]*.8)+(float)(m_nCompleteSourcesCount*.2));
1811 if( m_nCompleteSourcesCount < m_nCompleteSourcesCountLo ) {
1812 m_nCompleteSourcesCount = m_nCompleteSourcesCountLo;
1813 }
1814 m_nCompleteSourcesCountHi= (uint16)((float)(count[k]*.8)+(float)(m_nCompleteSourcesCount*.2));
1815 if( m_nCompleteSourcesCountHi < m_nCompleteSourcesCount ) {
1816 m_nCompleteSourcesCountHi = m_nCompleteSourcesCount;
1817 }
1818 }
1819 }
1820 m_nCompleteSourcesTime = time(NULL) + (60);
1821 }
1822 UpdateDisplayedInfo();
1823 }
1824
1825 // [Maella -Enhanced Chunk Selection- (based on jicxicmic)]
1826 bool CPartFile::GetNextRequestedBlock(CUpDownClient* sender,
1827 std::vector<Requested_Block_Struct*>& toadd, uint16& count)
1828 {
1829
1830 // The purpose of this function is to return a list of blocks (~180KB) to
1831 // download. To avoid a prematurely stop of the downloading, all blocks that
1832 // are requested from the same source must be located within the same
1833 // chunk (=> part ~9MB).
1834 //
1835 // The selection of the chunk to download is one of the CRITICAL parts of the
1836 // edonkey network. The selection algorithm must insure the best spreading
1837 // of files.
1838 //
1839 // The selection is based on 4 criteria:
1840 // 1. Frequency of the chunk (availability), very rare chunks must be downloaded
1841 // as quickly as possible to become a new available source.
1842 // 2. Parts used for preview (first + last chunk), preview or check a
1843 // file (e.g. movie, mp3)
1844 // 3. Request state (downloading in process), try to ask each source for another
1845 // chunk. Spread the requests between all sources.
1846 // 4. Completion (shortest-to-complete), partially retrieved chunks should be
1847 // completed before starting to download other one.
1848 //
1849 // The frequency criterion defines three zones: very rare (<10%), rare (<50%)
1850 // and common (>30%). Inside each zone, the criteria have a specific weight, used
1851 // to calculate the priority of chunks. The chunk(s) with the highest
1852 // priority (highest=0, lowest=0xffff) is/are selected first.
1853 //
1854 // very rare (preview) rare common
1855 // 0% <---- +0 pt ----> 10% <----- +10000 pt -----> 50% <---- +20000 pt ----> 100%
1856 // 1. <------- frequency: +25*frequency pt ----------->
1857 // 2. <- preview: +1 pt --><-------------- preview: set to 10000 pt ------------->
1858 // 3. <------ request: download in progress +20000 pt ------>
1859 // 4a. <- completion: 0% +100, 25% +75 .. 100% +0 pt --><-- !req => completion --->
1860 // 4b. <--- req => !completion -->
1861 //
1862 // Unrolled, the priority scale is:
1863 //
1864 // 0..xxxx unrequested and requested very rare chunks
1865 // 10000..1xxxx unrequested rare chunks + unrequested preview chunks
1866 // 20000..2xxxx unrequested common chunks (priority to the most complete)
1867 // 30000..3xxxx requested rare chunks + requested preview chunks
1868 // 40000..4xxxx requested common chunks (priority to the least complete)
1869 //
1870 // This algorithm usually selects first the rarest chunk(s). However, partially
1871 // complete chunk(s) that is/are close to completion may overtake the priority
1872 // (priority inversion).
1873 // For the common chuncks, the algorithm tries to spread the dowload between
1874 // the sources
1875 //
1876
1877 // Check input parameters
1878 if ( sender->GetPartStatus().empty() ) {
1879 return false;
1880 }
1881 // Define and create the list of the chunks to download
1882 const uint16 partCount = GetPartCount();
1883 ChunkList chunksList;
1884
1885 // Main loop
1886 uint16 newBlockCount = 0;
1887 while(newBlockCount != count) {
1888 // Create a request block stucture if a chunk has been previously selected
1889 if(sender->GetLastPartAsked() != 0xffff) {
1890 Requested_Block_Struct* pBlock = new Requested_Block_Struct;
1891 if(GetNextEmptyBlockInPart(sender->GetLastPartAsked(), pBlock) == true) {
1892 // Keep a track of all pending requested blocks
1893 m_requestedblocks_list.push_back(pBlock);
1894 // Update list of blocks to return
1895 toadd.push_back(pBlock);
1896 newBlockCount++;
1897 // Skip end of loop (=> CPU load)
1898 continue;
1899 } else {
1900 // All blocks for this chunk have been already requested
1901 delete pBlock;
1902 // => Try to select another chunk
1903 sender->SetLastPartAsked(0xffff);
1904 }
1905 }
1906
1907 // Check if a new chunk must be selected (e.g. download starting, previous chunk complete)
1908 if(sender->GetLastPartAsked() == 0xffff) {
1909 // Quantify all chunks (create list of chunks to download)
1910 // This is done only one time and only if it is necessary (=> CPU load)
1911 if(chunksList.empty()) {
1912 // Indentify the locally missing part(s) that this source has
1913 for(uint16 i=0; i < partCount; ++i) {
1914 if(sender->IsPartAvailable(i) == true && GetNextEmptyBlockInPart(i, NULL) == true) {
1915 // Create a new entry for this chunk and add it to the list
1916 Chunk newEntry;
1917 newEntry.part = i;
1918 newEntry.frequency = m_SrcpartFrequency[i];
1919 chunksList.push_back(newEntry);
1920 }
1921 }
1922
1923 // Check if any bloks(s) could be downloaded
1924 if(chunksList.empty()) {
1925 break; // Exit main loop while()
1926 }
1927
1928 // Define the bounds of the three zones (very rare, rare)
1929 // more depending on available sources
1930 uint8 modif=10;
1931 if (GetSourceCount()>800) {
1932 modif=2;
1933 } else if (GetSourceCount()>200) {
1934 modif=5;
1935 }
1936 uint16 limit= modif*GetSourceCount()/ 100;
1937 if (limit==0) {
1938 limit=1;
1939 }
1940 const uint16 veryRareBound = limit;
1941 const uint16 rareBound = 2*limit;
1942
1943 // Cache Preview state (Criterion 2)
1944 FileType type = GetFiletype(GetFileName());
1945 const bool isPreviewEnable =
1946 thePrefs::GetPreviewPrio() &&
1947 (type == ftArchive || type == ftVideo);
1948
1949 // Collect and calculate criteria for all chunks
1950 for (ChunkList::iterator it = chunksList.begin(); it != chunksList.end(); ++it) {
1951 Chunk& cur_chunk = *it;
1952
1953 // Offsets of chunk
1954 const uint64 uStart = cur_chunk.part * PARTSIZE;
1955 const uint64 uEnd = uStart + GetPartSize(cur_chunk.part) - 1;
1956 // Criterion 2. Parts used for preview
1957 // Remark: - We need to download the first part and the last part(s).
1958 // - When the last part is very small, it's necessary to
1959 // download the two last parts.
1960 bool critPreview = false;
1961 if(isPreviewEnable == true) {
1962 if(cur_chunk.part == 0) {
1963 critPreview = true; // First chunk
1964 } else if(cur_chunk.part == partCount-1) {
1965 critPreview = true; // Last chunk
1966 } else if(cur_chunk.part == partCount-2) {
1967 // Last chunk - 1 (only if last chunk is too small)
1968 const uint32 sizeOfLastChunk = GetFileSize() - uEnd;
1969 if(sizeOfLastChunk < PARTSIZE/3) {
1970 critPreview = true; // Last chunk - 1
1971 }
1972 }
1973 }
1974
1975 // Criterion 3. Request state (downloading in process from other source(s))
1976 // => CPU load
1977 const bool critRequested =
1978 cur_chunk.frequency > veryRareBound &&
1979 IsAlreadyRequested(uStart, uEnd);
1980
1981 // Criterion 4. Completion
1982 // PARTSIZE instead of GetPartSize() favours the last chunk - but that may be intentional
1983 uint32 partSize = PARTSIZE - m_gaplist.GetGapSize(cur_chunk.part);
1984 const uint16 critCompletion = (uint16)(partSize/(PARTSIZE/100)); // in [%]
1985
1986 // Calculate priority with all criteria
1987 if(cur_chunk.frequency <= veryRareBound) {
1988 // 0..xxxx unrequested + requested very rare chunks
1989 cur_chunk.rank = (25 * cur_chunk.frequency) + // Criterion 1
1990 ((critPreview == true) ? 0 : 1) + // Criterion 2
1991 (100 - critCompletion); // Criterion 4
1992 } else if(critPreview == true) {
1993 // 10000..10100 unrequested preview chunks
1994 // 30000..30100 requested preview chunks
1995 cur_chunk.rank = ((critRequested == false) ? 10000 : 30000) + // Criterion 3
1996 (100 - critCompletion); // Criterion 4
1997 } else if(cur_chunk.frequency <= rareBound) {
1998 // 10101..1xxxx unrequested rare chunks
1999 // 30101..3xxxx requested rare chunks
2000 cur_chunk.rank = (25 * cur_chunk.frequency) + // Criterion 1
2001 ((critRequested == false) ? 10101 : 30101) + // Criterion 3
2002 (100 - critCompletion); // Criterion 4
2003 } else {
2004 // common chunk
2005 if(critRequested == false) { // Criterion 3
2006 // 20000..2xxxx unrequested common chunks
2007 cur_chunk.rank = 20000 + // Criterion 3
2008 (100 - critCompletion); // Criterion 4
2009 } else {
2010 // 40000..4xxxx requested common chunks
2011 // Remark: The weight of the completion criterion is inversed
2012 // to spead the requests over the completing chunks.
2013 // Without this, the chunk closest to completion will
2014 // received every new sources.
2015 cur_chunk.rank = 40000 + // Criterion 3
2016 (critCompletion); // Criterion 4
2017 }
2018 }
2019 }
2020 }
2021
2022 // Select the next chunk to download
2023 if(!chunksList.empty()) {
2024 // Find and count the chunck(s) with the highest priority
2025 uint16 chunkCount = 0; // Number of found chunks with same priority
2026 uint16 rank = 0xffff; // Highest priority found
2027
2028 // Collect and calculate criteria for all chunks
2029 for (ChunkList::iterator it = chunksList.begin(); it != chunksList.end(); ++it) {
2030 const Chunk& cur_chunk = *it;
2031 if(cur_chunk.rank < rank) {
2032 chunkCount = 1;
2033 rank = cur_chunk.rank;
2034 } else if(cur_chunk.rank == rank) {
2035 ++chunkCount;
2036 }
2037 }
2038
2039 // Use a random access to avoid that everybody tries to download the
2040 // same chunks at the same time (=> spread the selected chunk among clients)
2041 uint16 randomness = 1 + (int) (((float)(chunkCount-1))*rand()/(RAND_MAX+1.0));
2042
2043 for (ChunkList::iterator it = chunksList.begin(); it != chunksList.end(); ++it) {
2044 const Chunk& cur_chunk = *it;
2045 if(cur_chunk.rank == rank) {
2046 randomness--;
2047 if(randomness == 0) {
2048 // Selection process is over
2049 sender->SetLastPartAsked(cur_chunk.part);
2050 // Remark: this list might be reused up to *count times
2051 chunksList.erase(it);
2052 break; // exit loop for()
2053 }
2054 }
2055 }
2056 } else {
2057 // There is no remaining chunk to download
2058 break; // Exit main loop while()
2059 }
2060 }
2061 }
2062 // Return the number of the blocks
2063 count = newBlockCount;
2064 // Return
2065 return (newBlockCount > 0);
2066 }
2067 // Maella end
2068
2069
2070 void CPartFile::RemoveBlockFromList(uint64 start,uint64 end)
2071 {
2072 std::list<Requested_Block_Struct*>::iterator it = m_requestedblocks_list.begin();
2073 while (it != m_requestedblocks_list.end()) {
2074 std::list<Requested_Block_Struct*>::iterator it2 = it++;
2075
2076 if ((*it2)->StartOffset <= start && (*it2)->EndOffset >= end) {
2077 m_requestedblocks_list.erase(it2);
2078 }
2079 }
2080 }
2081
2082
2083 void CPartFile::RemoveAllRequestedBlocks(void)
2084 {
2085 m_requestedblocks_list.clear();
2086 }
2087
2088
2089 void CPartFile::CompleteFile(bool bIsHashingDone)
2090 {
2091 if (GetKadFileSearchID()) {
2092 Kademlia::CSearchManager::StopSearch(GetKadFileSearchID(), false);
2093 }
2094
2095 theApp->downloadqueue->RemoveLocalServerRequest(this);
2096
2097 AddDebugLogLineN( logPartFile, wxString( wxT("CPartFile::CompleteFile: Hash ") ) + ( bIsHashingDone ? wxT("done") : wxT("not done") ) );
2098
2099 if (!bIsHashingDone) {
2100 SetStatus(PS_COMPLETING);
2101 kBpsDown = 0.0;
2102
2103 CPath partFile = m_partmetfilename.RemoveExt();
2104 CThreadScheduler::AddTask(new CHashingTask(GetFilePath(), partFile, this));
2105 return;
2106 } else {
2107 StopFile();
2108 m_is_A4AF_auto=false;
2109 SetStatus(PS_COMPLETING);
2110 // guess I was wrong about not need to spaw a thread ...
2111 // It is if the temp and incoming dirs are on different
2112 // partitions/drives and the file is large...[oz]
2113 //
2114
2115 PerformFileComplete();
2116
2117
2118 }
2119 if (thePrefs::ShowCatTabInfos()) {
2120 Notify_ShowUpdateCatTabTitles();
2121 }
2122 UpdateDisplayedInfo(true);
2123 }
2124
2125
2126 void CPartFile::CompleteFileEnded(bool errorOccured, const CPath& newname)
2127 {
2128 if (errorOccured) {
2129 m_paused = true;
2130 SetStatus(PS_ERROR);
2131 AddLogLineC(CFormat( _("Unexpected error while completing %s. File paused") )% GetFileName() );
2132 } else {
2133 m_fullname = newname;
2134
2135 SetFilePath(m_fullname.GetPath());
2136 SetFileName(m_fullname.GetFullName());
2137 m_lastDateChanged = CPath::GetModificationTime(m_fullname);
2138
2139 SetStatus(PS_COMPLETE);
2140 m_paused = false;
2141 ClearPriority();
2142
2143
2144 // Remove from list of canceled files in case it was canceled once upon a time
2145 if (theApp->canceledfiles->Remove(GetFileHash())) {
2146 theApp->canceledfiles->Save();
2147 }
2148
2149 // Mark as known (checks if it's already known),
2150 // also updates search files
2151 theApp->knownfiles->SafeAddKFile(this);
2152
2153 // remove the file from the suspended uploads list
2154 theApp->uploadqueue->ResumeUpload(GetFileHash());
2155 theApp->downloadqueue->RemoveFile(this, true);
2156 theApp->sharedfiles->SafeAddKFile(this);
2157 UpdateDisplayedInfo(true);
2158
2159 // republish that file to the ed2k-server to update the 'FT_COMPLETE_SOURCES' counter on the server.
2160 theApp->sharedfiles->RepublishFile(this);
2161
2162 // Ensure that completed shows the correct value
2163 completedsize = GetFileSize();
2164
2165 // clear the blackbox to free up memory
2166 m_CorruptionBlackBox->Free();
2167
2168 AddLogLineC(CFormat( _("Finished downloading: %s") ) % GetFileName() );
2169 #ifndef AMULE_DAEMON
2170 if (thePrefs::ShowNotifications()) {
2171 wxNotificationMessage *notification = new wxNotificationMessage ();
2172 notification->SetTitle("aMule");
2173 notification->SetMessage(CFormat( _("Finished downloading:\n%s") ) % GetFileName() );
2174 notification->SetFlags(wxICON_INFORMATION);
2175 notification->Show(7);
2176 delete notification;
2177 }
2178 #endif
2179 }
2180
2181 theApp->downloadqueue->StartNextFile(this);
2182 }
2183
2184
2185 void CPartFile::PerformFileComplete()
2186 {
2187 // add this file to the suspended uploads list
2188 theApp->uploadqueue->SuspendUpload(GetFileHash(), false);
2189 FlushBuffer();
2190
2191 // close permanent handle
2192 if (m_hpartfile.IsOpened()) {
2193 m_hpartfile.Close();
2194 }
2195
2196 // Schedule task for completion of the file
2197 CThreadScheduler::AddTask(new CCompletionTask(this));
2198 }
2199
2200
2201 void CPartFile::RemoveAllSources(bool bTryToSwap)
2202 {
2203 for( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end();) {
2204 CUpDownClient* cur_src = it++->GetClient();
2205 if (bTryToSwap) {
2206 if (!cur_src->SwapToAnotherFile(true, true, true, NULL)) {
2207 RemoveSource(cur_src,true,false);
2208 // If it was not swapped, it's not on any file anymore, and should die
2209 }
2210 } else {
2211 RemoveSource(cur_src,true,false);
2212 }
2213 }
2214
2215 UpdatePartsInfo();
2216
2217 /* eMule 0.30c implementation, i give it a try (Creteil) BEGIN ... */
2218 // remove all links A4AF in sources to this file
2219 if(!m_A4AFsrclist.empty()) {
2220 for( SourceSet::iterator it = m_A4AFsrclist.begin(); it != m_A4AFsrclist.end(); ) {
2221 CUpDownClient* cur_src = it++->GetClient();
2222 if ( cur_src->DeleteFileRequest( this ) ) {
2223 Notify_SourceCtrlRemoveSource(cur_src->ECID(), this);
2224 }
2225 }
2226 m_A4AFsrclist.clear();
2227 }
2228 /* eMule 0.30c implementation, i give it a try (Creteil) END ... */
2229 UpdateFileRatingCommentAvail();
2230 }
2231
2232
2233 void CPartFile::Delete()
2234 {
2235 AddLogLineN(CFormat(_("Deleting file: %s")) % GetFileName());
2236 // Barry - Need to tell any connected clients to stop sending the file
2237 StopFile(true);
2238 AddDebugLogLineN(logPartFile, wxT("\tStopped"));
2239
2240 #ifdef __DEBUG__
2241 uint16 removed =
2242 #endif
2243 theApp->uploadqueue->SuspendUpload(GetFileHash(), true);
2244 AddDebugLogLineN(logPartFile, CFormat(wxT("\tSuspended upload to %d clients")) % removed);
2245 theApp->sharedfiles->RemoveFile(this);
2246 AddDebugLogLineN(logPartFile, wxT("\tRemoved from shared"));
2247 theApp->downloadqueue->RemoveFile(this);
2248 AddDebugLogLineN(logPartFile, wxT("\tRemoved from download queue"));
2249 Notify_DownloadCtrlRemoveFile(this);
2250 AddDebugLogLineN(logPartFile, wxT("\tRemoved from transferwnd"));
2251 if (theApp->canceledfiles->Add(GetFileHash())) {
2252 theApp->canceledfiles->Save();
2253 }
2254 AddDebugLogLineN(logPartFile, wxT("\tAdded to canceled file list"));
2255 theApp->searchlist->UpdateSearchFileByHash(GetFileHash()); // Update file in the search dialog if it's still open
2256
2257 if (m_hpartfile.IsOpened()) {
2258 m_hpartfile.Close();
2259 }
2260
2261 AddDebugLogLineN(logPartFile, wxT("\tClosed"));
2262
2263 // cppcheck-suppress duplicateBranch
2264 if (!CPath::RemoveFile(m_fullname)) {
2265 AddDebugLogLineC(logPartFile, CFormat(wxT("\tFailed to delete '%s'")) % m_fullname);
2266 } else {
2267 AddDebugLogLineN(logPartFile, wxT("\tRemoved .part.met"));
2268 }
2269
2270 // cppcheck-suppress duplicateBranch
2271 if (!CPath::RemoveFile(m_PartPath)) {
2272 AddDebugLogLineC(logPartFile, CFormat(wxT("Failed to delete '%s'")) % m_PartPath);
2273 } else {
2274 AddDebugLogLineN(logPartFile, wxT("\tRemoved .part"));
2275 }
2276
2277 CPath BAKName = m_fullname.AppendExt(PARTMET_BAK_EXT);
2278 // cppcheck-suppress duplicateBranch
2279 if (!CPath::RemoveFile(BAKName)) {
2280 AddDebugLogLineC(logPartFile, CFormat(wxT("Failed to delete '%s'")) % BAKName);
2281 } else {
2282 AddDebugLogLineN(logPartFile, wxT("\tRemoved .bak"));
2283 }
2284
2285 CPath SEEDSName = m_fullname.AppendExt(wxT(".seeds"));
2286 if (SEEDSName.FileExists()) {
2287 // cppcheck-suppress duplicateBranch
2288 if (CPath::RemoveFile(SEEDSName)) {
2289 AddDebugLogLineN(logPartFile, wxT("\tRemoved .seeds"));
2290 } else {
2291 AddDebugLogLineC(logPartFile, CFormat(wxT("Failed to delete '%s'")) % SEEDSName);
2292 }
2293 }
2294
2295 AddDebugLogLineN(logPartFile, wxT("Done"));
2296
2297 delete this;
2298 }
2299
2300
2301 bool CPartFile::HashSinglePart(uint16 partnumber)
2302 {
2303 if ((GetHashCount() <= partnumber) && (GetPartCount() > 1)) {
2304 AddLogLineC(CFormat( _("WARNING: Unable to hash downloaded part - hashset incomplete for '%s'") )
2305 % GetFileName() );
2306 m_hashsetneeded = true;
2307 return true;
2308 } else if ((GetHashCount() <= partnumber) && GetPartCount() != 1) {
2309 AddLogLineC(CFormat( _("ERROR: Unable to hash downloaded part - hashset incomplete (%s). This should never happen")) % GetFileName() );
2310 m_hashsetneeded = true;
2311 return true;
2312 } else {
2313 CMD4Hash hashresult;
2314 uint64 offset = PARTSIZE * partnumber;
2315 uint32 length = GetPartSize(partnumber);
2316 try {
2317 CreateHashFromFile(m_hpartfile, offset, length, &hashresult, NULL);
2318 } catch (const CIOFailureException& e) {
2319 AddLogLineC(CFormat( _("EOF while hashing downloaded part %u with length %u (max %u) of partfile '%s' with length %u: %s"))
2320 % partnumber % length % (offset+length) % GetFileName() % GetFileSize() % e.what());
2321 SetStatus(PS_ERROR);
2322 return false;
2323 } catch (const CEOFException& e) {
2324 AddLogLineC(CFormat( _("EOF while hashing downloaded part %u with length %u (max %u) of partfile '%s' with length %u: %s"))
2325 % partnumber % length % (offset+length) % GetFileName() % GetFileSize() % e.what());
2326 SetStatus(PS_ERROR);
2327 return false;
2328 }
2329
2330 if (GetPartCount() > 1) {
2331 if (hashresult != GetPartHash(partnumber)) {
2332 AddDebugLogLineN(logPartFile, CFormat( wxT("%s: Expected hash of part %d: %s")) % GetFileName() % partnumber % GetPartHash(partnumber).Encode() );
2333 AddDebugLogLineN(logPartFile, CFormat( wxT("%s: Actual hash of part %d: %s")) % GetFileName() % partnumber % hashresult.Encode() );
2334 return false;
2335 } else {
2336 return true;
2337 }
2338 } else {
2339 if (hashresult != m_abyFileHash) {
2340 return false;
2341 } else {
2342 return true;
2343 }
2344 }
2345 }
2346
2347 }
2348
2349 bool CPartFile::IsCorruptedPart(uint16 partnumber)
2350 {
2351 return std::find(m_corrupted_list.begin(), m_corrupted_list.end(), partnumber)
2352 != m_corrupted_list.end();
2353 }
2354
2355
2356 void CPartFile::SetDownPriority(uint8 np, bool bSave, bool bRefresh )
2357 {
2358 if ( m_iDownPriority != np ) {
2359 m_iDownPriority = np;
2360 if ( bRefresh )
2361 UpdateDisplayedInfo(true);
2362 if ( bSave )
2363 SavePartFile();
2364 }
2365 }
2366
2367
2368 void CPartFile::StopFile(bool bCancel)
2369 {
2370 // Kry - Need to set it here to get into SetStatus(status) correctly
2371 m_stopped = true;
2372
2373 // Barry - Need to tell any connected clients to stop sending the file
2374 PauseFile();
2375
2376 m_LastSearchTimeKad = 0;
2377 m_TotalSearchesKad = 0;
2378
2379 RemoveAllSources(true);
2380 kBpsDown = 0.0;
2381 transferingsrc = 0;
2382
2383 if (!bCancel) {
2384 FlushBuffer();
2385 }
2386
2387 UpdateDisplayedInfo(true);
2388 }
2389
2390
2391 void CPartFile::StopPausedFile()
2392 {
2393 if (!IsStopped()) {
2394 // Once an hour, remove any sources for files which are no longer active downloads
2395 switch (GetStatus()) {
2396 case PS_PAUSED:
2397 case PS_INSUFFICIENT:
2398 case PS_ERROR:
2399 if (time(NULL) - m_iLastPausePurge > (60*60)) {
2400 m_iLastPausePurge = time(NULL);
2401 StopFile();
2402 }
2403 kBpsDown = 0.0;
2404 }
2405 }
2406 // release file handle if unused for some time
2407 m_hpartfile.Release();
2408 }
2409
2410
2411 void CPartFile::PauseFile(bool bInsufficient)
2412 {
2413 SetActive(false);
2414
2415 if ( status == PS_COMPLETE || status == PS_COMPLETING ) {
2416 return;
2417 }
2418
2419 if (GetKadFileSearchID()) {
2420 Kademlia::CSearchManager::StopSearch(GetKadFileSearchID(), true);
2421 // If we were in the middle of searching, reset timer so they can resume searching.
2422 m_LastSearchTimeKad = 0;
2423 }
2424
2425 m_iLastPausePurge = time(NULL);
2426
2427 theApp->downloadqueue->RemoveLocalServerRequest(this);
2428
2429 CPacket packet( OP_CANCELTRANSFER, 0, OP_EDONKEYPROT );
2430 for( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ) {
2431 CUpDownClient* cur_src = it++->GetClient();
2432 if (cur_src->GetDownloadState() == DS_DOWNLOADING) {
2433 if (!cur_src->GetSentCancelTransfer()) {
2434 theStats::AddUpOverheadOther( packet.GetPacketSize() );
2435 AddDebugLogLineN( logLocalClient, wxT("Local Client: OP_CANCELTRANSFER to ") + cur_src->GetFullIP() );
2436 cur_src->SendPacket( &packet, false, true );
2437 cur_src->SetSentCancelTransfer( true );
2438 }
2439 cur_src->SetDownloadState(DS_ONQUEUE);
2440 // Allow immediate reconnect on resume
2441 cur_src->ResetLastAskedTime();
2442 }
2443 }
2444
2445
2446 m_insufficient = bInsufficient;
2447 m_paused = true;
2448
2449
2450 kBpsDown = 0.0;
2451 transferingsrc = 0;
2452
2453 SetStatus(status);
2454 }
2455
2456
2457 void CPartFile::ResumeFile()
2458 {
2459 if ( status == PS_COMPLETE || status == PS_COMPLETING ) {
2460 return;
2461 }
2462
2463 if ( m_insufficient && !CheckFreeDiskSpace() ) {
2464 // Still not enough free discspace
2465 return;
2466 }
2467
2468 m_paused = false;
2469 m_stopped = false;
2470 m_insufficient = false;
2471
2472 m_lastsearchtime = 0;
2473 SetStatus(status);
2474 SetActive(theApp->IsConnected());
2475
2476 if (m_gaplist.IsComplete() && (GetStatus() == PS_ERROR)) {
2477 // The file has already been hashed at this point
2478 CompleteFile(true);
2479 }
2480
2481 UpdateDisplayedInfo(true);
2482 }
2483
2484
2485 bool CPartFile::CheckFreeDiskSpace( uint64 neededSpace )
2486 {
2487 uint64 free = CPath::GetFreeSpaceAt(GetFilePath());
2488 if (free == static_cast<uint64>(wxInvalidOffset)) {
2489 // If GetFreeSpaceAt() fails, then the path probably does not exist.
2490 return false;
2491 }
2492
2493 // The very least acceptable diskspace is a single PART
2494 if ( free < PARTSIZE ) {
2495 // Always fail in this case, since we risk losing data if we try to
2496 // write on a full partition.
2497 return false;
2498 }
2499
2500 // All other checks are only made if the user has enabled them
2501 if ( thePrefs::IsCheckDiskspaceEnabled() ) {
2502 neededSpace += thePrefs::GetMinFreeDiskSpace();
2503
2504 // Due to the the existance of sparse files, we cannot assume that
2505 // writes within the file doesn't cause new blocks to be allocated.
2506 // Therefore, we have to simply stop writing the moment the limit has
2507 // been exceeded.
2508 return free >= neededSpace;
2509 }
2510
2511 return true;
2512 }
2513
2514
2515 void CPartFile::SetLastAnsweredTime()
2516 {
2517 m_ClientSrcAnswered = ::GetTickCount();
2518 }
2519
2520 void CPartFile::SetLastAnsweredTimeTimeout()
2521 {
2522 m_ClientSrcAnswered = 2 * CONNECTION_LATENCY + ::GetTickCount() - SOURCECLIENTREASKS;
2523 }
2524
2525 CPacket *CPartFile::CreateSrcInfoPacket(const CUpDownClient* forClient, uint8 byRequestedVersion, uint16 nRequestedOptions)
2526 {
2527
2528 if ( m_SrcList.empty() ) {
2529 return NULL;
2530 }
2531
2532 if(!IsPartFile()) {
2533 return CKnownFile::CreateSrcInfoPacket(forClient, byRequestedVersion, nRequestedOptions);
2534 }
2535
2536 if (((forClient->GetRequestFile() != this)
2537 && (forClient->GetUploadFile() != this)) || forClient->GetUploadFileID() != GetFileHash()) {
2538 wxString file1 = _("Unknown");
2539 if (forClient->GetRequestFile() && forClient->GetRequestFile()->GetFileName().IsOk()) {
2540 file1 = forClient->GetRequestFile()->GetFileName().GetPrintable();
2541 } else if (forClient->GetUploadFile() && forClient->GetUploadFile()->GetFileName().IsOk()) {
2542 file1 = forClient->GetUploadFile()->GetFileName().GetPrintable();
2543 }
2544 wxString file2 = _("Unknown");
2545 if (GetFileName().IsOk()) {
2546 file2 = GetFileName().GetPrintable();
2547 }
2548 AddDebugLogLineN(logPartFile, wxT("File mismatch on source packet (P) Sending: ") + file1 + wxT(" From: ") + file2);
2549 return NULL;
2550 }
2551
2552 if ( !(GetStatus() == PS_READY || GetStatus() == PS_EMPTY)) {
2553 return NULL;
2554 }
2555
2556 const BitVector& reqstatus = forClient->GetPartStatus();
2557 bool KnowNeededParts = !reqstatus.empty();
2558 //wxASSERT(rcvstatus.size() == GetPartCount()); // Obviously!
2559 if (KnowNeededParts && (reqstatus.size() != GetPartCount())) {
2560 // Yuck. Same file but different part count? Seriously fucked up.
2561 // This happens rather often with reqstatus.size() == 0. Don't log then.
2562 if (reqstatus.size()) {
2563 AddDebugLogLineN(logKnownFiles, CFormat(wxT("Impossible situation: different partcounts: %i (client) and %i (file) for %s")) % reqstatus.size() % GetPartCount() % GetFileName());
2564 }
2565 return NULL;
2566 }
2567
2568 CMemFile data(1024);
2569
2570 uint8 byUsedVersion;
2571 bool bIsSX2Packet;
2572 if (forClient->SupportsSourceExchange2() && byRequestedVersion > 0){
2573 // the client uses SourceExchange2 and requested the highest version he knows
2574 // and we send the highest version we know, but of course not higher than his request
2575 byUsedVersion = std::min(byRequestedVersion, (uint8)SOURCEEXCHANGE2_VERSION);
2576 bIsSX2Packet = true;
2577 data.WriteUInt8(byUsedVersion);
2578
2579 // we don't support any special SX2 options yet, reserved for later use
2580 if (nRequestedOptions != 0) {
2581 AddDebugLogLineN(logKnownFiles, CFormat(wxT("Client requested unknown options for SourceExchange2: %u")) % nRequestedOptions);
2582 }
2583 } else {
2584 byUsedVersion = forClient->GetSourceExchange1Version();
2585 bIsSX2Packet = false;
2586 if (forClient->SupportsSourceExchange2()) {
2587 AddDebugLogLineN(logKnownFiles, wxT("Client which announced to support SX2 sent SX1 packet instead"));
2588 }
2589 }
2590
2591 uint16 nCount = 0;
2592
2593 data.WriteHash(m_abyFileHash);
2594 data.WriteUInt16(nCount);
2595 bool bNeeded;
2596 for (SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ++it ) {
2597 bNeeded = false;
2598 CUpDownClient* cur_src = it->GetClient();
2599
2600 int state = cur_src->GetDownloadState();
2601 int valid = ( state == DS_DOWNLOADING ) || ( state == DS_ONQUEUE && !cur_src->IsRemoteQueueFull() );
2602
2603 if ( cur_src->HasLowID() || !valid ) {
2604 continue;
2605 }
2606
2607 // only send source which have needed parts for this client if possible
2608 const BitVector& srcstatus = cur_src->GetPartStatus();
2609 if ( !srcstatus.empty() ) {
2610 //wxASSERT(srcstatus.size() == GetPartCount()); // Obviously!
2611 if (srcstatus.size() != GetPartCount()) {
2612 continue;
2613 }
2614 if ( KnowNeededParts ) {
2615 // only send sources which have needed parts for this client
2616 for (int x = 0; x < GetPartCount(); ++x) {
2617 if (srcstatus.get(x) && !reqstatus.get(x)) {
2618 bNeeded = true;
2619 break;
2620 }
2621 }
2622 } else {
2623 // if we don't know the need parts for this client,
2624 // return any source currently a client sends it's
2625 // file status only after it has at least one complete part
2626 if (srcstatus.size() != GetPartCount()) {
2627 continue;
2628 }
2629 for (int x = 0; x < GetPartCount(); ++x){
2630 if (srcstatus.get(x)) {
2631 bNeeded = true;
2632 break;
2633 }
2634 }
2635 }
2636 }
2637 if(bNeeded) {
2638 ++nCount;
2639 uint32 dwID;
2640 if(forClient->GetSourceExchange1Version() > 2) {
2641 dwID = cur_src->GetUserIDHybrid();
2642 } else {
2643 dwID = wxUINT32_SWAP_ALWAYS(cur_src->GetUserIDHybrid());
2644 }
2645 data.WriteUInt32(dwID);
2646 data.WriteUInt16(cur_src->GetUserPort());
2647 data.WriteUInt32(cur_src->GetServerIP());
2648 data.WriteUInt16(cur_src->GetServerPort());
2649
2650 if (byUsedVersion >= 2) {
2651 data.WriteHash(cur_src->GetUserHash());
2652 }
2653
2654 if (byUsedVersion >= 4){
2655 // CryptSettings - SourceExchange V4
2656 // 5 Reserved (!)
2657 // 1 CryptLayer Required
2658 // 1 CryptLayer Requested
2659 // 1 CryptLayer Supported
2660 const uint8 uSupportsCryptLayer = cur_src->SupportsCryptLayer() ? 1 : 0;
2661 const uint8 uRequestsCryptLayer = cur_src->RequestsCryptLayer() ? 1 : 0;
2662 const uint8 uRequiresCryptLayer = cur_src->RequiresCryptLayer() ? 1 : 0;
2663 const uint8 byCryptOptions = (uRequiresCryptLayer << 2) | (uRequestsCryptLayer << 1) | (uSupportsCryptLayer << 0);
2664 data.WriteUInt8(byCryptOptions);
2665 }
2666
2667 if (nCount > 500) {
2668 break;
2669 }
2670 }
2671 }
2672 if (!nCount) {
2673 return 0;
2674 }
2675 data.Seek(bIsSX2Packet ? 17 : 16, wxFromStart);
2676 data.WriteUInt16(nCount);
2677
2678 CPacket* result = new CPacket(data, OP_EMULEPROT, bIsSX2Packet ? OP_ANSWERSOURCES2 : OP_ANSWERSOURCES);
2679
2680 // 16+2+501*(4+2+4+2+16) = 14046 bytes max.
2681 if (result->GetPacketSize() > 354) {
2682 result->PackPacket();
2683 }
2684
2685 return result;
2686 }
2687
2688 void CPartFile::AddClientSources(CMemFile* sources, unsigned nSourceFrom, uint8 uClientSXVersion, bool bSourceExchange2, const CUpDownClient* /*pClient*/)
2689 {
2690 // Kad reviewed
2691
2692 if (m_stopped) {
2693 return;
2694 }
2695
2696 uint32 nCount = 0;
2697 uint8 uPacketSXVersion = 0;
2698 if (!bSourceExchange2) {
2699 nCount = sources->ReadUInt16();
2700
2701 // Check if the data size matches the 'nCount' for v1 or v2 and eventually correct the source
2702 // exchange version while reading the packet data. Otherwise we could experience a higher
2703 // chance in dealing with wrong source data, userhashs and finally duplicate sources.
2704 uint32 uDataSize = sources->GetLength() - sources->GetPosition();
2705
2706 if ((uint32)(nCount*(4+2+4+2)) == uDataSize) { //Checks if version 1 packet is correct size
2707 if(uClientSXVersion != 1) {
2708 return;
2709 }
2710 uPacketSXVersion = 1;
2711 } else if ((uint32)(nCount*(4+2+4+2+16)) == uDataSize) { // Checks if version 2&3 packet is correct size
2712 if (uClientSXVersion == 2) {
2713 uPacketSXVersion = 2;
2714 } else if (uClientSXVersion > 2) {
2715 uPacketSXVersion = 3;
2716 } else {
2717 return;
2718 }
2719 } else if (nCount*(4+2+4+2+16+1) == uDataSize) {
2720 if (uClientSXVersion != 4 ) {
2721 return;
2722 }
2723 uPacketSXVersion = 4;
2724 } else {
2725 // If v5 inserts additional data (like v2), the above code will correctly filter those packets.
2726 // If v5 appends additional data after <count>(<Sources>)[count], we are in trouble with the
2727 // above code. Though a client which does not understand v5+ should never receive such a packet.
2728 AddDebugLogLineN(logClient, CFormat(wxT("Received invalid source exchange packet (v%u) of data size %u for %s")) % uClientSXVersion % uDataSize % GetFileName());
2729 return;
2730 }
2731 } else {
2732 // for SX2:
2733 // We only check if the version is known by us and do a quick sanitize check on known version
2734 // other then SX1, the packet will be ignored if any error appears, sicne it can't be a "misunderstanding" anymore
2735 if (uClientSXVersion > SOURCEEXCHANGE2_VERSION || uClientSXVersion == 0 ){
2736 AddDebugLogLineN(logPartFile, CFormat(wxT("Invalid source exchange type version: %i")) % uClientSXVersion);
2737 return;
2738 }
2739
2740 // all known versions use the first 2 bytes as count and unknown version are already filtered above
2741 nCount = sources->ReadUInt16();
2742 uint32 uDataSize = (uint32)(sources->GetLength() - sources->GetPosition());
2743 bool bError = false;
2744 switch (uClientSXVersion){
2745 case 1:
2746 bError = nCount*(4+2+4+2) != uDataSize;
2747 break;
2748 case 2:
2749 case 3:
2750 bError = nCount*(4+2+4+2+16) != uDataSize;
2751 break;
2752 case 4:
2753 bError = nCount*(4+2+4+2+16+1) != uDataSize;
2754 break;
2755 default:
2756 wxFAIL;
2757 }
2758
2759 if (bError){
2760 wxFAIL;
2761 AddDebugLogLineN(logPartFile, wxT("Invalid source exchange data size."));
2762 return;
2763 }
2764 uPacketSXVersion = uClientSXVersion;
2765 }
2766
2767 for (uint16 i = 0;i != nCount;++i) {
2768
2769 uint32 dwID = sources->ReadUInt32();
2770 uint16 nPort = sources->ReadUInt16();
2771 uint32 dwServerIP = sources->ReadUInt32();
2772 uint16 nServerPort = sources->ReadUInt16();
2773
2774 CMD4Hash userHash;
2775 if (uPacketSXVersion > 1) {
2776 userHash = sources->ReadHash();
2777 }
2778
2779 uint8 byCryptOptions = 0;
2780 if (uPacketSXVersion >= 4) {
2781 byCryptOptions = sources->ReadUInt8();
2782 }
2783
2784 //Clients send ID's the the Hyrbid format so highID clients with *.*.*.0 won't be falsely switched to a lowID..
2785 uint32 dwIDED2K;
2786 if (uPacketSXVersion >= 3) {
2787 dwIDED2K = wxUINT32_SWAP_ALWAYS(dwID);
2788 } else {
2789 dwIDED2K = dwID;
2790 }
2791
2792 // check the HighID(IP) - "Filter LAN IPs" and "IPfilter" the received sources IP addresses
2793 if (!IsLowID(dwID)) {
2794 if (!IsGoodIP(dwIDED2K, thePrefs::FilterLanIPs())) {
2795 // check for 0-IP, localhost and optionally for LAN addresses
2796 AddDebugLogLineN(logIPFilter, CFormat(wxT("Ignored source (IP=%s) received via %s - bad IP")) % Uint32toStringIP(dwIDED2K) % OriginToText(nSourceFrom));
2797 continue;
2798 }
2799 if (theApp->ipfilter->IsFiltered(dwIDED2K)) {
2800 AddDebugLogLineN(logIPFilter, CFormat(wxT("Ignored source (IP=%s) received via %s - IPFilter")) % Uint32toStringIP(dwIDED2K) % OriginToText(nSourceFrom));
2801 continue;
2802 }
2803 if (theApp->clientlist->IsBannedClient(dwIDED2K)){
2804 continue;
2805 }
2806 }
2807
2808 // additionally check for LowID and own IP
2809 if (!CanAddSource(dwID, nPort, dwServerIP, nServerPort, NULL, false)) {
2810 AddDebugLogLineN(logIPFilter, CFormat(wxT("Ignored source (IP=%s) received via source exchange")) % Uint32toStringIP(dwIDED2K));
2811 continue;
2812 }
2813
2814 if(thePrefs::GetMaxSourcePerFile() > GetSourceCount()) {
2815 CUpDownClient* newsource = new CUpDownClient(nPort,dwID,dwServerIP,nServerPort,this, (uPacketSXVersion < 3), true);
2816 if (uPacketSXVersion > 1) {
2817 newsource->SetUserHash(userHash);
2818 }
2819
2820 if (uPacketSXVersion >= 4) {
2821 newsource->SetConnectOptions(byCryptOptions, true, false);
2822 }
2823
2824 newsource->SetSourceFrom((ESourceFrom)nSourceFrom);
2825 theApp->downloadqueue->CheckAndAddSource(this,newsource);
2826
2827 } else {
2828 break;
2829 }
2830 }
2831 }
2832
2833 void CPartFile::UpdateAutoDownPriority()
2834 {
2835 if (!IsAutoDownPriority()) {
2836 return;
2837 }
2838 if (GetSourceCount() <= theApp->downloadqueue->GetRareFileThreshold()) {
2839 if ( GetDownPriority() != PR_HIGH )
2840 SetDownPriority(PR_HIGH, false, false);
2841 } else if (GetSourceCount() < theApp->downloadqueue->GetCommonFileThreshold()) {
2842 if ( GetDownPriority() != PR_NORMAL )
2843 SetDownPriority(PR_NORMAL, false, false);
2844 } else {
2845 if ( GetDownPriority() != PR_LOW )
2846 SetDownPriority(PR_LOW, false, false);
2847 }
2848 }
2849
2850 // making this function return a higher when more sources have the extended
2851 // protocol will force you to ask a larger variety of people for sources
2852
2853 int CPartFile::GetCommonFilePenalty()
2854 {
2855 //TODO: implement, but never return less than MINCOMMONPENALTY!
2856 return MINCOMMONPENALTY;
2857 }
2858
2859 /* Barry - Replaces BlockReceived()
2860
2861 Originally this only wrote to disk when a full 180k block
2862 had been received from a client, and only asked for data in
2863 180k blocks.
2864
2865 This meant that on average 90k was lost for every connection
2866 to a client data source. That is a lot of wasted data.
2867
2868 To reduce the lost data, packets are now written to a buffer
2869 and flushed to disk regularly regardless of size downloaded.
2870 This includes compressed packets.
2871
2872 Data is also requested only where gaps are, not in 180k blocks.
2873 The requests will still not exceed 180k, but may be smaller to
2874 fill a gap.
2875 */
2876
2877 // Kry - transize is 32bits, no packet can be more than that (this is
2878 // compressed size). Even 32bits is too much imho.As for the return size,
2879 // look at the lenData below.
2880 uint32 CPartFile::WriteToBuffer(uint32 transize, byte* data, uint64 start, uint64 end, Requested_Block_Struct *block, const CUpDownClient* client)
2881 {
2882 // Increment transferred bytes counter for this file
2883 transferred += transize;
2884
2885 // This is needed a few times
2886 // Kry - should not need a uint64 here - no block is larger than
2887 // 2GB even after uncompressed.
2888 uint32 lenData = (uint32) (end - start + 1);
2889
2890 if(lenData > transize) {
2891 m_iGainDueToCompression += lenData-transize;
2892 }
2893
2894 // Occasionally packets are duplicated, no point writing it twice
2895 if (IsComplete(start, end)) {
2896 AddDebugLogLineN(logPartFile,
2897 CFormat(wxT("File '%s' has already been written from %u to %u"))
2898 % GetFileName() % start % end);
2899 return 0;
2900 }
2901
2902 // security sanitize check to make sure we do not write anything into an already hashed complete chunk
2903 const uint64 nStartChunk = start / PARTSIZE;
2904 const uint64 nEndChunk = end / PARTSIZE;
2905 if (IsComplete(nStartChunk)) {
2906 AddDebugLogLineN(logPartFile, CFormat(wxT("Received data touches already hashed chunk - ignored (start): %u-%u; File=%s")) % start % end % GetFileName());
2907 return 0;
2908 } else if (nStartChunk != nEndChunk) {
2909 if (IsComplete(nEndChunk)) {
2910 AddDebugLogLineN(logPartFile, CFormat(wxT("Received data touches already hashed chunk - ignored (end): %u-%u; File=%s")) % start % end % GetFileName());
2911 return 0;
2912 } else {
2913 AddDebugLogLineN(logPartFile, CFormat(wxT("Received data crosses chunk boundaries: %u-%u; File=%s")) % start % end % GetFileName());
2914 }
2915 }
2916
2917 // log transferinformation in our "blackbox"
2918 m_CorruptionBlackBox->TransferredData(start, end, client->GetIP());
2919
2920 // Create a new buffered queue entry
2921 PartFileBufferedData *item = new PartFileBufferedData(m_hpartfile, data, start, end, block);
2922
2923 // Add to the queue in the correct position (most likely the end)
2924 bool added = false;
2925
2926 std::list<PartFileBufferedData*>::iterator it = m_BufferedData_list.begin();
2927 for (; it != m_BufferedData_list.end(); ++it) {
2928 PartFileBufferedData* queueItem = *it;
2929
2930 if (item->end <= queueItem->end) {
2931 if (it != m_BufferedData_list.begin()) {
2932 added = true;
2933
2934 m_BufferedData_list.insert(--it, item);
2935 }
2936
2937 break;
2938 }
2939 }
2940
2941 if (!added) {
2942 m_BufferedData_list.push_front(item);
2943 }
2944
2945 // Increment buffer size marker
2946 m_nTotalBufferData += lenData;
2947
2948 // Mark this small section of the file as filled
2949 FillGap(item->start, item->end);
2950
2951 // Update the flushed mark on the requested block
2952 // The loop here is unfortunate but necessary to detect deleted blocks.
2953
2954 std::list<Requested_Block_Struct*>::iterator it2 = m_requestedblocks_list.begin();
2955 for (; it2 != m_requestedblocks_list.end(); ++it2) {
2956 if (*it2 == item->block) {
2957 item->block->transferred += lenData;
2958 }
2959 }
2960
2961 if (m_gaplist.IsComplete()) {
2962 FlushBuffer();
2963 }
2964
2965 // Return the length of data written to the buffer
2966 return lenData;
2967 }
2968
2969 void CPartFile::FlushBuffer(bool fromAICHRecoveryDataAvailable)
2970 {
2971 m_nLastBufferFlushTime = GetTickCount();
2972
2973 if (m_BufferedData_list.empty()) {
2974 return;
2975 }
2976
2977
2978 uint32 partCount = GetPartCount();
2979 // Remember which parts need to be checked at the end of the flush
2980 std::vector<bool> changedPart(partCount, false);
2981
2982 // Ensure file is big enough to write data to (the last item will be the furthest from the start)
2983 if (!CheckFreeDiskSpace(m_nTotalBufferData)) {
2984 // Not enough free space to write the last item, bail
2985 AddLogLineC(CFormat( _("WARNING: Not enough free disk-space! Pausing file: %s") ) % GetFileName());
2986
2987 PauseFile( true );
2988 return;
2989 }
2990
2991 // Loop through queue
2992 while ( !m_BufferedData_list.empty() ) {
2993 // Get top item and remove it from the queue
2994 CScopedPtr<PartFileBufferedData> item(m_BufferedData_list.front());
2995 m_BufferedData_list.pop_front();
2996
2997 // This is needed a few times
2998 wxASSERT((item->end - item->start) < 0xFFFFFFFF);
2999 uint32 lenData = (uint32)(item->end - item->start + 1);
3000
3001 // SLUGFILLER: SafeHash - could be more than one part
3002 for (uint32 curpart = (item->start/PARTSIZE); curpart <= (item->end/PARTSIZE); ++curpart) {
3003 wxASSERT(curpart < partCount);
3004 changedPart[curpart] = true;
3005 }
3006 // SLUGFILLER: SafeHash
3007
3008 // Go to the correct position in file and write block of data
3009 try {
3010 item->area.FlushAt(m_hpartfile, item->start, lenData);
3011 // Decrease buffer size
3012 m_nTotalBufferData -= lenData;
3013 } catch (const CIOFailureException& e) {
3014 AddDebugLogLineC(logPartFile, wxT("Error while saving part-file: ") + e.what());
3015 SetStatus(PS_ERROR);
3016 // No need to bang your head against it again and again if it has already failed.
3017 DeleteContents(m_BufferedData_list);
3018 m_nTotalBufferData = 0;
3019 return;
3020 }
3021 }
3022
3023
3024 // Update last-changed date
3025 m_lastDateChanged = wxDateTime::GetTimeNow();
3026
3027 try {
3028 // Partfile should never be too large
3029 if (m_hpartfile.GetLength() > GetFileSize()) {
3030 // it's "last chance" correction. the real bugfix has to be applied 'somewhere' else
3031 m_hpartfile.SetLength(GetFileSize());
3032 }
3033 } catch (const CIOFailureException& e) {
3034 AddDebugLogLineC(logPartFile,
3035 CFormat(wxT("Error while truncating part-file (%s): %s"))
3036 % m_PartPath % e.what());
3037 SetStatus(PS_ERROR);
3038 }
3039
3040
3041
3042 // Check each part of the file
3043 for (uint16 partNumber = 0; partNumber < partCount; ++partNumber) {
3044 if (changedPart[partNumber] == false) {
3045 continue;
3046 }
3047
3048 uint32 partRange = GetPartSize(partNumber) - 1;
3049
3050 // Is this 9MB part complete
3051 if (IsComplete(partNumber)) {
3052 // Is part corrupt
3053 if (!HashSinglePart(partNumber)) {
3054 AddLogLineC(CFormat(
3055 _("Downloaded part %i is corrupt in file: %s") ) % partNumber % GetFileName() );
3056 AddGap(partNumber);
3057 // add part to corrupted list, if not already there
3058 if (!IsCorruptedPart(partNumber)) {
3059 m_corrupted_list.push_back(partNumber);
3060 }
3061 // request AICH recovery data
3062 // Don't if called from the AICHRecovery. It's already there and would lead to an infinite recursion.
3063 if (!fromAICHRecoveryDataAvailable) {
3064 RequestAICHRecovery(partNumber);
3065 }
3066 // Reduce transferred amount by corrupt amount
3067 m_iLostDueToCorruption += (partRange + 1);
3068 } else {
3069 if (!m_hashsetneeded) {
3070 AddDebugLogLineN(logPartFile, CFormat(
3071 wxT("Finished part %u of '%s'")) % partNumber % GetFileName());
3072 }
3073
3074 // tell the blackbox about the verified data
3075 m_CorruptionBlackBox->VerifiedData(true, partNumber, 0, partRange);
3076
3077 // if this part was successfully completed (although ICH is active), remove from corrupted list
3078 EraseFirstValue(m_corrupted_list, partNumber);
3079
3080 if (status == PS_EMPTY) {
3081 if (theApp->IsRunning()) { // may be called during shutdown!
3082 if (GetHashCount() == GetED2KPartHashCount() && !m_hashsetneeded) {
3083 // Successfully completed part, make it available for sharing
3084 SetStatus(PS_READY);
3085 theApp->sharedfiles->SafeAddKFile(this);
3086 }
3087 }
3088 }
3089 }
3090 } else if ( IsCorruptedPart(partNumber) && // corrupted part:
3091 (thePrefs::IsICHEnabled() // old ICH: rehash whenever we have new data hoping it will be good now
3092 || fromAICHRecoveryDataAvailable)) {// new AICH: one rehash right before performing it (maybe it's already good)
3093 // Try to recover with minimal loss
3094 if (HashSinglePart(partNumber)) {
3095 ++m_iTotalPacketsSavedDueToICH;
3096
3097 uint64 uMissingInPart = m_gaplist.GetGapSize(partNumber);
3098 FillGap(partNumber);
3099 RemoveBlockFromList(PARTSIZE*partNumber,(PARTSIZE*partNumber + partRange));
3100
3101 // tell the blackbox about the verified data
3102 m_CorruptionBlackBox->VerifiedData(true, partNumber, 0, partRange);
3103
3104 // remove from corrupted list
3105 EraseFirstValue(m_corrupted_list, partNumber);
3106
3107 AddLogLineC(CFormat( _("ICH: Recovered corrupted part %i for %s -> Saved bytes: %s") )
3108 % partNumber
3109 % GetFileName()
3110 % CastItoXBytes(uMissingInPart));
3111
3112 if (GetHashCount() == GetED2KPartHashCount() && !m_hashsetneeded) {
3113 if (status == PS_EMPTY) {
3114 // Successfully recovered part, make it available for sharing
3115 SetStatus(PS_READY);
3116 if (theApp->IsRunning()) // may be called during shutdown!
3117 theApp->sharedfiles->SafeAddKFile(this);
3118 }
3119 }
3120 }
3121 }
3122 }
3123
3124 // Update met file
3125 SavePartFile();
3126
3127 if (theApp->IsRunning()) { // may be called during shutdown!
3128 // Is this file finished ?
3129 if (m_gaplist.IsComplete()) {
3130 CompleteFile(false);
3131 }
3132 }
3133 }
3134
3135
3136 // read data for upload, return false on error
3137 bool CPartFile::ReadData(CFileArea & area, uint64 offset, uint32 toread)
3138 {
3139 // Sanity check
3140 if (offset + toread > GetFileSize()) {
3141 AddDebugLogLineN(logPartFile, CFormat(wxT("tried to read %d bytes past eof of %s"))
3142 % (offset + toread - GetFileSize()) % GetFileName());
3143 wxFAIL;
3144 return false;
3145 }
3146
3147 area.ReadAt(m_hpartfile, offset, toread);
3148 // if it fails it throws (which the caller should catch)
3149 return true;
3150 }
3151
3152
3153 void CPartFile::UpdateFileRatingCommentAvail()
3154 {
3155 bool prevComment = m_hasComment;
3156 int prevRating = m_iUserRating;
3157
3158 m_hasComment = false;
3159 m_iUserRating = 0;
3160 int ratingCount = 0;
3161
3162 SourceSet::iterator it = m_SrcList.begin();
3163 for (; it != m_SrcList.end(); ++it) {
3164 CUpDownClient* cur_src = it->GetClient();
3165
3166 if (!cur_src->GetFileComment().IsEmpty()) {
3167 if (thePrefs::IsCommentFiltered(cur_src->GetFileComment())) {
3168 continue;
3169 }
3170 m_hasComment = true;
3171 }
3172
3173 uint8 rating = cur_src->GetFileRating();
3174 if (rating) {
3175 wxASSERT(rating <= 5);
3176
3177 ratingCount++;
3178 m_iUserRating += rating;
3179 }
3180 }
3181
3182 if (ratingCount) {
3183 m_iUserRating /= ratingCount;
3184 wxASSERT(m_iUserRating > 0 && m_iUserRating <= 5);
3185 }
3186
3187 if ((prevComment != m_hasComment) || (prevRating != m_iUserRating)) {
3188 UpdateDisplayedInfo();
3189 }
3190 }
3191
3192
3193 void CPartFile::SetCategory(uint8 cat)
3194 {
3195 wxASSERT( cat < theApp->glob_prefs->GetCatCount() );
3196
3197 m_category = cat;
3198 SavePartFile();
3199 }
3200
3201 bool CPartFile::RemoveSource(CUpDownClient* toremove, bool updatewindow, bool bDoStatsUpdate)
3202 {
3203 wxASSERT( toremove );
3204
3205 bool result = theApp->downloadqueue->RemoveSource( toremove, updatewindow, bDoStatsUpdate );
3206
3207 // Check if the client should be deleted, but not if the client is already dying
3208 if ( !toremove->GetSocket() && !toremove->HasBeenDeleted() ) {
3209 if ( toremove->Disconnected(wxT("RemoveSource - purged")) ) {
3210 toremove->Safe_Delete();
3211 }
3212 }
3213
3214 return result;
3215 }
3216
3217 void CPartFile::AddDownloadingSource(CUpDownClient* client)
3218 {
3219 CClientRefList::iterator it =
3220 std::find(m_downloadingSourcesList.begin(), m_downloadingSourcesList.end(), CCLIENTREF(client, wxEmptyString));
3221 if (it == m_downloadingSourcesList.end()) {
3222 m_downloadingSourcesList.push_back(CCLIENTREF(client, wxT("CPartFile::AddDownloadingSource")));
3223 }
3224 }
3225
3226
3227 void CPartFile::RemoveDownloadingSource(CUpDownClient* client)
3228 {
3229 CClientRefList::iterator it =
3230 std::find(m_downloadingSourcesList.begin(), m_downloadingSourcesList.end(), CCLIENTREF(client, wxEmptyString));
3231 if (it != m_downloadingSourcesList.end()) {
3232 m_downloadingSourcesList.erase(it);
3233 }
3234 }
3235
3236
3237 uint64 CPartFile::GetNeededSpace()
3238 {
3239 try {
3240 uint64 length = m_hpartfile.GetLength();
3241
3242 if (length > GetFileSize()) {
3243 return 0; // Shouldn't happen, but just in case
3244 }
3245
3246 return GetFileSize() - length;
3247 } catch (const CIOFailureException& e) {
3248 AddDebugLogLineC(logPartFile,
3249 CFormat(wxT("Error while retrieving file-length (%s): %s"))
3250 % m_PartPath % e.what());
3251 SetStatus(PS_ERROR);
3252 return 0;
3253 }
3254 }
3255
3256 void CPartFile::SetStatus(uint8 in)
3257 {
3258 // PAUSED and INSUFFICIENT have extra flag variables m_paused and m_insufficient
3259 // - they are never to be stored in status
3260 wxASSERT( in != PS_PAUSED && in != PS_INSUFFICIENT );
3261
3262 status = in;
3263
3264 if (theApp->IsRunning()) {
3265 UpdateDisplayedInfo( true );
3266
3267 if ( thePrefs::ShowCatTabInfos() ) {
3268 Notify_ShowUpdateCatTabTitles();
3269 }
3270 Notify_DownloadCtrlSort();
3271 }
3272 }
3273
3274
3275 void CPartFile::RequestAICHRecovery(uint16 nPart)
3276 {
3277
3278 if ( !m_pAICHHashSet->HasValidMasterHash() ||
3279 (m_pAICHHashSet->GetStatus() != AICH_TRUSTED && m_pAICHHashSet->GetStatus() != AICH_VERIFIED)){
3280 AddDebugLogLineN( logAICHRecovery, wxT("Unable to request AICH Recoverydata because we have no trusted Masterhash") );
3281 return;
3282 }
3283 if (GetPartSize(nPart) <= EMBLOCKSIZE)
3284 return;
3285 if (CAICHHashSet::IsClientRequestPending(this, nPart)){
3286 AddDebugLogLineN( logAICHRecovery, wxT("RequestAICHRecovery: Already a request for this part pending"));
3287 return;
3288 }
3289
3290 // first check if we have already the recoverydata, no need to rerequest it then
3291 if (m_pAICHHashSet->IsPartDataAvailable(nPart*PARTSIZE)){
3292 AddDebugLogLineN( logAICHRecovery, wxT("Found PartRecoveryData in memory"));
3293 AICHRecoveryDataAvailable(nPart);
3294 return;
3295 }
3296
3297 wxASSERT( nPart < GetPartCount() );
3298 // find some random client which support AICH to ask for the blocks
3299 // first lets see how many we have at all, we prefer high id very much
3300 uint32 cAICHClients = 0;
3301 uint32 cAICHLowIDClients = 0;
3302 for ( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ++it) {
3303 CUpDownClient* pCurClient = it->GetClient();
3304 if ( pCurClient->IsSupportingAICH() &&
3305 pCurClient->GetReqFileAICHHash() != NULL &&
3306 !pCurClient->IsAICHReqPending()
3307 && (*pCurClient->GetReqFileAICHHash()) == m_pAICHHashSet->GetMasterHash())
3308 {
3309 if (pCurClient->HasLowID()) {
3310 ++cAICHLowIDClients;
3311 } else {
3312 ++cAICHClients;
3313 }
3314 }
3315 }
3316 if ((cAICHClients | cAICHLowIDClients) == 0){
3317 AddDebugLogLineN( logAICHRecovery, wxT("Unable to request AICH Recoverydata because found no client who supports it and has the same hash as the trusted one"));
3318 return;
3319 }
3320 uint32 nSeclectedClient;
3321 if (cAICHClients > 0) {
3322 nSeclectedClient = (rand() % cAICHClients) + 1;
3323 } else {
3324 nSeclectedClient = (rand() % cAICHLowIDClients) + 1;
3325 }
3326 CUpDownClient* pClient = NULL;
3327 for ( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ++it) {
3328 CUpDownClient* pCurClient = it->GetClient();
3329 if (pCurClient->IsSupportingAICH() && pCurClient->GetReqFileAICHHash() != NULL && !pCurClient->IsAICHReqPending()
3330 && (*pCurClient->GetReqFileAICHHash()) == m_pAICHHashSet->GetMasterHash())
3331 {
3332 if (cAICHClients > 0){
3333 if (!pCurClient->HasLowID())
3334 nSeclectedClient--;
3335 }
3336 else{
3337 wxASSERT( pCurClient->HasLowID());
3338 nSeclectedClient--;
3339 }
3340 if (nSeclectedClient == 0){
3341 pClient = pCurClient;
3342 break;
3343 }
3344 }
3345 }
3346 if (pClient == NULL){
3347 wxFAIL;
3348 return;
3349 }
3350
3351 AddDebugLogLineN( logAICHRecovery, CFormat( wxT("Requesting AICH Hash (%s) form client %s") ) % ( cAICHClients ? wxT("HighId") : wxT("LowID") ) % pClient->GetClientFullInfo() );
3352 pClient->SendAICHRequest(this, nPart);
3353
3354 }
3355
3356
3357 void CPartFile::AICHRecoveryDataAvailable(uint16 nPart)
3358 {
3359 if (GetPartCount() < nPart){
3360 wxFAIL;
3361 return;
3362 }
3363
3364 FlushBuffer(true);
3365 uint32 length = GetPartSize(nPart);
3366 // if the part was already ok, it would now be complete
3367 if (IsComplete(nPart)) {
3368 AddDebugLogLineN(logAICHRecovery, CFormat(wxT("Processing AICH Recovery data: The part (%u) is already complete, canceling")) % nPart);
3369 return;
3370 }
3371
3372
3373
3374 CAICHHashTree* pVerifiedHash = m_pAICHHashSet->m_pHashTree.FindHash(nPart*PARTSIZE, length);
3375 if (pVerifiedHash == NULL || !pVerifiedHash->GetHashValid()){
3376 AddDebugLogLineC( logAICHRecovery, wxT("Processing AICH Recovery data: Unable to get verified hash from hashset (should never happen)") );
3377 wxFAIL;
3378 return;
3379 }
3380 CAICHHashTree htOurHash(pVerifiedHash->GetNDataSize(), pVerifiedHash->GetIsLeftBranch(), pVerifiedHash->GetNBaseSize());
3381 try {
3382 CreateHashFromFile(m_hpartfile, PARTSIZE * nPart, length, NULL, &htOurHash);
3383 } catch (const CIOFailureException& e) {
3384 AddDebugLogLineC(logAICHRecovery,
3385 CFormat(wxT("IO failure while hashing part-file '%s': %s"))
3386 % m_hpartfile.GetFilePath() % e.what());
3387 SetStatus(PS_ERROR);
3388 return;
3389 }
3390
3391 if (!htOurHash.GetHashValid()){
3392 AddDebugLogLineN( logAICHRecovery, wxT("Processing AICH Recovery data: Failed to retrieve AICH Hashset of corrupt part") );
3393 wxFAIL;
3394 return;
3395 }
3396
3397 // now compare the hash we just did, to the verified hash and readd all blocks which are ok
3398 uint32 nRecovered = 0;
3399 for (uint32 pos = 0; pos < length; pos += EMBLOCKSIZE){
3400 const uint32 nBlockSize = min<uint32>(EMBLOCKSIZE, length - pos);
3401 CAICHHashTree* pVerifiedBlock = pVerifiedHash->FindHash(pos, nBlockSize);
3402 CAICHHashTree* pOurBlock = htOurHash.FindHash(pos, nBlockSize);
3403 if ( pVerifiedBlock == NULL || pOurBlock == NULL || !pVerifiedBlock->GetHashValid() || !pOurBlock->GetHashValid()){
3404 wxFAIL;
3405 continue;
3406 }
3407 if (pOurBlock->GetHash() == pVerifiedBlock->GetHash()){
3408 FillGap(PARTSIZE*nPart+pos, PARTSIZE*nPart + pos + (nBlockSize-1));
3409 RemoveBlockFromList(PARTSIZE*nPart, PARTSIZE*nPart + (nBlockSize-1));
3410 nRecovered += nBlockSize;
3411 // tell the blackbox about the verified data
3412 m_CorruptionBlackBox->VerifiedData(true, nPart, pos, pos + nBlockSize - 1);
3413 } else {
3414 // inform our "blackbox" about the corrupted block which may ban clients who sent it
3415 m_CorruptionBlackBox->VerifiedData(false, nPart, pos, pos + nBlockSize - 1);
3416 }
3417 }
3418 m_CorruptionBlackBox->EvaluateData();
3419
3420 // ok now some sanity checks
3421 if (IsComplete(nPart)) {
3422 // this is bad, but it could probably happen under some rare circumstances
3423 // make sure that MD4 agrees to this fact too
3424 if (!HashSinglePart(nPart)) {
3425 AddDebugLogLineN(logAICHRecovery,
3426 CFormat(wxT("Processing AICH Recovery data: The part (%u) got completed while recovering - but MD4 says it corrupt! Setting hashset to error state, deleting part")) % nPart);
3427 // now we are fu... unhappy
3428 m_pAICHHashSet->SetStatus(AICH_ERROR);
3429 AddGap(nPart);
3430 wxFAIL;
3431 return;
3432 } else {
3433 AddDebugLogLineN(logAICHRecovery,
3434 CFormat(wxT("Processing AICH Recovery data: The part (%u) got completed while recovering and MD4 agrees")) % nPart);
3435 if (status == PS_EMPTY && theApp->IsRunning()) {
3436 if (GetHashCount() == GetED2KPartHashCount() && !m_hashsetneeded) {
3437 // Successfully recovered part, make it available for sharing
3438 SetStatus(PS_READY);
3439 theApp->sharedfiles->SafeAddKFile(this);
3440 }
3441 }
3442
3443 if (theApp->IsRunning()) {
3444 // Is this file finished?
3445 if (m_gaplist.IsComplete()) {
3446 CompleteFile(false);
3447 }
3448 }
3449 }
3450 } // end sanity check
3451 // We did the best we could. If it's still incomplete, then no need to keep
3452 // bashing it with ICH. So remove it from the list of corrupted parts.
3453 EraseFirstValue(m_corrupted_list, nPart);
3454 // Update met file
3455 SavePartFile();
3456
3457 // make sure the user appreciates our great recovering work :P
3458 AddDebugLogLineC( logAICHRecovery, CFormat(
3459 wxT("AICH successfully recovered %s of %s from part %u for %s") )
3460 % CastItoXBytes(nRecovered)
3461 % CastItoXBytes(length)
3462 % nPart
3463 % GetFileName() );
3464 }
3465
3466
3467 void CPartFile::ClientStateChanged( int oldState, int newState )
3468 {
3469 if ( oldState == newState )
3470 return;
3471
3472 // If the state is -1, then it's an entirely new item
3473 if ( oldState != -1 ) {
3474 // Was the old state a valid state?
3475 if ( oldState == DS_ONQUEUE || oldState == DS_DOWNLOADING ) {
3476 m_validSources--;
3477 } else {
3478 if ( oldState == DS_CONNECTED /* || oldState == DS_REMOTEQUEUEFULL */ ) {
3479 m_validSources--;
3480 }
3481
3482 m_notCurrentSources--;
3483 }
3484 }
3485
3486 // If the state is -1, then the source is being removed
3487 if ( newState != -1 ) {
3488 // Was the old state a valid state?
3489 if ( newState == DS_ONQUEUE || newState == DS_DOWNLOADING ) {
3490 ++m_validSources;
3491 } else {
3492 if ( newState == DS_CONNECTED /* || newState == DS_REMOTEQUEUEFULL */ ) {
3493 ++m_validSources;
3494 }
3495
3496 ++m_notCurrentSources;
3497 }
3498 }
3499 }
3500
3501
3502 bool CPartFile::AddSource( CUpDownClient* client )
3503 {
3504 if (m_SrcList.insert(CCLIENTREF(client, wxT("CPartFile::AddSource"))).second) {
3505 theStats::AddFoundSource();
3506 theStats::AddSourceOrigin(client->GetSourceFrom());
3507 return true;
3508 } else {
3509 return false;
3510 }
3511 }
3512
3513
3514 bool CPartFile::DelSource( CUpDownClient* client )
3515 {
3516 if (m_SrcList.erase(CCLIENTREF(client, wxEmptyString))) {
3517 theStats::RemoveSourceOrigin(client->GetSourceFrom());
3518 theStats::RemoveFoundSource();
3519 return true;
3520 } else {
3521 return false;
3522 }
3523 }
3524
3525
3526 void CPartFile::UpdatePartsFrequency( CUpDownClient* client, bool increment )
3527 {
3528 const BitVector& freq = client->GetPartStatus();
3529
3530 if ( m_SrcpartFrequency.size() != GetPartCount() ) {
3531 m_SrcpartFrequency.clear();
3532 m_SrcpartFrequency.insert(m_SrcpartFrequency.begin(), GetPartCount(), 0);
3533
3534 if ( !increment ) {
3535 return;
3536 }
3537 }
3538
3539 unsigned int size = freq.size();
3540 if ( size != m_SrcpartFrequency.size() ) {
3541 return;
3542 }
3543
3544 if ( increment ) {
3545 for ( unsigned int i = 0; i < size; i++ ) {
3546 if ( freq.get(i) ) {
3547 m_SrcpartFrequency[i]++;
3548 }
3549 }
3550 } else {
3551 for ( unsigned int i = 0; i < size; i++ ) {
3552 if ( freq.get(i) ) {
3553 m_SrcpartFrequency[i]--;
3554 }
3555 }
3556 }
3557 }
3558
3559 void CPartFile::GetRatingAndComments(FileRatingList & list) const
3560 {
3561 list.clear();
3562 // This can be pre-processed, but is it worth the CPU?
3563 CPartFile::SourceSet::const_iterator it = m_SrcList.begin();
3564 for ( ; it != m_SrcList.end(); ++it ) {
3565 CUpDownClient *cur_src = it->GetClient();
3566 if (cur_src->GetFileComment().Length()>0 || cur_src->GetFileRating()>0) {
3567 // AddDebugLogLineN(logPartFile, wxString(wxT("found a comment for ")) << GetFileName());
3568 list.push_back(SFileRating(*cur_src));
3569 }
3570 }
3571 }
3572
3573 #else // CLIENT_GUI
3574
3575 CPartFile::CPartFile(const CEC_PartFile_Tag *tag) : CKnownFile(tag)
3576 {
3577 Init();
3578
3579 SetFileName(CPath(tag->FileName()));
3580 m_abyFileHash = tag->FileHash();
3581 SetFileSize(tag->SizeFull());
3582 m_gaplist.Init(GetFileSize(), true); // Init empty
3583 m_partmetfilename = CPath(tag->PartMetName());
3584 m_fullname = m_partmetfilename; // We have only the met number, so show it without path in the detail dialog.
3585
3586 m_SrcpartFrequency.insert(m_SrcpartFrequency.end(), GetPartCount(), 0);
3587
3588 // these are only in CLIENT_GUI and not covered by Init()
3589 m_source_count = 0;
3590 m_kbpsDown = 0;
3591 m_iDownPriorityEC = 0;
3592 m_a4af_source_count = 0;
3593 m_isShared = false;
3594 }
3595
3596 /*
3597 * Remote gui specific code
3598 */
3599 CPartFile::~CPartFile()
3600 {
3601 }
3602
3603 void CPartFile::GetRatingAndComments(FileRatingList & list) const
3604 {
3605 list = m_FileRatingList;
3606 }
3607
3608 void CPartFile::SetCategory(uint8 cat)
3609 {
3610 m_category = cat;
3611 }
3612
3613
3614 bool CPartFile::AddSource(CUpDownClient* client)
3615 {
3616 return m_SrcList.insert(CCLIENTREF(client, wxT("CPartFile::AddSource"))).second != 0;
3617 }
3618
3619
3620 bool CPartFile::DelSource(CUpDownClient* client)
3621 {
3622 return m_SrcList.erase(CCLIENTREF(client, wxEmptyString)) != 0;
3623 }
3624
3625
3626 #endif // !CLIENT_GUI
3627
3628
3629 void CPartFile::UpdateDisplayedInfo(bool force)
3630 {
3631 uint32 curTick = ::GetTickCount();
3632
3633 // Wait 1.5s between each redraw
3634 if (force || curTick-m_lastRefreshedDLDisplay > MINWAIT_BEFORE_DLDISPLAY_WINDOWUPDATE) {
3635 Notify_DownloadCtrlUpdateItem(this);
3636 m_lastRefreshedDLDisplay = curTick;
3637 }
3638 }
3639
3640
3641 void CPartFile::Init()
3642 {
3643 m_lastsearchtime = 0;
3644 lastpurgetime = ::GetTickCount();
3645 m_paused = false;
3646 m_stopped = false;
3647 m_insufficient = false;
3648
3649 status = PS_EMPTY;
3650
3651 transferred = 0;
3652 m_iLastPausePurge = time(NULL);
3653
3654 if(thePrefs::GetNewAutoDown()) {
3655 m_iDownPriority = PR_HIGH;
3656 m_bAutoDownPriority = true;
3657 } else {
3658 m_iDownPriority = PR_NORMAL;
3659 m_bAutoDownPriority = false;
3660 }
3661
3662 transferingsrc = 0; // new
3663
3664 kBpsDown = 0.0;
3665
3666 m_hashsetneeded = true;
3667 m_count = 0;
3668 percentcompleted = 0;
3669 completedsize=0;
3670 lastseencomplete = 0;
3671 m_availablePartsCount=0;
3672 m_ClientSrcAnswered = 0;
3673 m_LastNoNeededCheck = 0;
3674 m_iRating = 0;
3675 m_nTotalBufferData = 0;
3676 m_nLastBufferFlushTime = 0;
3677 m_bPercentUpdated = false;
3678 m_iGainDueToCompression = 0;
3679 m_iLostDueToCorruption = 0;
3680 m_iTotalPacketsSavedDueToICH = 0;
3681 m_category = 0;
3682 m_lastRefreshedDLDisplay = 0;
3683 m_nDlActiveTime = 0;
3684 m_tActivated = 0;
3685 m_is_A4AF_auto = false;
3686 m_localSrcReqQueued = false;
3687 m_nCompleteSourcesTime = time(NULL);
3688 m_nCompleteSourcesCount = 0;
3689 m_nCompleteSourcesCountLo = 0;
3690 m_nCompleteSourcesCountHi = 0;
3691
3692 m_validSources = 0;
3693 m_notCurrentSources = 0;
3694
3695 // Kad
3696 m_LastSearchTimeKad = 0;
3697 m_TotalSearchesKad = 0;
3698
3699 #ifndef CLIENT_GUI
3700 m_CorruptionBlackBox = new CCorruptionBlackBox();
3701 #endif
3702 }
3703
3704 wxString CPartFile::getPartfileStatus() const
3705 {
3706
3707 wxString mybuffer;
3708
3709 if ((status == PS_HASHING) || (status == PS_WAITINGFORHASH)) {
3710 mybuffer=_("Hashing");
3711 } else if (status == PS_ALLOCATING) {
3712 mybuffer = _("Allocating");
3713 } else {
3714 switch (GetStatus()) {
3715 case PS_COMPLETING:
3716 mybuffer=_("Completing");
3717 break;
3718 case PS_COMPLETE:
3719 mybuffer=_("Complete");
3720 break;
3721 case PS_PAUSED:
3722 mybuffer=_("Paused");
3723 break;
3724 case PS_ERROR:
3725 mybuffer=_("Erroneous");
3726 break;
3727 case PS_INSUFFICIENT:
3728 mybuffer = _("Insufficient disk space");
3729 break;
3730 default:
3731 if (GetTransferingSrcCount()>0) {
3732 mybuffer=_("Downloading");
3733 } else {
3734 mybuffer=_("Waiting");
3735 }
3736 break;
3737 }
3738 if (m_stopped && (GetStatus()!=PS_COMPLETE)) {
3739 mybuffer=_("Stopped");
3740 }
3741 }
3742
3743 return mybuffer;
3744 }
3745
3746 int CPartFile::getPartfileStatusRang() const
3747 {
3748
3749 int tempstatus=0;
3750 if (GetTransferingSrcCount()==0) tempstatus=1;
3751 switch (GetStatus()) {
3752 case PS_HASHING:
3753 case PS_WAITINGFORHASH:
3754 tempstatus=3;
3755 break;
3756 case PS_COMPLETING:
3757 tempstatus=4;
3758 break;
3759 case PS_COMPLETE:
3760 tempstatus=5;
3761 break;
3762 case PS_PAUSED:
3763 tempstatus=2;
3764 break;
3765 case PS_ERROR:
3766 tempstatus=6;
3767 break;
3768 }
3769 return tempstatus;
3770 }
3771
3772
3773 wxString CPartFile::GetFeedback() const
3774 {
3775 wxString retval = CKnownFile::GetFeedback();
3776 if (GetStatus() != PS_COMPLETE) {
3777 retval += CFormat(wxT("%s: %s (%.2f%%)\n%s: %u\n"))
3778 % _("Downloaded") % CastItoXBytes(GetCompletedSize()) % GetPercentCompleted() % _("Sources") % GetSourceCount();
3779 }
3780 return retval + _("Status") + wxT(": ") + getPartfileStatus() + wxT("\n");
3781 }
3782
3783
3784 sint32 CPartFile::getTimeRemaining() const
3785 {
3786 if (GetKBpsDown() < 0.001)
3787 return -1;
3788 else
3789 return((GetFileSize()-GetCompletedSize()) / ((int)(GetKBpsDown()*1024.0)));
3790 }
3791
3792 bool CPartFile::PreviewAvailable()
3793 {
3794 const uint64 minSizeForPreview = 256 * 1024;
3795 FileType type = GetFiletype(GetFileName());
3796
3797 return (type == ftVideo || type == ftAudio) &&
3798 GetFileSize() >= minSizeForPreview &&
3799 IsComplete(0, minSizeForPreview);
3800 }
3801
3802 bool CPartFile::CheckShowItemInGivenCat(int inCategory)
3803 {
3804 // first check if item belongs in this cat in principle
3805 if (inCategory > 0 && inCategory != GetCategory()) {
3806 return false;
3807 }
3808
3809 // if yes apply filter
3810 bool show = true;
3811
3812 switch (thePrefs::GetAllcatFilter()) {
3813 case acfAllOthers:
3814 show = GetCategory() == 0 || inCategory > 0;
3815 break;
3816 case acfIncomplete:
3817 show = IsPartFile();
3818 break;
3819 case acfCompleted:
3820 show = !IsPartFile();
3821 break;
3822 case acfWaiting:
3823 show =
3824 (GetStatus() == PS_READY || GetStatus() == PS_EMPTY) &&
3825 GetTransferingSrcCount() == 0;
3826 break;
3827 case acfDownloading:
3828 show =
3829 (GetStatus() == PS_READY || GetStatus() == PS_EMPTY) &&
3830 GetTransferingSrcCount() > 0;
3831 break;
3832 case acfErroneous:
3833 show = GetStatus() == PS_ERROR;
3834 break;
3835 case acfPaused:
3836 show = GetStatus() == PS_PAUSED && !IsStopped();
3837 break;
3838 case acfStopped:
3839 show = IsStopped();
3840 break;
3841 case acfVideo:
3842 show = GetFiletype(GetFileName()) == ftVideo;
3843 break;
3844 case acfAudio:
3845 show = GetFiletype(GetFileName()) == ftAudio;
3846 break;
3847 case acfArchive:
3848 show = GetFiletype(GetFileName()) == ftArchive;
3849 break;
3850 case acfCDImages:
3851 show = GetFiletype(GetFileName()) == ftCDImage;
3852 break;
3853 case acfPictures:
3854 show = GetFiletype(GetFileName()) == ftPicture;
3855 break;
3856 case acfText:
3857 show = GetFiletype(GetFileName()) == ftText;
3858 break;
3859 case acfActive:
3860 show = !IsStopped() && GetStatus() != PS_PAUSED;
3861 break;
3862 default:
3863 show = true;
3864 break;
3865 }
3866
3867 return show;
3868 }
3869
3870
3871 void CPartFile::RemoveCategory(uint8 cat)
3872 {
3873 if (m_category == cat) {
3874 // Reset the category
3875 m_category = 0;
3876 } else if (m_category > cat) {
3877 // Set to the new position of the original category
3878 m_category--;
3879 }
3880 }
3881
3882
3883 void CPartFile::SetActive(bool bActive)
3884 {
3885 time_t tNow = time(NULL);
3886 if (bActive) {
3887 if (theApp->IsConnected()) {
3888 if (m_tActivated == 0) {
3889 m_tActivated = tNow;
3890 }
3891 }
3892 } else {
3893 if (m_tActivated != 0) {
3894 m_nDlActiveTime += tNow - m_tActivated;
3895 m_tActivated = 0;
3896 }
3897 }
3898 }
3899
3900
3901 uint32 CPartFile::GetDlActiveTime() const
3902 {
3903 uint32 nDlActiveTime = m_nDlActiveTime;
3904 if (m_tActivated != 0) {
3905 nDlActiveTime += time(NULL) - m_tActivated;
3906 }
3907 return nDlActiveTime;
3908 }
3909
3910
3911 uint16 CPartFile::GetPartMetNumber() const
3912 {
3913 long nr;
3914 return m_partmetfilename.RemoveAllExt().GetRaw().ToLong(&nr) ? nr : 0;
3915 }
3916
3917
3918 void CPartFile::SetHashingProgress(uint16 part) const
3919 {
3920 m_hashingProgress = part;
3921 Notify_DownloadCtrlUpdateItem(this);
3922 }
3923
3924
3925 #ifndef CLIENT_GUI
3926
3927 uint8 CPartFile::GetStatus(bool ignorepause) const
3928 {
3929 if ( (!m_paused && !m_insufficient) ||
3930 status == PS_ERROR ||
3931 status == PS_COMPLETING ||
3932 status == PS_COMPLETE ||
3933 ignorepause) {
3934 return status;
3935 } else if ( m_insufficient ) {
3936 return PS_INSUFFICIENT;
3937 } else {
3938 return PS_PAUSED;
3939 }
3940 }
3941
3942 void CPartFile::AddDeadSource(const CUpDownClient* client)
3943 {
3944 m_deadSources.AddDeadSource( client );
3945 }
3946
3947
3948 bool CPartFile::IsDeadSource(const CUpDownClient* client)
3949 {
3950 return m_deadSources.IsDeadSource( client );
3951 }
3952
3953 void CPartFile::SetFileName(const CPath& fileName)
3954 {
3955 CKnownFile* pFile = theApp->sharedfiles->GetFileByID(GetFileHash());
3956
3957 bool is_shared = (pFile && pFile == this);
3958
3959 if (is_shared) {
3960 // The file is shared, we must clear the search keywords so we don't
3961 // publish the old name anymore.
3962 theApp->sharedfiles->RemoveKeywords(this);
3963 }
3964
3965 CKnownFile::SetFileName(fileName);
3966
3967 if (is_shared) {
3968 // And of course, we must advertise the new name if the file is shared.
3969 theApp->sharedfiles->AddKeywords(this);
3970 }
3971
3972 UpdateDisplayedInfo(true);
3973 }
3974
3975
3976 uint16 CPartFile::GetMaxSources() const
3977 {
3978 // This is just like this, while we don't import the private max sources per file
3979 return thePrefs::GetMaxSourcePerFile();
3980 }
3981
3982
3983 uint16 CPartFile::GetMaxSourcePerFileSoft() const
3984 {
3985 unsigned int temp = ((unsigned int)GetMaxSources() * 9L) / 10;
3986 if (temp > MAX_SOURCES_FILE_SOFT) {
3987 return MAX_SOURCES_FILE_SOFT;
3988 }
3989 return temp;
3990 }
3991
3992 uint16 CPartFile::GetMaxSourcePerFileUDP() const
3993 {
3994 unsigned int temp = ((unsigned int)GetMaxSources() * 3L) / 4;
3995 if (temp > MAX_SOURCES_FILE_UDP) {
3996 return MAX_SOURCES_FILE_UDP;
3997 }
3998 return temp;
3999 }
4000
4001 #define DROP_FACTOR 2
4002
4003 CUpDownClient* CPartFile::GetSlowerDownloadingClient(uint32 speed, CUpDownClient* caller) {
4004 // printf("Start slower source calculation\n");
4005 for( SourceSet::iterator it = m_SrcList.begin(); it != m_SrcList.end(); ) {
4006 CUpDownClient* cur_src = it++->GetClient();
4007 if ((cur_src->GetDownloadState() == DS_DOWNLOADING) && (cur_src != caller)) {
4008 uint32 factored_bytes_per_second = static_cast<uint32>(
4009 (cur_src->GetKBpsDown() * 1024) * DROP_FACTOR);
4010 if ( factored_bytes_per_second< speed) {
4011 // printf("Selecting source %p to drop: %d < %d\n", cur_src, factored_bytes_per_second, speed);
4012 // printf("End slower source calculation\n");
4013 return cur_src;
4014 } else {
4015 // printf("Not selecting source %p to drop: %d > %d\n", cur_src, factored_bytes_per_second, speed);
4016 }
4017 }
4018 }
4019 // printf("End slower source calculation\n");
4020 return NULL;
4021 }
4022
4023 void CPartFile::AllocationFinished()
4024 {
4025 // see if it can be opened
4026 if (!m_hpartfile.Open(m_PartPath, CFile::read_write)) {
4027 AddLogLineN(CFormat(_("ERROR: Failed to open partfile '%s'")) % GetFullName());
4028 SetStatus(PS_ERROR);
4029 }
4030 // then close the handle again
4031 m_hpartfile.Release(true);
4032 }
4033
4034 #endif
4035 // File_checked_for_headers
aMule P2P client