2 // This file is part of the aMule Project.
4 // Parts of this file are based on work from pan One (http://home-3.tiscali.nl/~meost/pms/)
6 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
7 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
9 // Any parts of this program derived from the xMule, lMule or eMule project,
10 // or contributed by third-party developers are copyrighted by their
11 // respective authors.
13 // This program is free software; you can redistribute it and/or modify
14 // it under the terms of the GNU General Public License as published by
15 // the Free Software Foundation; either version 2 of the License, or
16 // (at your option) any later version.
18 // This program is distributed in the hope that it will be useful,
19 // but WITHOUT ANY WARRANTY; without even the implied warranty of
20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 // GNU General Public License for more details.
23 // You should have received a copy of the GNU General Public License
24 // along with this program; if not, write to the Free Software
25 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
29 #include "KnownFile.h" // Do_not_auto_remove
31 #include <protocol/kad/Constants.h>
32 #include <protocol/ed2k/Client2Client/TCP.h>
33 #include <protocol/ed2k/ClientSoftware.h>
34 #include <protocol/Protocols.h>
35 #include <tags/FileTags.h>
37 #include <wx/config.h>
40 #include "UpDownClientEC.h" // Needed for CUpDownClient
42 #include "updownclient.h" // Needed for CUpDownClient
45 #include "MemFile.h" // Needed for CMemFile
46 #include "Packet.h" // Needed for CPacket
47 #include "Preferences.h" // Needed for CPreferences
48 #include "KnownFileList.h" // Needed for CKnownFileList
49 #include "amule.h" // Needed for theApp
50 #include "PartFile.h" // Needed for SavePartFile
51 #include "ClientList.h" // Needed for clientlist (buddy support)
53 #include "ScopedPtr.h" // Needed for CScopedArray and CScopedPtr
54 #include "GuiEvents.h" // Needed for Notify_*
55 #include "SearchFile.h" // Needed for CSearchFile
56 #include "FileArea.h" // Needed for CFileArea
57 #include "FileAutoClose.h" // Needed for CFileAutoClose
58 #include "Server.h" // Needed for CServer
60 #include "CryptoPP_Inc.h" // Needed for MD4
62 #include <common/Format.h>
64 CFileStatistic::CFileStatistic(CKnownFile
*parent
)
70 alltimetransferred(0),
76 void CFileStatistic::AddRequest()
80 theApp
->knownfiles
->requested
++;
81 theApp
->sharedfiles
->UpdateItem(fileParent
);
84 void CFileStatistic::AddAccepted()
88 theApp
->knownfiles
->accepted
++;
89 theApp
->sharedfiles
->UpdateItem(fileParent
);
92 void CFileStatistic::AddTransferred(uint64 bytes
)
95 alltimetransferred
+= bytes
;
96 theApp
->knownfiles
->transferred
+= bytes
;
97 theApp
->sharedfiles
->UpdateItem(fileParent
);
103 /* Abstract File (base class)*/
105 CAbstractFile::CAbstractFile()
113 CAbstractFile::CAbstractFile(const CAbstractFile
& other
)
114 : m_abyFileHash(other
.m_abyFileHash
),
115 m_strComment(other
.m_strComment
),
116 m_iRating(other
.m_iRating
),
117 m_hasComment(other
.m_hasComment
),
118 m_iUserRating(other
.m_iUserRating
),
119 m_taglist(other
.m_taglist
),
121 m_nFileSize(other
.m_nFileSize
),
122 m_fileName(other
.m_fileName
)
124 /* // TODO: Currently it's not safe to duplicate the entries, but isn't needed either.
125 CKadEntryPtrList::const_iterator it = other.m_kadNotes.begin();
126 for (; it != other.m_kadNotes.end(); ++it) {
127 m_kadNotes.push_back(new Kademlia::CEntry(**it));
133 void CAbstractFile::SetFileName(const CPath
& fileName
)
135 m_fileName
= fileName
;
138 uint32
CAbstractFile::GetIntTagValue(uint8 tagname
) const
140 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
141 for (; it
!= m_taglist
.end(); ++it
){
142 if (((*it
).GetNameID() == tagname
) && (*it
).IsInt()) {
143 return (*it
).GetInt();
149 bool CAbstractFile::GetIntTagValue(uint8 tagname
, uint32
& ruValue
) const
151 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
152 for (; it
!= m_taglist
.end(); ++it
){
153 if (((*it
).GetNameID() == tagname
) && (*it
).IsInt()){
154 ruValue
= (*it
).GetInt();
161 uint32
CAbstractFile::GetIntTagValue(const wxString
& tagname
) const
163 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
164 for (; it
!= m_taglist
.end(); ++it
){
165 if ((*it
).IsInt() && ((*it
).GetName() == tagname
)) {
166 return (*it
).GetInt();
172 const wxString
& CAbstractFile::GetStrTagValue(uint8 tagname
) const
174 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
175 for (; it
!= m_taglist
.end(); ++it
){
176 if ((*it
).GetNameID() == tagname
&& (*it
).IsStr()) {
177 return (*it
).GetStr();
183 const wxString
& CAbstractFile::GetStrTagValue(const wxString
& tagname
) const
185 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
186 for (; it
!= m_taglist
.end(); ++it
){
187 if ((*it
).IsStr() && ((*it
).GetName() == tagname
)) {
188 return (*it
).GetStr();
194 const CTag
*CAbstractFile::GetTag(uint8 tagname
, uint8 tagtype
) const
196 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
197 for (; it
!= m_taglist
.end(); ++it
){
198 if ((*it
).GetNameID() == tagname
&& (*it
).GetType() == tagtype
) {
205 const CTag
*CAbstractFile::GetTag(const wxString
& tagname
, uint8 tagtype
) const
207 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
208 for (; it
!= m_taglist
.end(); ++it
){
209 if ((*it
).GetType() == tagtype
&& (*it
).GetName() == tagname
) {
216 const CTag
*CAbstractFile::GetTag(uint8 tagname
) const
218 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
219 for (; it
!= m_taglist
.end(); ++it
){
220 if ((*it
).GetNameID() == tagname
) {
227 const CTag
*CAbstractFile::GetTag(const wxString
& tagname
) const
229 ArrayOfCTag::const_iterator it
= m_taglist
.begin();
230 for (; it
!= m_taglist
.end(); ++it
){
231 if ((*it
).GetName() == tagname
) {
238 void CAbstractFile::AddTagUnique(const CTag
&rTag
)
240 ArrayOfCTag::iterator it
= m_taglist
.begin();
241 for (; it
!= m_taglist
.end(); ++it
) {
242 if ( ( ((*it
).GetNameID() != 0 &&
243 (*it
).GetNameID() == rTag
.GetNameID()) ||
244 (!(*it
).GetName().IsEmpty() &&
245 !rTag
.GetName().IsEmpty() &&
246 (*it
).GetName() == rTag
.GetName()) ) &&
247 (*it
).GetType() == rTag
.GetType())
249 it
= m_taglist
.erase(it
);
250 m_taglist
.insert(it
, rTag
);
254 m_taglist
.push_back(rTag
);
258 void CAbstractFile::AddNote(Kademlia::CEntry
*pEntry
)
260 CKadEntryPtrList::iterator it
= m_kadNotes
.begin();
261 for (; it
!= m_kadNotes
.end(); ++it
) {
262 Kademlia::CEntry
* entry
= *it
;
263 if(entry
->m_uIP
== pEntry
->m_uIP
|| entry
->m_uSourceID
== pEntry
->m_uSourceID
) {
268 m_kadNotes
.push_front(pEntry
);
271 void CAbstractFile::AddNote(Kademlia::CEntry
*)
279 CKnownFile::CKnownFile()
285 CKnownFile::CKnownFile(uint32 ecid
)
293 //#warning Experimental: Construct a CKnownFile from a CSearchFile
294 CKnownFile::CKnownFile(const CSearchFile
&searchFile
)
296 // This will copy the file hash
297 CAbstractFile(static_cast<const CAbstractFile
&>(searchFile
)),
302 // Use CKnownFile::SetFileName()
303 SetFileName(searchFile
.GetFileName());
305 // Use CKnownFile::SetFileSize()
306 SetFileSize(searchFile
.GetFileSize());
310 void CKnownFile::Init()
312 m_showSources
= false;
314 m_nCompleteSourcesTime
= time(NULL
);
315 m_nCompleteSourcesCount
= 0;
316 m_nCompleteSourcesCountLo
= 0;
317 m_nCompleteSourcesCountHi
= 0;
318 m_bCommentLoaded
= false;
320 m_iED2KPartCount
= 0;
321 m_iED2KPartHashCount
= 0;
322 m_PublishedED2K
= false;
324 m_lastPublishTimeKadSrc
= 0;
325 m_lastPublishTimeKadNotes
= 0;
327 m_lastDateChanged
= 0;
328 m_bAutoUpPriority
= thePrefs::GetNewAutoUp();
329 m_iUpPriority
= ( m_bAutoUpPriority
) ? PR_HIGH
: PR_NORMAL
;
330 m_hashingProgress
= 0;
333 m_pAICHHashSet
= new CAICHHashSet(this);
338 void CKnownFile::SetFileSize(uint64 nFileSize
)
340 CAbstractFile::SetFileSize(nFileSize
);
342 m_pAICHHashSet
->SetFileSize(nFileSize
);
345 // Examples of parthashs, hashsets and filehashs for different filesizes
346 // according the ed2k protocol
347 //----------------------------------------------------------------------
350 //File hash: 2D55E87D0E21F49B9AD25F98531F3724
354 //File size: 1*PARTSIZE
355 //File hash: A72CA8DF7F07154E217C236C89C17619
357 //Hash[ 0]: 4891ED2E5C9C49F442145A3A5F608299
358 //Hash[ 1]: 31D6CFE0D16AE931B73C59D7E0C089C0 *special part hash*
361 //File size: 1*PARTSIZE + 1 byte
362 //File hash: 2F620AE9D462CBB6A59FE8401D2B3D23
364 //Hash[ 0]: 121795F0BEDE02DDC7C5426D0995F53F
365 //Hash[ 1]: C329E527945B8FE75B3C5E8826755747
368 //File size: 2*PARTSIZE
369 //File hash: A54C5E562D5E03CA7D77961EB9A745A4
371 //Hash[ 0]: B3F5CE2A06BF403BFB9BFFF68BDDC4D9
372 //Hash[ 1]: 509AA30C9EA8FC136B1159DF2F35B8A9
373 //Hash[ 2]: 31D6CFE0D16AE931B73C59D7E0C089C0 *special part hash*
376 //File size: 3*PARTSIZE
377 //File hash: 5E249B96F9A46A18FC2489B005BF2667
379 //Hash[ 0]: 5319896A2ECAD43BF17E2E3575278E72
380 //Hash[ 1]: D86EF157D5E49C5ED502EDC15BB5F82B
381 //Hash[ 2]: 10F2D5B1FCB95C0840519C58D708480F
382 //Hash[ 3]: 31D6CFE0D16AE931B73C59D7E0C089C0 *special part hash*
385 //File size: 3*PARTSIZE + 1 byte
386 //File hash: 797ED552F34380CAFF8C958207E40355
388 //Hash[ 0]: FC7FD02CCD6987DCF1421F4C0AF94FB8
389 //Hash[ 1]: 2FE466AF8A7C06DA3365317B75A5ACFE
390 //Hash[ 2]: 873D3BF52629F7C1527C6E8E473C1C30
391 //Hash[ 3]: BCE50BEE7877BB07BB6FDA56BFE142FB
394 // File size Data parts ED2K parts ED2K part hashs
395 // ---------------------------------------------------------------
396 // 1..PARTSIZE-1 1 1 0(!)
397 // PARTSIZE 1 2(!) 2(!)
399 // PARTSIZE*2 2 3(!) 3(!)
400 // PARTSIZE*2+1 3 3 3
403 //wxFAIL; // Kry - Why commented out by lemonfan? it can never be 0
405 m_iED2KPartCount
= 0;
406 m_iED2KPartHashCount
= 0;
412 m_iPartCount
= nFileSize
/ PARTSIZE
+ 1;
414 m_sizeLastPart
= nFileSize
% PARTSIZE
;
415 // file with size of n * PARTSIZE
416 if (m_sizeLastPart
== 0) {
417 m_sizeLastPart
= PARTSIZE
;
421 // nr. of parts to be used with OP_FILESTATUS
422 m_iED2KPartCount
= nFileSize
/ PARTSIZE
+ 1;
424 // nr. of parts to be used with OP_HASHSETANSWER
425 m_iED2KPartHashCount
= nFileSize
/ PARTSIZE
;
426 if (m_iED2KPartHashCount
!= 0) {
427 m_iED2KPartHashCount
+= 1;
432 void CKnownFile::AddUploadingClient(CUpDownClient
* client
)
434 m_ClientUploadList
.insert(CCLIENTREF(client
, wxT("CKnownFile::AddUploadingClient m_ClientUploadList")));
436 SourceItemType type
= UNAVAILABLE_SOURCE
;
437 switch (client
->GetUploadState()) {
439 case US_ONUPLOADQUEUE
:
440 type
= AVAILABLE_SOURCE
;
443 // Any other state is UNAVAILABLE_SOURCE by default.
447 Notify_SharedCtrlAddClient(this, CCLIENTREF(client
, wxT("CKnownFile::AddUploadingClient Notify_SharedCtrlAddClient")), type
);
449 UpdateAutoUpPriority();
453 void CKnownFile::RemoveUploadingClient(CUpDownClient
* client
)
455 if (m_ClientUploadList
.erase(CCLIENTREF(client
, wxEmptyString
))) {
456 Notify_SharedCtrlRemoveClient(client
->ECID(), this);
457 UpdateAutoUpPriority();
464 CKnownFile::CKnownFile(const CEC_SharedFile_Tag
*tag
)
470 m_abyFileHash
= tag
->FileHash();
471 SetFileSize(tag
->SizeFull());
472 m_AvailPartFrequency
.insert(m_AvailPartFrequency
.end(), m_iPartCount
, 0);
476 CKnownFile::~CKnownFile()
479 void CKnownFile::UpdateAutoUpPriority()
483 #else // ! CLIENT_GUI
485 CKnownFile::~CKnownFile()
487 SourceSet::iterator it
= m_ClientUploadList
.begin();
488 for ( ; it
!= m_ClientUploadList
.end(); ++it
) {
489 it
->ClearUploadFileID();
492 delete m_pAICHHashSet
;
496 void CKnownFile::SetFilePath(const CPath
& filePath
)
498 m_filePath
= filePath
;
502 // needed for memfiles. its probably better to switch everything to CFile...
503 bool CKnownFile::LoadHashsetFromFile(const CFileDataIO
* file
, bool checkhash
)
505 CMD4Hash checkid
= file
->ReadHash();
507 uint16 parts
= file
->ReadUInt16();
509 for (uint16 i
= 0; i
< parts
; ++i
){
510 CMD4Hash cur_hash
= file
->ReadHash();
511 m_hashlist
.push_back(cur_hash
);
514 // SLUGFILLER: SafeHash - always check for valid m_hashlist
516 m_abyFileHash
= checkid
;
517 if (parts
<= 1) { // nothing to check
521 if ( m_abyFileHash
!= checkid
) {
522 return false; // wrong file?
524 if (parts
!= GetED2KPartHashCount()) {
529 // SLUGFILLER: SafeHash
532 // lol, useless comment but made me lmao
533 // wtf you guys are weird.
535 if (!m_hashlist
.empty()) {
536 CreateHashFromHashlist(m_hashlist
, &checkid
);
539 if ( m_abyFileHash
== checkid
) {
548 bool CKnownFile::LoadTagsFromFile(const CFileDataIO
* file
)
550 uint32 tagcount
= file
->ReadUInt32();
552 for (uint32 j
= 0; j
!= tagcount
; ++j
) {
553 CTag
newtag(*file
, true);
554 switch(newtag
.GetNameID()){
556 if (GetFileName().IsOk()) {
557 // Unlike eMule, we actually prefer the second
558 // filename tag, since we use it to specify the
559 // 'universial' filename (see CPath::ToUniv).
560 CPath path
= CPath::FromUniv(newtag
.GetStr());
562 // May be invalid, if from older versions where
563 // unicoded filenames be saved as empty-strings.
568 SetFileName(CPath(newtag
.GetStr()));
573 SetFileSize(newtag
.GetInt());
574 m_AvailPartFrequency
.clear();
575 m_AvailPartFrequency
.insert(
576 m_AvailPartFrequency
.begin(),
580 case FT_ATTRANSFERRED
:
581 statistic
.SetAllTimeTransferred(statistic
.GetAllTimeTransferred() + newtag
.GetInt());
584 case FT_ATTRANSFERREDHI
:
585 statistic
.SetAllTimeTransferred(statistic
.GetAllTimeTransferred() + (((uint64
)newtag
.GetInt()) << 32));
589 statistic
.SetAllTimeRequests(newtag
.GetInt());
593 statistic
.SetAllTimeAccepts(newtag
.GetInt());
597 m_iUpPriority
= newtag
.GetInt();
598 if( m_iUpPriority
== PR_AUTO
){
599 m_iUpPriority
= PR_HIGH
;
600 m_bAutoUpPriority
= true;
602 if ( m_iUpPriority
!= PR_VERYLOW
&&
603 m_iUpPriority
!= PR_LOW
&&
604 m_iUpPriority
!= PR_NORMAL
&&
605 m_iUpPriority
!= PR_HIGH
&&
606 m_iUpPriority
!= PR_VERYHIGH
&&
607 m_iUpPriority
!= PR_POWERSHARE
) {
608 m_iUpPriority
= PR_NORMAL
;
611 m_bAutoUpPriority
= false;
616 case FT_KADLASTPUBLISHKEY
:
617 case FT_PARTFILENAME
:
618 // Old tags, not used anymore. Just purge them.
624 hash
.DecodeBase32(newtag
.GetStr()) == CAICHHash::GetHashSize();
625 wxASSERT(hashSizeOk
);
627 m_pAICHHashSet
->SetMasterHash(hash
, AICH_HASHSETCOMPLETE
);
632 case FT_KADLASTPUBLISHSRC
:
633 SetLastPublishTimeKadSrc( newtag
.GetInt(), 0 );
635 if(GetLastPublishTimeKadSrc() > (uint32
)time(NULL
)+KADEMLIAREPUBLISHTIMES
) {
636 //There may be a posibility of an older client that saved a random number here.. This will check for that..
637 SetLastPublishTimeKadSrc(0, 0);
641 case FT_KADLASTPUBLISHNOTES
:
642 SetLastPublishTimeKadNotes( newtag
.GetInt() );
646 // Store them here and write them back on saving.
647 m_taglist
.push_back(newtag
);
655 bool CKnownFile::LoadDateFromFile(const CFileDataIO
* file
)
657 m_lastDateChanged
= file
->ReadUInt32();
663 bool CKnownFile::LoadFromFile(const CFileDataIO
* file
)
665 // SLUGFILLER: SafeHash - load first, verify later
666 bool ret1
= LoadDateFromFile(file
);
667 bool ret2
= LoadHashsetFromFile(file
,false);
668 bool ret3
= LoadTagsFromFile(file
);
670 // Final hash-count verification, needs to be done after the tags are loaded.
671 return ret1
&& ret2
&& ret3
&& GetED2KPartHashCount()==GetHashCount();
672 // SLUGFILLER: SafeHash
676 bool CKnownFile::WriteToFile(CFileDataIO
* file
)
678 wxCHECK(!IsPartFile(), false);
681 file
->WriteUInt32(m_lastDateChanged
);
683 file
->WriteHash(m_abyFileHash
);
685 uint16 parts
= m_hashlist
.size();
686 file
->WriteUInt16(parts
);
688 for (int i
= 0; i
< parts
; ++i
)
689 file
->WriteHash(m_hashlist
[i
]);
692 const int iFixedTags
= 8;
693 uint32 tagcount
= iFixedTags
;
694 if (HasProperAICHHashSet()) {
697 // Float meta tags are currently not written. All older eMule versions < 0.28a have
698 // a bug in the meta tag reading+writing code. To achive maximum backward
699 // compatibility for met files with older eMule versions we just don't write float
700 // tags. This is OK, because we (eMule) do not use float tags. The only float tags
701 // we may have to handle is the '# Sent' tag from the Hybrid, which is pretty
702 // useless but may be received from us via the servers.
704 // The code for writing the float tags SHOULD BE ENABLED in SOME MONTHS (after most
705 // people are using the newer eMule versions which do not write broken float tags).
706 for (size_t j
= 0; j
< m_taglist
.size(); ++j
){
707 if (m_taglist
[j
].IsInt() || m_taglist
[j
].IsStr()) {
712 if (m_lastPublishTimeKadSrc
) {
716 if (m_lastPublishTimeKadNotes
){
722 file
->WriteUInt32(tagcount
);
724 // We still save the unicoded filename, for backwards
725 // compatibility with pre-2.2 and other clients.
726 CTagString
nametag_unicode(FT_FILENAME
, GetFileName().GetRaw());
727 // We write it with BOM to keep eMule compatibility
728 nametag_unicode
.WriteTagToFile(file
,utf8strOptBOM
);
730 // The non-unicoded filename is written in an 'universial'
731 // format, which allows us to identify files, even if the
732 // system locale changes.
733 CTagString
nametag(FT_FILENAME
, CPath::ToUniv(GetFileName()));
734 nametag
.WriteTagToFile(file
);
736 CTagIntSized
sizetag(FT_FILESIZE
, GetFileSize(), IsLargeFile() ? 64 : 32);
737 sizetag
.WriteTagToFile(file
);
741 tran
= statistic
.GetAllTimeTransferred() & 0xFFFFFFFF;
742 CTagInt32
attag1(FT_ATTRANSFERRED
, tran
);
743 attag1
.WriteTagToFile(file
);
745 tran
= statistic
.GetAllTimeTransferred() >> 32;
746 CTagInt32
attag4(FT_ATTRANSFERREDHI
, tran
);
747 attag4
.WriteTagToFile(file
);
749 CTagInt32
attag2(FT_ATREQUESTED
, statistic
.GetAllTimeRequests());
750 attag2
.WriteTagToFile(file
);
752 CTagInt32
attag3(FT_ATACCEPTED
, statistic
.GetAllTimeAccepts());
753 attag3
.WriteTagToFile(file
);
755 // priority N permission
756 CTagInt32
priotag(FT_ULPRIORITY
, IsAutoUpPriority() ? PR_AUTO
: m_iUpPriority
);
757 priotag
.WriteTagToFile(file
);
760 if (HasProperAICHHashSet()) {
761 CTagString
aichtag(FT_AICH_HASH
, m_pAICHHashSet
->GetMasterHash().GetString());
762 aichtag
.WriteTagToFile(file
);
766 if (m_lastPublishTimeKadSrc
){
767 CTagInt32
kadLastPubSrc(FT_KADLASTPUBLISHSRC
, m_lastPublishTimeKadSrc
);
768 kadLastPubSrc
.WriteTagToFile(file
);
772 if (m_lastPublishTimeKadNotes
){
773 CTagInt32
kadLastPubNotes(FT_KADLASTPUBLISHNOTES
, m_lastPublishTimeKadNotes
);
774 kadLastPubNotes
.WriteTagToFile(file
);
778 for (size_t j
= 0; j
< m_taglist
.size(); ++j
){
779 if (m_taglist
[j
].IsInt() || m_taglist
[j
].IsStr()) {
780 m_taglist
[j
].WriteTagToFile(file
);
787 void CKnownFile::CreateHashFromHashlist(const ArrayOfCMD4Hash
& hashes
, CMD4Hash
* Output
)
789 wxCHECK_RET(hashes
.size(), wxT("No input to hash from in CreateHashFromHashlist"));
791 std::vector
<uint8_t> buffer(hashes
.size() * MD4HASH_LENGTH
);
792 std::vector
<uint8_t>::iterator it
= buffer
.begin();
794 for (size_t i
= 0; i
< hashes
.size(); ++i
) {
795 it
= STLCopy_n(hashes
[i
].GetHash(), MD4HASH_LENGTH
, it
);
798 CreateHashFromInput(&buffer
[0], buffer
.size(), Output
, NULL
);
802 void CKnownFile::CreateHashFromFile(CFileAutoClose
& file
, uint64 offset
, uint32 Length
, CMD4Hash
* Output
, CAICHHashTree
* pShaHashOut
)
804 wxCHECK_RET(Length
, wxT("No input to hash from in CreateHashFromFile"));
807 area
.ReadAt(file
, offset
, Length
);
809 CreateHashFromInput(area
.GetBuffer(), Length
, Output
, pShaHashOut
);
814 void CKnownFile::CreateHashFromInput(const uint8_t* input
, uint32 Length
, CMD4Hash
* Output
, CAICHHashTree
* pShaHashOut
)
816 wxASSERT_MSG(Output
|| pShaHashOut
, wxT("Nothing to do in CreateHashFromInput"));
817 { wxCHECK_RET(input
, wxT("No input to hash from in CreateHashFromInput")); }
818 wxASSERT(Length
<= PARTSIZE
); // We never hash more than one PARTSIZE
820 CMemFile
data(input
, Length
);
822 uint32 Required
= Length
;
825 uint32 posCurrentEMBlock
= 0;
827 CScopedPtr
<CAICHHashAlgo
> pHashAlg(CAICHHashSet::GetNewHashAlgo());
830 while (Required
>= 64) {
831 uint32 len
= Required
/ 64;
832 if (len
> sizeof(X
)/(64 * sizeof(X
[0]))) {
833 len
= sizeof(X
)/(64 * sizeof(X
[0]));
836 data
.Read(&X
, len
* 64);
838 // SHA hash needs 180KB blocks
840 if (nIACHPos
+ len
*64 >= EMBLOCKSIZE
) {
841 uint32 nToComplete
= EMBLOCKSIZE
- nIACHPos
;
842 pHashAlg
->Add(X
, nToComplete
);
843 wxASSERT( nIACHPos
+ nToComplete
== EMBLOCKSIZE
);
844 pShaHashOut
->SetBlockHash(EMBLOCKSIZE
, posCurrentEMBlock
, pHashAlg
.get());
845 posCurrentEMBlock
+= EMBLOCKSIZE
;
847 pHashAlg
->Add(X
+nToComplete
,(len
*64) - nToComplete
);
848 nIACHPos
= (len
*64) - nToComplete
;
851 pHashAlg
->Add(X
, len
*64);
859 Required
= Length
% 64;
861 data
.Read(&X
,Required
);
863 if (pShaHashOut
!= NULL
){
864 if (nIACHPos
+ Required
>= EMBLOCKSIZE
){
865 uint32 nToComplete
= EMBLOCKSIZE
- nIACHPos
;
866 pHashAlg
->Add(X
, nToComplete
);
867 wxASSERT( nIACHPos
+ nToComplete
== EMBLOCKSIZE
);
868 pShaHashOut
->SetBlockHash(EMBLOCKSIZE
, posCurrentEMBlock
, pHashAlg
.get());
869 posCurrentEMBlock
+= EMBLOCKSIZE
;
871 pHashAlg
->Add(X
+nToComplete
, Required
- nToComplete
);
872 nIACHPos
= Required
- nToComplete
;
875 pHashAlg
->Add(X
, Required
);
876 nIACHPos
+= Required
;
880 if (pShaHashOut
!= NULL
){
882 pShaHashOut
->SetBlockHash(nIACHPos
, posCurrentEMBlock
, pHashAlg
.get());
883 posCurrentEMBlock
+= nIACHPos
;
885 wxASSERT( posCurrentEMBlock
== Length
);
886 wxCHECK2( pShaHashOut
->ReCalculateHash(pHashAlg
.get(), false), );
890 CryptoPP::Weak::MD4 md4_hasher
;
891 md4_hasher
.CalculateDigest(Output
->GetHash(), input
, Length
);
896 const CMD4Hash
& CKnownFile::GetPartHash(uint16 part
) const {
897 wxASSERT( part
< m_hashlist
.size() );
899 return m_hashlist
[part
];
902 CPacket
* CKnownFile::CreateSrcInfoPacket(const CUpDownClient
* forClient
, uint8 byRequestedVersion
, uint16 nRequestedOptions
)
906 if (m_ClientUploadList
.empty()) {
910 if (((static_cast<CKnownFile
*>(forClient
->GetRequestFile()) != this)
911 && (forClient
->GetUploadFile() != this)) || forClient
->GetUploadFileID() != GetFileHash()) {
912 wxString file1
= _("Unknown");
913 if (forClient
->GetRequestFile() && forClient
->GetRequestFile()->GetFileName().IsOk()) {
914 file1
= forClient
->GetRequestFile()->GetFileName().GetPrintable();
915 } else if (forClient
->GetUploadFile() && forClient
->GetUploadFile()->GetFileName().IsOk()) {
916 file1
= forClient
->GetUploadFile()->GetFileName().GetPrintable();
918 wxString file2
= _("Unknown");
919 if (GetFileName().IsOk()) {
920 file2
= GetFileName().GetPrintable();
922 AddDebugLogLineN(logKnownFiles
, wxT("File mismatch on source packet (K) Sending: ") + file1
+ wxT(" From: ") + file2
);
926 const BitVector
& rcvstatus
= forClient
->GetUpPartStatus();
927 bool SupportsUploadChunksState
= !rcvstatus
.empty();
928 //wxASSERT(rcvstatus.size() == GetPartCount()); // Obviously!
929 if (rcvstatus
.size() != GetPartCount()) {
930 // Yuck. Same file but different part count? Seriously fucked up.
931 AddDebugLogLineN(logKnownFiles
, CFormat(wxT("Impossible situation: different partcounts for the same known file: %i (client) and %i (file)")) % rcvstatus
.size() % GetPartCount());
939 if (forClient
->SupportsSourceExchange2() && byRequestedVersion
> 0){
940 // the client uses SourceExchange2 and requested the highest version he knows
941 // and we send the highest version we know, but of course not higher than his request
942 byUsedVersion
= std::min(byRequestedVersion
, (uint8
)SOURCEEXCHANGE2_VERSION
);
944 data
.WriteUInt8(byUsedVersion
);
946 // we don't support any special SX2 options yet, reserved for later use
947 if (nRequestedOptions
!= 0) {
948 AddDebugLogLineN(logKnownFiles
, CFormat(wxT("Client requested unknown options for SourceExchange2: %u")) % nRequestedOptions
);
951 byUsedVersion
= forClient
->GetSourceExchange1Version();
952 bIsSX2Packet
= false;
953 if (forClient
->SupportsSourceExchange2()) {
954 AddDebugLogLineN(logKnownFiles
, wxT("Client which announced to support SX2 sent SX1 packet instead"));
960 data
.WriteHash(forClient
->GetUploadFileID());
961 data
.WriteUInt16(nCount
);
962 uint32 cDbgNoSrc
= 0;
964 SourceSet::iterator it
= m_ClientUploadList
.begin();
965 for ( ; it
!= m_ClientUploadList
.end(); ++it
) {
966 const CUpDownClient
*cur_src
= it
->GetClient();
968 if ( cur_src
->HasLowID() ||
969 cur_src
== forClient
||
970 !( cur_src
->GetUploadState() == US_UPLOADING
||
971 cur_src
->GetUploadState() == US_ONUPLOADQUEUE
)) {
975 bool bNeeded
= false;
977 if ( SupportsUploadChunksState
) {
978 const BitVector
& srcstatus
= cur_src
->GetUpPartStatus();
979 if ( !srcstatus
.empty() ) {
980 //wxASSERT(srcstatus.size() == GetPartCount()); // Obviously!
981 if (srcstatus
.size() != GetPartCount()) {
984 if ( cur_src
->GetUpPartCount() == forClient
->GetUpPartCount() ) {
985 for (int x
= 0; x
< GetPartCount(); x
++ ) {
986 if ( srcstatus
.get(x
) && !rcvstatus
.get(x
) ) {
987 // We know the receiving client needs
988 // a chunk from this client.
996 // This client doesn't support upload chunk status.
997 // So just send it and hope for the best.
1001 // remote client does not support upload chunk status,
1002 // search sources which have at least one complete part
1003 // we could even sort the list of sources by available
1004 // chunks to return as much sources as possible which
1005 // have the most available chunks. but this could be
1006 // a noticeable performance problem.
1007 const BitVector
& srcstatus
= cur_src
->GetUpPartStatus();
1008 if ( !srcstatus
.empty() ) {
1009 //wxASSERT(srcstatus.size() == GetPartCount());
1010 if (srcstatus
.size() != GetPartCount()) {
1013 for (int x
= 0; x
< GetPartCount(); x
++ ) {
1014 if ( srcstatus
.get(x
) ) {
1015 // this client has at least one chunk
1021 // This client doesn't support upload chunk status.
1022 // So just send it and hope for the best.
1030 if(byUsedVersion
>= 3) {
1031 dwID
= cur_src
->GetUserIDHybrid();
1033 dwID
= cur_src
->GetIP();
1035 data
.WriteUInt32(dwID
);
1036 data
.WriteUInt16(cur_src
->GetUserPort());
1037 data
.WriteUInt32(cur_src
->GetServerIP());
1038 data
.WriteUInt16(cur_src
->GetServerPort());
1040 if (byUsedVersion
>= 2) {
1041 data
.WriteHash(cur_src
->GetUserHash());
1044 if (byUsedVersion
>= 4){
1045 // CryptSettings - SourceExchange V4
1047 // 1 CryptLayer Required
1048 // 1 CryptLayer Requested
1049 // 1 CryptLayer Supported
1050 const uint8 uSupportsCryptLayer
= cur_src
->SupportsCryptLayer() ? 1 : 0;
1051 const uint8 uRequestsCryptLayer
= cur_src
->RequestsCryptLayer() ? 1 : 0;
1052 const uint8 uRequiresCryptLayer
= cur_src
->RequiresCryptLayer() ? 1 : 0;
1053 const uint8 byCryptOptions
= (uRequiresCryptLayer
<< 2) | (uRequestsCryptLayer
<< 1) | (uSupportsCryptLayer
<< 0);
1054 data
.WriteUInt8(byCryptOptions
);
1067 data
.Seek(bIsSX2Packet
? 17 : 16, wxFromStart
);
1068 data
.WriteUInt16(nCount
);
1070 CPacket
* result
= new CPacket(data
, OP_EMULEPROT
, bIsSX2Packet
? OP_ANSWERSOURCES2
: OP_ANSWERSOURCES
);
1072 if ( result
->GetPacketSize() > 354 ) {
1073 result
->PackPacket();
1080 void CKnownFile::CreateOfferedFilePacket(
1083 CUpDownClient
*pClient
) {
1085 // This function is used for offering files to the local server and for sending
1086 // shared files to some other client. In each case we send our IP+Port only, if
1087 // we have a HighID.
1089 wxASSERT(!(pClient
&& pServer
));
1091 SetPublishedED2K(true);
1092 files
->WriteHash(GetFileHash());
1094 uint32 nClientID
= 0;
1095 uint16 nClientPort
= 0;
1098 if (pServer
->GetTCPFlags() & SRV_TCPFLG_COMPRESSION
) {
1099 #define FILE_COMPLETE_ID 0xfbfbfbfb
1100 #define FILE_COMPLETE_PORT 0xfbfb
1101 #define FILE_INCOMPLETE_ID 0xfcfcfcfc
1102 #define FILE_INCOMPLETE_PORT 0xfcfc
1103 // complete file: ip 251.251.251 (0xfbfbfbfb) port 0xfbfb
1104 // incomplete file: op 252.252.252 (0xfcfcfcfc) port 0xfcfc
1105 if (GetStatus() == PS_COMPLETE
) {
1106 nClientID
= FILE_COMPLETE_ID
;
1107 nClientPort
= FILE_COMPLETE_PORT
;
1109 nClientID
= FILE_INCOMPLETE_ID
;
1110 nClientPort
= FILE_INCOMPLETE_PORT
;
1113 if (theApp
->IsConnectedED2K() && !::IsLowID(theApp
->GetED2KID())){
1114 nClientID
= theApp
->GetID();
1115 nClientPort
= thePrefs::GetPort();
1119 // Do not merge this with the above case - this one
1120 // also checks Kad status.
1121 if (theApp
->IsConnected() && !theApp
->IsFirewalled()) {
1122 nClientID
= theApp
->GetID();
1123 nClientPort
= thePrefs::GetPort();
1127 files
->WriteUInt32(nClientID
);
1128 files
->WriteUInt16(nClientPort
);
1132 // The printable filename is used because it's destined for another user.
1133 tags
.push_back(new CTagString(FT_FILENAME
, GetFileName().GetPrintable()));
1135 if (pClient
&& pClient
->GetVBTTags()) {
1136 tags
.push_back(new CTagVarInt(FT_FILESIZE
, GetFileSize()));
1138 if (!IsLargeFile()){
1139 tags
.push_back(new CTagInt32(FT_FILESIZE
, GetFileSize()));
1142 // we send 2*32 bit tags to servers, but a real 64 bit tag to other clients.
1144 if (!pServer
->SupportsLargeFilesTCP()){
1146 tags
.push_back(new CTagInt32(FT_FILESIZE
, 0));
1148 tags
.push_back(new CTagInt32(FT_FILESIZE
, (uint32
)GetFileSize()));
1149 tags
.push_back(new CTagInt32(FT_FILESIZE_HI
, (uint32
)(GetFileSize() >> 32)));
1152 if (!pClient
->SupportsLargeFiles()) {
1154 tags
.push_back(new CTagInt32(FT_FILESIZE
, 0));
1156 tags
.push_back(new CTagInt64(FT_FILESIZE
, GetFileSize()));
1162 if (GetFileRating()) {
1163 tags
.push_back(new CTagVarInt(FT_FILERATING
, GetFileRating(), (pClient
&& pClient
->GetVBTTags()) ? 0 : 32));
1166 // NOTE: Archives and CD-Images are published+searched with file type "Pro"
1167 bool bAddedFileType
= false;
1168 if (pServer
&& (pServer
->GetTCPFlags() & SRV_TCPFLG_TYPETAGINTEGER
)) {
1169 // Send integer file type tags to newer servers
1170 EED2KFileType eFileType
= GetED2KFileTypeSearchID(GetED2KFileTypeID(GetFileName()));
1171 if (eFileType
>= ED2KFT_AUDIO
&& eFileType
<= ED2KFT_CDIMAGE
) {
1172 tags
.push_back(new CTagInt32(FT_FILETYPE
, eFileType
));
1173 bAddedFileType
= true;
1176 if (!bAddedFileType
) {
1177 // Send string file type tags to:
1178 // - newer servers, in case there is no integer type available for the file type (e.g. emulecollection)
1181 wxString
strED2KFileType(GetED2KFileTypeSearchTerm(GetED2KFileTypeID(GetFileName())));
1182 if (!strED2KFileType
.IsEmpty()) {
1183 tags
.push_back(new CTagString(FT_FILETYPE
, strED2KFileType
));
1187 // There, we could add MetaData info, if we ever get to have that.
1189 EUtf8Str eStrEncode
;
1191 bool unicode_support
=
1192 // eservers that support UNICODE.
1193 (pServer
&& (pServer
->GetUnicodeSupport()))
1195 // clients that support unicode
1196 (pClient
&& pClient
->GetUnicodeSupport());
1197 eStrEncode
= unicode_support
? utf8strRaw
: utf8strNone
;
1199 files
->WriteUInt32(tags
.size());
1201 // Sadly, eMule doesn't use a MISCOPTIONS flag on hello packet for this, so we
1202 // have to identify the support for new tags by version.
1204 // eMule client > 0.42f
1205 (pClient
&& pClient
->IsEmuleClient() && pClient
->GetVersion() >= MAKE_CLIENT_VERSION(0,42,7))
1207 // aMule >= 2.0.0rc8. Sadly, there's no way to check the rcN number, so I checked
1208 // the rc8 changelog. On rc8 OSInfo was introduced, so...
1209 (pClient
&& pClient
->GetClientSoft() == SO_AMULE
&& !pClient
->GetClientOSInfo().IsEmpty())
1211 // eservers use a flag for this, at least.
1212 (pServer
&& (pServer
->GetTCPFlags() & SRV_TCPFLG_NEWTAGS
));
1214 for (TagPtrList::iterator it
= tags
.begin(); it
!= tags
.end(); ++it
) {
1217 pTag
->WriteNewEd2kTag(files
, eStrEncode
);
1219 pTag
->WriteTagToFile(files
, eStrEncode
);
1226 // Updates priority of file if autopriority is activated
1227 void CKnownFile::UpdateAutoUpPriority()
1229 if (IsAutoUpPriority()) {
1230 uint32 queued
= GetQueuedCount();
1231 uint8 priority
= PR_NORMAL
;
1235 } else if (queued
> 1) {
1236 priority
= PR_NORMAL
;
1241 if (GetUpPriority() != priority
) {
1242 SetUpPriority(priority
, false);
1243 Notify_SharedFilesUpdateItem(this);
1248 void CKnownFile::SetFileCommentRating(const wxString
& strNewComment
, int8 iNewRating
)
1250 if (m_strComment
!= strNewComment
|| m_iRating
!= iNewRating
) {
1251 SetLastPublishTimeKadNotes(0);
1252 wxString strCfgPath
= wxT("/") + m_abyFileHash
.Encode() + wxT("/");
1254 wxConfigBase
* cfg
= wxConfigBase::Get();
1255 if (strNewComment
.IsEmpty() && iNewRating
== 0) {
1256 cfg
->DeleteGroup(strCfgPath
);
1258 cfg
->Write( strCfgPath
+ wxT("Comment"), strNewComment
);
1259 cfg
->Write( strCfgPath
+ wxT("Rate"), (int)iNewRating
);
1262 m_strComment
= strNewComment
;
1263 m_iRating
= iNewRating
;
1265 SourceSet::iterator it
= m_ClientUploadList
.begin();
1266 for ( ; it
!= m_ClientUploadList
.end(); ++it
) {
1267 it
->SetCommentDirty();
1273 void CKnownFile::SetUpPriority(uint8 iNewUpPriority
, bool m_bsave
){
1274 m_iUpPriority
= iNewUpPriority
;
1275 if( IsPartFile() && m_bsave
) {
1276 static_cast<CPartFile
*>(this)->SavePartFile();
1280 void CKnownFile::SetPublishedED2K(bool val
){
1281 m_PublishedED2K
= val
;
1282 Notify_SharedFilesUpdateItem(this);
1285 bool CKnownFile::PublishNotes()
1287 if(m_lastPublishTimeKadNotes
> (uint32
)time(NULL
)) {
1291 if(!GetFileComment().IsEmpty()) {
1292 m_lastPublishTimeKadNotes
= (uint32
)time(NULL
)+KADEMLIAREPUBLISHTIMEN
;
1296 if(GetFileRating() != 0) {
1297 m_lastPublishTimeKadNotes
= (uint32
)time(NULL
)+KADEMLIAREPUBLISHTIMEN
;
1304 bool CKnownFile::PublishSrc()
1306 uint32 lastBuddyIP
= 0;
1308 if( theApp
->IsFirewalled() ) {
1309 CUpDownClient
* buddy
= theApp
->clientlist
->GetBuddy();
1311 lastBuddyIP
= theApp
->clientlist
->GetBuddy()->GetIP();
1312 if( lastBuddyIP
!= m_lastBuddyIP
) {
1313 SetLastPublishTimeKadSrc( (uint32
)time(NULL
)+KADEMLIAREPUBLISHTIMES
, lastBuddyIP
);
1321 if(m_lastPublishTimeKadSrc
> (uint32
)time(NULL
)) {
1325 SetLastPublishTimeKadSrc((uint32
)time(NULL
)+KADEMLIAREPUBLISHTIMES
,lastBuddyIP
);
1330 void CKnownFile::UpdatePartsInfo()
1333 uint16 partcount
= GetPartCount();
1334 bool flag
= (time(NULL
) - m_nCompleteSourcesTime
> 0);
1336 // Ensure the frequency-list is ready
1337 if ( m_AvailPartFrequency
.size() != GetPartCount() ) {
1338 m_AvailPartFrequency
.clear();
1339 m_AvailPartFrequency
.insert(m_AvailPartFrequency
.begin(), GetPartCount(), 0);
1343 ArrayOfUInts16 count
;
1344 count
.reserve(m_ClientUploadList
.size());
1346 SourceSet::iterator it
= m_ClientUploadList
.begin();
1347 for ( ; it
!= m_ClientUploadList
.end(); ++it
) {
1348 CUpDownClient
* client
= it
->GetClient();
1349 if ( !client
->GetUpPartStatus().empty() && client
->GetUpPartCount() == partcount
) {
1350 count
.push_back(client
->GetUpCompleteSourcesCount());
1354 m_nCompleteSourcesCount
= m_nCompleteSourcesCountLo
= m_nCompleteSourcesCountHi
= 0;
1356 if( partcount
> 0) {
1357 m_nCompleteSourcesCount
= m_AvailPartFrequency
[0];
1359 for (uint16 i
= 1; i
< partcount
; ++i
) {
1360 if( m_nCompleteSourcesCount
> m_AvailPartFrequency
[i
]) {
1361 m_nCompleteSourcesCount
= m_AvailPartFrequency
[i
];
1364 count
.push_back(m_nCompleteSourcesCount
);
1366 int32 n
= count
.size();
1368 std::sort(count
.begin(), count
.end(), std::less
<uint16
>());
1371 int i
= n
>> 1; // (n / 2)
1372 int j
= (n
* 3) >> 2; // (n * 3) / 4
1373 int k
= (n
* 7) >> 3; // (n * 7) / 8
1375 // For complete files, trust the people your uploading to more...
1377 // For low guess and normal guess count
1378 // - If we see more sources then the guessed low and
1379 // normal, use what we see.
1380 // - If we see less sources then the guessed low,
1381 // adjust network accounts for 100%, we account for
1382 // 0% with what we see and make sure we are still
1383 // above the normal.
1385 // Adjust 100% network and 0% what we see.
1387 if ( count
[i
] < m_nCompleteSourcesCount
) {
1388 m_nCompleteSourcesCountLo
= m_nCompleteSourcesCount
;
1390 m_nCompleteSourcesCountLo
= count
[i
];
1392 m_nCompleteSourcesCount
= m_nCompleteSourcesCountLo
;
1393 m_nCompleteSourcesCountHi
= count
[j
];
1394 if( m_nCompleteSourcesCountHi
< m_nCompleteSourcesCount
) {
1395 m_nCompleteSourcesCountHi
= m_nCompleteSourcesCount
;
1402 // Adjust network accounts for 100%, we account for
1403 // 0% with what we see and make sure we are still above the low.
1405 // Adjust network accounts for 100%, we account for 0%
1406 // with what we see and make sure we are still above the normal.
1408 m_nCompleteSourcesCountLo
= m_nCompleteSourcesCount
;
1409 m_nCompleteSourcesCount
= count
[j
];
1410 if( m_nCompleteSourcesCount
< m_nCompleteSourcesCountLo
) {
1411 m_nCompleteSourcesCount
= m_nCompleteSourcesCountLo
;
1413 m_nCompleteSourcesCountHi
= count
[k
];
1414 if( m_nCompleteSourcesCountHi
< m_nCompleteSourcesCount
) {
1415 m_nCompleteSourcesCountHi
= m_nCompleteSourcesCount
;
1419 m_nCompleteSourcesTime
= time(NULL
) + (60);
1422 Notify_SharedFilesUpdateItem(this);
1426 void CKnownFile::UpdateUpPartsFrequency( CUpDownClient
* client
, bool increment
)
1428 if ( m_AvailPartFrequency
.size() != GetPartCount() ) {
1429 m_AvailPartFrequency
.clear();
1430 m_AvailPartFrequency
.insert(m_AvailPartFrequency
.begin(), GetPartCount(), 0);
1436 const BitVector
& freq
= client
->GetUpPartStatus();
1437 unsigned int size
= freq
.size();
1438 if ( size
!= m_AvailPartFrequency
.size() ) {
1443 for ( unsigned int i
= 0; i
< size
; ++i
) {
1444 if ( freq
.get(i
) ) {
1445 m_AvailPartFrequency
[i
]++;
1449 for ( unsigned int i
= 0; i
< size
; ++i
) {
1450 if ( freq
.get(i
) ) {
1451 m_AvailPartFrequency
[i
]--;
1457 void CKnownFile::ClearPriority() {
1458 if ( !m_bAutoUpPriority
) return;
1459 m_iUpPriority
= ( m_bAutoUpPriority
) ? PR_HIGH
: PR_NORMAL
;
1460 UpdateAutoUpPriority();
1463 static void GuessAndRemoveExt(CPath
& name
)
1465 wxString ext
= name
.GetExt();
1467 // Remove common two-part extensions, such as "tar.gz"
1468 if (ext
== wxT("gz") || ext
== wxT("bz2")) {
1469 name
= name
.RemoveExt();
1470 if (name
.GetExt() == wxT("tar")) {
1471 name
= name
.RemoveExt();
1473 // might be an extension if length == 3
1474 // and also remove some common non-three-character extensions
1475 } else if (ext
.Length() == 3 ||
1478 ext
== wxT("jpeg") ||
1481 name
= name
.RemoveExt();
1485 void CKnownFile::SetFileName(const CPath
& filename
)
1487 CAbstractFile::SetFileName(filename
);
1489 // Don't publish extension. That'd kill the node indexing e.g. "avi".
1490 CPath tmpName
= GetFileName();
1491 GuessAndRemoveExt(tmpName
);
1492 Kademlia::CSearchManager::GetWords(tmpName
.GetPrintable(), &wordlist
);
1495 #endif // CLIENT_GUI
1497 //For File Comment //
1498 void CKnownFile::LoadComment() const
1501 wxString strCfgPath
= wxT("/") + m_abyFileHash
.Encode() + wxT("/");
1503 wxConfigBase
* cfg
= wxConfigBase::Get();
1505 m_strComment
= cfg
->Read( strCfgPath
+ wxT("Comment"), wxEmptyString
);
1506 m_iRating
= cfg
->Read( strCfgPath
+ wxT("Rate"), 0l);
1509 m_bCommentLoaded
= true;
1513 wxString
CKnownFile::GetAICHMasterHash() const
1516 return m_AICHMasterHash
;
1518 if (HasProperAICHHashSet()) {
1519 return m_pAICHHashSet
->GetMasterHash().GetString();
1522 return wxEmptyString
;
1527 bool CKnownFile::HasProperAICHHashSet() const
1530 return m_AICHMasterHash
.Length() != 0;
1532 return m_pAICHHashSet
->HasValidMasterHash() &&
1533 (m_pAICHHashSet
->GetStatus() == AICH_HASHSETCOMPLETE
||
1534 m_pAICHHashSet
->GetStatus() == AICH_VERIFIED
);
1538 wxString
CKnownFile::GetFeedback() const
1540 return wxString(_("File name")) + wxT(": ") + GetFileName().GetPrintable() + wxT("\n")
1541 + _("File size") + wxT(": ") + CastItoXBytes(GetFileSize()) + wxT("\n")
1542 + _("Share ratio") + CFormat(wxT(": %.2f%%\n")) % (((double)statistic
.GetAllTimeTransferred() / (double)GetFileSize()) * 100.0)
1543 + _("Uploaded") + wxT(": ") + CastItoXBytes(statistic
.GetTransferred()) + wxT(" (") + CastItoXBytes(statistic
.GetAllTimeTransferred()) + wxT(")\n")
1544 + _("Requested") + CFormat(wxT(": %u (%u)\n")) % statistic
.GetRequests() % statistic
.GetAllTimeRequests()
1545 + _("Accepted") + CFormat(wxT(": %u (%u)\n")) % statistic
.GetAccepts() % statistic
.GetAllTimeAccepts()
1546 + _("On Queue") + CFormat(wxT(": %u\n")) % GetQueuedCount()
1547 + _("Complete sources") + CFormat(wxT(": %u\n")) % m_nCompleteSourcesCount
;
1550 // File_checked_for_headers