src/KnownFileList.cpp

   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
  27 #include "KnownFileList.h"      // Interface declarations
  28
  29 #include <common/DataFileVersion.h>
  30
  31 #include <memory>               // Do_not_auto_remove (lionel's Mac, 10.3)
  32 #include "PartFile.h"           // Needed for CPartFile
  33 #include "amule.h"
  34 #include "Logger.h"
  35 #include "MemFile.h"
  36 #include "ScopedPtr.h"
  37 #include "SearchList.h"         // Needed for UpdateSearchFileByHash
  38 #include <common/Format.h>
  39
  40
  41 // This function is inlined for performance
  42 inline bool CKnownFileList::KnownFileMatches(
  43         CKnownFile *knownFile,
  44         const CPath& filename,
  45         uint32 in_date,
  46         uint64 in_size) const
  47 {
  48         return
  49                 (knownFile->GetLastChangeDatetime() == (time_t)in_date) &&
  50                 (knownFile->GetFileSize() == in_size) &&
  51                 (knownFile->GetFileName() == filename);
  52 }
  53
  54
  55 CKnownFileList::CKnownFileList()
  56 {
  57         accepted = 0;
  58         requested = 0;
  59         transferred = 0;
  60         m_filename = wxT("known.met");
  61         m_knownSizeMap = NULL;
  62         m_duplicateSizeMap = NULL;
  63         Init();
  64 }
  65
  66
  67 CKnownFileList::~CKnownFileList()
  68 {
  69         Clear();
  70 }
  71
  72
  73 bool CKnownFileList::Init()
  74 {
  75         CFile file;
  76
  77         CPath fullpath = CPath(theApp->ConfigDir + m_filename);
  78         if (!fullpath.FileExists()) {
  79                 // This is perfectly normal. The file was probably either
  80                 // deleted, or this is the first time running aMule.
  81                 return false;
  82         }
  83
  84         if (!file.Open(fullpath)) {
  85                 AddLogLineC(CFormat(_("WARNING: %s cannot be opened.")) % m_filename);
  86                 return false;
  87         }
  88
  89         try {
  90                 uint8 version = file.ReadUInt8();
  91                 if ((version != MET_HEADER) && (version != MET_HEADER_WITH_LARGEFILES)) {
  92                         AddLogLineC(_("WARNING: Known file list corrupted, contains invalid header."));
  93                         return false;
  94                 }
  95
  96                 wxMutexLocker sLock(list_mut);
  97                 uint32 RecordsNumber = file.ReadUInt32();
  98                 AddDebugLogLineN(logKnownFiles, CFormat(wxT("Reading %i known files from file format 0x%2.2x."))
  99                         % RecordsNumber % version);
 100                 for (uint32 i = 0; i < RecordsNumber; i++) {
 101                         CScopedPtr<CKnownFile> record;
 102                         if (record->LoadFromFile(&file)) {
 103                                 AddDebugLogLineN(logKnownFiles,
 104                                         CFormat(wxT("Known file read: %s")) % record->GetFileName());
 105                                 Append(record.release());
 106                         } else {
 107                                 AddLogLineC(_("Failed to load entry in known file list, file may be corrupt"));
 108                         }
 109                 }
 110                 AddDebugLogLineN(logKnownFiles, wxT("Finished reading known files"));
 111
 112                 return true;
 113         } catch (const CInvalidPacket& e) {
 114                 AddLogLineC(_("Invalid entry in known file list, file may be corrupt: ") + e.what());
 115         } catch (const CSafeIOException& e) {
 116                 AddLogLineC(CFormat(_("IO error while reading %s file: %s")) % m_filename % e.what());
 117         }
 118
 119         return false;
 120 }
 121
 122
 123 void CKnownFileList::Save()
 124 {
 125         CFile file(theApp->ConfigDir + m_filename, CFile::write);
 126         if (!file.IsOpened()) {
 127                 return;
 128         }
 129
 130         wxMutexLocker sLock(list_mut);
 131
 132         try {
 133                 // Kry - This is the version, but we don't know it till
 134                 // we know if any largefile is saved. This allows the list
 135                 // to be compatible with previous versions.
 136                 bool bContainsAnyLargeFiles = false;
 137                 file.WriteUInt8(0);
 138
 139                 file.WriteUInt32(m_knownFileMap.size() + m_duplicateFileList.size());
 140
 141                 // Duplicates handling. Duplicates needs to be saved first,
 142                 // since it is the last entry that gets used.
 143                 KnownFileList::iterator itDup = m_duplicateFileList.begin();
 144                 for ( ; itDup != m_duplicateFileList.end(); ++itDup ) {
 145                         (*itDup)->WriteToFile(&file);
 146                         if ((*itDup)->IsLargeFile()) {
 147                                 bContainsAnyLargeFiles = true;
 148                         }
 149                 }
 150
 151                 CKnownFileMap::iterator it = m_knownFileMap.begin();
 152                 for (; it != m_knownFileMap.end(); ++it) {
 153                         it->second->WriteToFile(&file);
 154                         if (it->second->IsLargeFile()) {
 155                                 bContainsAnyLargeFiles = true;
 156                         }
 157                 }
 158
 159                 file.Seek(0);
 160                 file.WriteUInt8(bContainsAnyLargeFiles ? MET_HEADER_WITH_LARGEFILES : MET_HEADER);
 161         } catch (const CIOFailureException& e) {
 162                 AddLogLineC(CFormat(_("Error while saving %s file: %s")) % m_filename % e.what());
 163         }
 164 }
 165
 166
 167 void CKnownFileList::Clear()
 168 {
 169         wxMutexLocker sLock(list_mut);
 170
 171         DeleteContents(m_knownFileMap);
 172         DeleteContents(m_duplicateFileList);
 173         ReleaseIndex();
 174 }
 175
 176
 177 CKnownFile* CKnownFileList::FindKnownFile(
 178         const CPath& filename,
 179         time_t in_date,
 180         uint64 in_size)
 181 {
 182         wxMutexLocker sLock(list_mut);
 183
 184         if (m_knownSizeMap) {
 185                 std::pair<KnownFileSizeMap::const_iterator, KnownFileSizeMap::const_iterator> p;
 186                 p = m_knownSizeMap->equal_range((uint32) in_size);
 187                 for (KnownFileSizeMap::const_iterator it = p.first; it != p.second; it++) {
 188                         CKnownFile *cur_file = it->second;
 189                         if (KnownFileMatches(cur_file, filename, in_date, in_size)) {
 190                                 return cur_file;
 191                         }
 192                 }
 193         } else {
 194                 for (CKnownFileMap::const_iterator it = m_knownFileMap.begin();
 195                          it != m_knownFileMap.end(); ++it) {
 196                         CKnownFile *cur_file = it->second;
 197                         if (KnownFileMatches(cur_file, filename, in_date, in_size)) {
 198                                 return cur_file;
 199                         }
 200                 }
 201         }
 202
 203         return IsOnDuplicates(filename, in_date, in_size);
 204 }
 205
 206
 207 CKnownFile *CKnownFileList::IsOnDuplicates(
 208         const CPath& filename,
 209         uint32 in_date,
 210         uint64 in_size) const
 211 {
 212         if (m_duplicateSizeMap) {
 213                 std::pair<KnownFileSizeMap::const_iterator, KnownFileSizeMap::const_iterator> p;
 214                 p = m_duplicateSizeMap->equal_range((uint32) in_size);
 215                 for (KnownFileSizeMap::const_iterator it = p.first; it != p.second; it++) {
 216                         CKnownFile *cur_file = it->second;
 217                         if (KnownFileMatches(cur_file, filename, in_date, in_size)) {
 218                                 return cur_file;
 219                         }
 220                 }
 221         } else {
 222                 for (KnownFileList::const_iterator it = m_duplicateFileList.begin();
 223                          it != m_duplicateFileList.end(); ++it) {
 224                         CKnownFile *cur_file = *it;
 225                         if (KnownFileMatches(cur_file, filename, in_date, in_size)) {
 226                                 return cur_file;
 227                         }
 228                 }
 229         }
 230         return NULL;
 231 }
 232
 233
 234 CKnownFile* CKnownFileList::FindKnownFileByID(const CMD4Hash& hash)
 235 {
 236         wxMutexLocker sLock(list_mut);
 237
 238         if (!hash.IsEmpty()) {
 239                 if (m_knownFileMap.find(hash) != m_knownFileMap.end()) {
 240                         return m_knownFileMap[hash];
 241                 } else {
 242                         return NULL;
 243                 }
 244         }
 245         return NULL;
 246
 247 }
 248
 249
 250 bool CKnownFileList::SafeAddKFile(CKnownFile* toadd, bool afterHashing)
 251 {
 252         bool ret;
 253         {
 254                 wxMutexLocker sLock(list_mut);
 255                 ret = Append(toadd, afterHashing);
 256         }
 257         if (ret) {
 258                 theApp->searchlist->UpdateSearchFileByHash(toadd->GetFileHash());
 259         }
 260         return ret;
 261 }
 262
 263
 264 bool CKnownFileList::Append(CKnownFile *Record, bool afterHashing)
 265 {
 266         if (Record->GetFileSize() > 0) {
 267                 const CMD4Hash& tkey = Record->GetFileHash();
 268                 CKnownFileMap::iterator it = m_knownFileMap.find(tkey);
 269                 if (it == m_knownFileMap.end()) {
 270                         m_knownFileMap[tkey] = Record;
 271                         return true;
 272                 } else {
 273                         CKnownFile *existing = it->second;
 274                         time_t in_date = existing->GetLastChangeDatetime();
 275                         uint64 in_size = existing->GetFileSize();
 276                         CPath filename = existing->GetFileName();
 277                         if (KnownFileMatches(Record, filename, in_date, in_size) ||
 278                             IsOnDuplicates(filename, in_date, in_size)) {
 279                                 // The file is already on the list, ignore it.
 280                                 return false;
 281                         } else {
 282                                 if (afterHashing && in_size == Record->GetFileSize()) {
 283                                         // We just hashed a "new" shared file and find it's already known under a different name or date.
 284                                         // Guess what - it was probably renamed or touched.
 285                                         // So copy over all properties from the existing known file and just keep name/date.
 286                                         time_t newDate = Record->GetLastChangeDatetime();
 287                                         CPath newName = Record->GetFileName();
 288                                         CMemFile f;
 289                                         existing->WriteToFile(&f);
 290                                         f.Reset();
 291                                         Record->LoadFromFile(&f);
 292                                         Record->SetLastChangeDatetime(newDate);
 293                                         Record->SetFileName(newName);
 294                                 }
 295                                 // The file is a duplicated hash. Add THE OLD ONE to the duplicates list.
 296                                 // (This is used when reading the known file list where the duplicates are stored in front.)
 297                                 m_duplicateFileList.push_back(existing);
 298                                 if (theApp->sharedfiles) {
 299                                         // Removing the old kad keywords created with the old filename
 300                                         theApp->sharedfiles->RemoveKeywords(existing);
 301                                 }
 302                                 m_knownFileMap[tkey] = Record;
 303                                 return true;
 304                         }
 305                 }
 306         } else {
 307                 AddDebugLogLineN(logGeneral,
 308                         CFormat(wxT("%s is 0-size, not added")) %
 309                         Record->GetFileName());
 310
 311                 return false;
 312         }
 313 }
 314
 315 // Make an index by size to speed up FindKnownFile
 316 // Size modulo 2^32 is enough here
 317 void CKnownFileList::PrepareIndex()
 318 {
 319         ReleaseIndex();
 320         m_knownSizeMap = new KnownFileSizeMap;
 321         for (CKnownFileMap::const_iterator it = m_knownFileMap.begin(); it != m_knownFileMap.end(); it++) {
 322                 m_knownSizeMap->insert(std::pair<uint32, CKnownFile*>((uint32) it->second->GetFileSize(), it->second));
 323         }
 324         m_duplicateSizeMap = new KnownFileSizeMap;
 325         for (KnownFileList::const_iterator it = m_duplicateFileList.begin(); it != m_duplicateFileList.end(); it++) {
 326                 m_duplicateSizeMap->insert(std::pair<uint32, CKnownFile*>((uint32) (*it)->GetFileSize(), *it));
 327         }
 328 }
 329
 330
 331 void CKnownFileList::ReleaseIndex()
 332 {
 333         delete m_knownSizeMap;
 334         delete m_duplicateSizeMap;
 335         m_knownSizeMap = NULL;
 336         m_duplicateSizeMap = NULL;
 337 }
 338
 339 // File_checked_for_headers