src/ThreadTasks.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2006-2011 Mikkel Schubert ( xaignar@amule.org / http:://www.amule.org )
   5 // Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   6 // Copyright (c) 2002-2011 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   7 //
   8 // Any parts of this program derived from the xMule, lMule or eMule project,
   9 // or contributed by third-party developers are copyrighted by their
  10 // respective authors.
  11 //
  12 // This program is free software; you can redistribute it and/or modify
  13 // it under the terms of the GNU General Public License as published by
  14 // the Free Software Foundation; either version 2 of the License, or
  15 // (at your option) any later version.
  16 //
  17 // This program is distributed in the hope that it will be useful,
  18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 // GNU General Public License for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License
  23 // along with this program; if not, write to the Free Software
  24 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  25 //
  26
  27
  28 #include <wx/app.h>                     // Needed for wxTheApp
  29
  30 #include "ThreadTasks.h"                // Interface declarations
  31 #include "PartFile.h"                   // Needed for CPartFile
  32 #include "Logger.h"                     // Needed for Add(Debug)LogLine{C,N}
  33 #include <common/Format.h>              // Needed for CFormat
  34 #include "amule.h"                      // Needed for theApp
  35 #include "KnownFileList.h"              // Needed for theApp->knownfiles
  36 #include "Preferences.h"                // Needed for thePrefs
  37 #include "ScopedPtr.h"                  // Needed for CScopedPtr and CScopedArray
  38 #include "PlatformSpecific.h"           // Needed for CanFSHandleSpecialChars
  39
  40 #ifdef HAVE_CONFIG_H
  41 #       include "config.h"
  42 #endif
  43
  44 //! This hash represents the value for an empty MD4 hashing
  45 const byte g_emptyMD4Hash[16] = {
  46         0x31, 0xD6, 0xCF, 0xE0, 0xD1, 0x6A, 0xE9, 0x31,
  47         0xB7, 0x3C, 0x59, 0xD7, 0xE0, 0xC0, 0x89, 0xC0 };
  48
  49
  50 ////////////////////////////////////////////////////////////
  51 // CHashingTask
  52
  53 CHashingTask::CHashingTask(const CPath& path, const CPath& filename, const CPartFile* part)
  54         // GetPrintable is used to improve the readability of the log.
  55         : CThreadTask(wxT("Hashing"), path.JoinPaths(filename).GetPrintable(), (part ? ETP_High : ETP_Normal)),
  56           m_path(path),
  57           m_filename(filename),
  58           m_toHash((EHashes)(EH_MD4 | EH_AICH)),
  59           m_owner(part)
  60 {
  61         // We can only create the AICH hashset if the file is a knownfile or
  62         // if the partfile is complete, since the MD4 hashset is checked first,
  63         // so that the AICH hashset only gets assigned if the MD4 hashset
  64         // matches what we expected. Due to the rareity of post-completion
  65         // corruptions, this gives us a nice speedup in most cases.
  66         if (part && !part->GetGapList().empty()) {
  67                 m_toHash = EH_MD4;
  68         }
  69 }
  70
  71
  72 CHashingTask::CHashingTask(const CKnownFile* toAICHHash)
  73         // GetPrintable is used to improve the readability of the log.
  74         : CThreadTask(wxT("AICH Hashing"), toAICHHash->GetFilePath().JoinPaths(toAICHHash->GetFileName()).GetPrintable(), ETP_Low),
  75           m_path(toAICHHash->GetFilePath()),
  76           m_filename(toAICHHash->GetFileName()),
  77           m_toHash(EH_AICH),
  78           m_owner(toAICHHash)
  79 {
  80 }
  81
  82
  83 void CHashingTask::Entry()
  84 {
  85         CFileAutoClose file;
  86
  87         CPath fullPath = m_path.JoinPaths(m_filename);
  88         if (!file.Open(fullPath, CFile::read)) {
  89                 AddDebugLogLineC(logHasher,
  90                         CFormat(wxT("Warning, failed to open file, skipping: %s")) % fullPath);
  91                 return;
  92         }
  93
  94         uint64 fileLength = 0;
  95         try {
  96                 fileLength = file.GetLength();
  97         } catch (const CIOFailureException&) {
  98                 AddDebugLogLineC(logHasher,
  99                         CFormat(wxT("Warning, failed to retrieve file-length, skipping: %s")) % fullPath);
 100                 return;
 101         }
 102
 103         if (fileLength > MAX_FILE_SIZE) {
 104                 AddDebugLogLineC(logHasher,
 105                         CFormat(wxT("Warning, file is larger than supported size, skipping: %s")) % fullPath);
 106                 return;
 107         } else if (fileLength == 0) {
 108                 if (m_owner) {
 109                         // It makes no sense to try to hash empty partfiles ...
 110                         wxFAIL;
 111                 } else {
 112                         // Zero-size partfiles should be hashed, but not zero-sized shared-files.
 113                         AddDebugLogLineC(logHasher,
 114                                 CFormat(wxT("Warning, 0-size file, skipping: %s")) % fullPath);
 115                 }
 116
 117                 return;
 118         }
 119
 120         // For thread-safety, results are passed via a temporary file object.
 121         CScopedPtr<CKnownFile> knownfile;
 122         knownfile->m_filePath = m_path;
 123         knownfile->SetFileName(m_filename);
 124         knownfile->SetFileSize(fileLength);
 125         knownfile->m_lastDateChanged = CPath::GetModificationTime(fullPath);
 126         knownfile->m_AvailPartFrequency.insert(
 127                 knownfile->m_AvailPartFrequency.begin(),
 128                 knownfile->GetPartCount(), 0);
 129
 130         if ((m_toHash & EH_MD4) && (m_toHash & EH_AICH)) {
 131                 knownfile->GetAICHHashset()->FreeHashSet();
 132                 AddDebugLogLineN( logHasher, CFormat(
 133                         wxT("Starting to create MD4 and AICH hash for file: %s")) %
 134                         m_filename );
 135         } else if ((m_toHash & EH_MD4)) {
 136                 AddDebugLogLineN( logHasher, CFormat(
 137                         wxT("Starting to create MD4 hash for file: %s")) % m_filename );
 138         } else if ((m_toHash & EH_AICH)) {
 139                 knownfile->GetAICHHashset()->FreeHashSet();
 140                 AddDebugLogLineN( logHasher, CFormat(
 141                         wxT("Starting to create AICH hash for file: %s")) % m_filename );
 142         } else {
 143                 wxCHECK_RET(0, (CFormat(wxT("No hashes requested for file, skipping: %s"))
 144                         % m_filename).GetString());
 145         }
 146
 147         // This loops creates the part-hashes, loop-de-loop.
 148         try {
 149                 for (uint16 part = 0; part < knownfile->GetPartCount() && !TestDestroy(); part++) {
 150                         SetHashingProgress(part + 1);
 151                         if (CreateNextPartHash(file, part, knownfile.get(), m_toHash) == false) {
 152                                 AddDebugLogLineC(logHasher,
 153                                         CFormat(wxT("Error while hashing file, skipping: %s"))
 154                                                 % m_filename);
 155
 156                                 SetHashingProgress(0);
 157                                 return;
 158                         }
 159                 }
 160         } catch (const CSafeIOException& e) {
 161                 AddDebugLogLineC(logHasher, wxT("IO exception while hashing file: ") + e.what());
 162                 SetHashingProgress(0);
 163                 return;
 164         }
 165         SetHashingProgress(0);
 166
 167         if ((m_toHash & EH_MD4) && !TestDestroy()) {
 168                 // If the file is < PARTSIZE, then the filehash is that one hash,
 169                 // otherwise, the filehash is the hash of the parthashes
 170                 if ( knownfile->m_hashlist.size() == 1 ) {
 171                         knownfile->m_abyFileHash = knownfile->m_hashlist[0];
 172                         knownfile->m_hashlist.clear();
 173                 } else if ( knownfile->m_hashlist.size() ) {
 174                         CMD4Hash hash;
 175                         knownfile->CreateHashFromHashlist(knownfile->m_hashlist, &hash);
 176                         knownfile->m_abyFileHash = hash;
 177                 } else {
 178                         // This should not happen!
 179                         wxFAIL;
 180                 }
 181         }
 182
 183         // Did we create a AICH hashset?
 184         if ((m_toHash & EH_AICH) && !TestDestroy()) {
 185                 CAICHHashSet* AICHHashSet = knownfile->GetAICHHashset();
 186
 187                 AICHHashSet->ReCalculateHash(false);
 188                 if (AICHHashSet->VerifyHashTree(true) ) {
 189                         AICHHashSet->SetStatus(AICH_HASHSETCOMPLETE);
 190                         if (!AICHHashSet->SaveHashSet()) {
 191                                 AddDebugLogLineC( logHasher,
 192                                         CFormat(wxT("Warning, failed to save AICH hashset for file: %s"))
 193                                                 % m_filename );
 194                         }
 195                         // delete hashset now to free memory
 196                         AICHHashSet->FreeHashSet();
 197                 }
 198         }
 199
 200         if ((m_toHash == EH_AICH) && !TestDestroy()) {
 201                 CHashingEvent evt(MULE_EVT_AICH_HASHING, knownfile.release(), m_owner);
 202
 203                 wxPostEvent(wxTheApp, evt);
 204         } else if (!TestDestroy()) {
 205                 CHashingEvent evt(MULE_EVT_HASHING, knownfile.release(), m_owner);
 206
 207                 wxPostEvent(wxTheApp, evt);
 208         }
 209 }
 210
 211
 212 void CHashingTask::SetHashingProgress(uint16 part)
 213 {
 214         if (m_owner) {
 215                 m_owner->SetHashingProgress(part);
 216         }
 217 }
 218
 219
 220 bool CHashingTask::CreateNextPartHash(CFileAutoClose& file, uint16 part, CKnownFile* owner, EHashes toHash)
 221 {
 222         wxCHECK_MSG(!file.Eof(), false, wxT("Unexpected EOF in CreateNextPartHash"));
 223
 224         const uint64 offset = part * PARTSIZE;
 225         // We'll read at most PARTSIZE bytes per cycle
 226         const uint64 partLength = owner->GetPartSize(part);
 227
 228         CMD4Hash hash;
 229         CMD4Hash* md4Hash = ((toHash & EH_MD4) ? &hash : NULL);
 230         CAICHHashTree* aichHash = NULL;
 231
 232         // Setup for AICH hashing
 233         if (toHash & EH_AICH) {
 234                 aichHash = owner->GetAICHHashset()->m_pHashTree.FindHash(offset, partLength);
 235         }
 236
 237         owner->CreateHashFromFile(file, offset, partLength, md4Hash, aichHash);
 238
 239         if (toHash & EH_MD4) {
 240                 // Store the md4 hash
 241                 owner->m_hashlist.push_back(hash);
 242
 243                 // This is because of the ed2k implementation for parts. A 2 * PARTSIZE
 244                 // file i.e. will have 3 parts (see CKnownFile::SetFileSize for comments).
 245                 // So we have to create the hash for the 0-size data, which will be the default
 246                 // md4 hash for null data: 31D6CFE0D16AE931B73C59D7E0C089C0
 247                 if ((partLength == PARTSIZE) && file.Eof()) {
 248                         owner->m_hashlist.push_back(CMD4Hash(g_emptyMD4Hash));
 249                 }
 250         }
 251
 252         return true;
 253 }
 254
 255
 256 void CHashingTask::OnLastTask()
 257 {
 258         if (GetType() == wxT("Hashing")) {
 259                 // To prevent rehashing in case of crashes, we
 260                 // explicity save the list of hashed files here.
 261                 theApp->knownfiles->Save();
 262
 263                 // Make sure the AICH-hashes are up to date.
 264                 CThreadScheduler::AddTask(new CAICHSyncTask());
 265         }
 266 }
 267
 268
 269 ////////////////////////////////////////////////////////////
 270 // CAICHSyncTask
 271
 272 CAICHSyncTask::CAICHSyncTask()
 273         : CThreadTask(wxT("AICH Syncronizing"), wxEmptyString, ETP_Low)
 274 {
 275 }
 276
 277
 278 void CAICHSyncTask::Entry()
 279 {
 280         ConvertToKnown2ToKnown264();
 281
 282         AddDebugLogLineN( logAICHThread, wxT("Syncronization thread started.") );
 283
 284         // We collect all masterhashs which we find in the known2.met and store them in a list
 285         std::list<CAICHHash> hashlist;
 286         const CPath fullpath = CPath(thePrefs::GetConfigDir() + KNOWN2_MET_FILENAME);
 287
 288         CFile file;
 289         if (!fullpath.FileExists()) {
 290                 // File does not exist. Try to create it to see if it can be created at all (and don't start hashing otherwise).
 291                 if (!file.Open(fullpath, CFile::write)) {
 292                         AddDebugLogLineC( logAICHThread, wxT("Error, failed to open 'known2_64.met' file!") );
 293                         return;
 294                 }
 295                 try {
 296                         file.WriteUInt8(KNOWN2_MET_VERSION);
 297                 } catch (const CIOFailureException& e) {
 298                         AddDebugLogLineC(logAICHThread, wxT("IO failure while creating hashlist (Aborting): ") + e.what());
 299                         return;
 300                 }
 301         } else {
 302                 if (!file.Open(fullpath, CFile::read)) {
 303                         AddDebugLogLineC( logAICHThread, wxT("Error, failed to open 'known2_64.met' file!") );
 304                         return;
 305                 }
 306
 307                 uint32 nLastVerifiedPos = 0;
 308                 try {
 309                         if (file.ReadUInt8() != KNOWN2_MET_VERSION) {
 310                                 throw CEOFException(wxT("Invalid met-file header found, removing file."));
 311                         }
 312
 313                         uint64 nExistingSize = file.GetLength();
 314                         while (file.GetPosition() < nExistingSize) {
 315                                 // Read the next hash
 316                                 hashlist.push_back(CAICHHash(&file));
 317
 318                                 uint32 nHashCount = file.ReadUInt32();
 319                                 if (file.GetPosition() + nHashCount * CAICHHash::GetHashSize() > nExistingSize){
 320                                         throw CEOFException(wxT("Hashlist ends past end of file."));
 321                                 }
 322
 323                                 // skip the rest of this hashset
 324                                 nLastVerifiedPos = file.Seek(nHashCount * HASHSIZE, wxFromCurrent);
 325                         }
 326                 } catch (const CEOFException&) {
 327                         AddDebugLogLineC(logAICHThread, wxT("Hashlist corrupted, truncating file."));
 328                         file.Close();
 329                         file.Reopen(CFile::read_write);
 330                         file.SetLength(nLastVerifiedPos);
 331                 } catch (const CIOFailureException& e) {
 332                         AddDebugLogLineC(logAICHThread, wxT("IO failure while reading hashlist (Aborting): ") + e.what());
 333
 334                         return;
 335                 }
 336
 337                 AddDebugLogLineN( logAICHThread, wxT("Masterhashes of known files have been loaded.") );
 338         }
 339
 340         // Now we check that all files which are in the sharedfilelist have a
 341         // corresponding hash in our list. Those how don't are queued for hashing.
 342         theApp->sharedfiles->CheckAICHHashes(hashlist);
 343 }
 344
 345
 346 bool CAICHSyncTask::ConvertToKnown2ToKnown264()
 347 {
 348         // converting known2.met to known2_64.met to support large files
 349         // changing hashcount from uint16 to uint32
 350
 351         const CPath oldfullpath = CPath(thePrefs::GetConfigDir() + OLD_KNOWN2_MET_FILENAME);
 352         const CPath newfullpath = CPath(thePrefs::GetConfigDir() + KNOWN2_MET_FILENAME);
 353
 354         if (newfullpath.FileExists() || !oldfullpath.FileExists()) {
 355                 // In this case, there is nothing that we need to do.
 356                 return false;
 357         }
 358
 359         CFile oldfile;
 360         CFile newfile;
 361
 362         if (!oldfile.Open(oldfullpath, CFile::read)) {
 363                 AddDebugLogLineC(logAICHThread, wxT("Failed to open 'known2.met' file."));
 364
 365                 // else -> known2.met also doesn't exists, so nothing to convert
 366                 return false;
 367         }
 368
 369
 370         if (!newfile.Open(newfullpath, CFile::write_excl)) {
 371                 AddDebugLogLineC(logAICHThread, wxT("Failed to create 'known2_64.met' file."));
 372
 373                 return false;
 374         }
 375
 376         AddLogLineN(CFormat(_("Converting old AICH hashsets in '%s' to 64b in '%s'."))
 377                         % OLD_KNOWN2_MET_FILENAME % KNOWN2_MET_FILENAME);
 378
 379         try {
 380                 newfile.WriteUInt8(KNOWN2_MET_VERSION);
 381
 382                 while (newfile.GetPosition() < oldfile.GetLength()) {
 383                         CAICHHash aichHash(&oldfile);
 384                         uint32 nHashCount = oldfile.ReadUInt16();
 385
 386                         CScopedArray<byte> buffer(nHashCount * CAICHHash::GetHashSize());
 387
 388                         oldfile.Read(buffer.get(), nHashCount * CAICHHash::GetHashSize());
 389                         newfile.Write(aichHash.GetRawHash(), CAICHHash::GetHashSize());
 390                         newfile.WriteUInt32(nHashCount);
 391                         newfile.Write(buffer.get(), nHashCount * CAICHHash::GetHashSize());
 392                 }
 393                 newfile.Flush();
 394         } catch (const CEOFException& e) {
 395                 AddDebugLogLineC(logAICHThread, wxT("Error reading old 'known2.met' file.") + e.what());
 396                 return false;
 397         } catch (const CIOFailureException& e) {
 398                 AddDebugLogLineC(logAICHThread, wxT("IO error while converting 'known2.met' file: ") + e.what());
 399                 return false;
 400         }
 401
 402         // FIXME LARGE FILES (uncomment)
 403         //DeleteFile(oldfullpath);
 404
 405         return true;
 406 }
 407
 408
 409
 410 ////////////////////////////////////////////////////////////
 411 // CCompletionTask
 412
 413
 414 CCompletionTask::CCompletionTask(const CPartFile* file)
 415         // GetPrintable is used to improve the readability of the log.
 416         : CThreadTask(wxT("Completing"), file->GetFullName().GetPrintable(), ETP_High),
 417           m_filename(file->GetFileName()),
 418           m_metPath(file->GetFullName()),
 419           m_category(file->GetCategory()),
 420           m_owner(file),
 421           m_error(false)
 422 {
 423         wxASSERT(m_filename.IsOk());
 424         wxASSERT(m_metPath.IsOk());
 425         wxASSERT(m_owner);
 426 }
 427
 428
 429 void CCompletionTask::Entry()
 430 {
 431         CPath targetPath;
 432
 433         {
 434 #ifndef AMULE_DAEMON
 435                 // Prevent the preference values from changing underneeth us.
 436                 wxMutexGuiLocker guiLock;
 437 #else
 438                 //#warning Thread-safety needed
 439 #endif
 440
 441                 targetPath = theApp->glob_prefs->GetCategory(m_category)->path;
 442                 if (!targetPath.DirExists()) {
 443                         targetPath = thePrefs::GetIncomingDir();
 444                 }
 445         }
 446
 447         CPath dstName = m_filename.Cleanup(true, !PlatformSpecific::CanFSHandleSpecialChars(targetPath));
 448
 449         // Avoid empty filenames ...
 450         if (!dstName.IsOk()) {
 451                 dstName = CPath(wxT("Unknown"));
 452         }
 453
 454         if (m_filename != dstName) {
 455                 AddLogLineC(CFormat(_("WARNING: The filename '%s' is invalid and has been renamed to '%s'.")) % m_filename % dstName);
 456         }
 457
 458         // Avoid saving to an already existing filename
 459         CPath newName = targetPath.JoinPaths(dstName);
 460         for (unsigned count = 0; newName.FileExists(); ++count) {
 461                 wxString postfix = CFormat(wxT("(%u)")) % count;
 462
 463                 newName = targetPath.JoinPaths(dstName.AddPostfix(postfix));
 464         }
 465
 466         if (newName != targetPath.JoinPaths(dstName)) {
 467                 AddLogLineC(CFormat(_("WARNING: The file '%s' already exists, new file renamed to '%s'.")) % dstName % newName.GetFullName());
 468         }
 469
 470         // Move will handle dirs on the same partition, otherwise copy is needed.
 471         CPath partfilename = m_metPath.RemoveExt();
 472         if (!CPath::RenameFile(partfilename, newName)) {
 473                 if (!CPath::CloneFile(partfilename, newName, true)) {
 474                         m_error = true;
 475                         return;
 476                 }
 477
 478                 if (!CPath::RemoveFile(partfilename)) {
 479                         AddDebugLogLineC(logPartFile, CFormat(wxT("WARNING: Could not remove original '%s' after creating backup")) % partfilename);
 480                 }
 481         }
 482
 483         // Removes the various other data-files
 484         const wxChar* otherMetExt[] = { wxT(""), PARTMET_BAK_EXT, wxT(".seeds"), NULL };
 485         for (size_t i = 0; otherMetExt[i]; ++i) {
 486                 CPath toRemove = m_metPath.AppendExt(otherMetExt[i]);
 487
 488                 if (toRemove.FileExists()) {
 489                         if (!CPath::RemoveFile(toRemove)) {
 490                                 AddDebugLogLineC(logPartFile, CFormat(wxT("WARNING: Failed to delete %s")) % toRemove);
 491                         }
 492                 }
 493         }
 494
 495         m_newName = newName;
 496 }
 497
 498
 499 void CCompletionTask::OnExit()
 500 {
 501         // Notify the app that the completion has finished for this file.
 502         CCompletionEvent evt(m_error, m_owner, m_newName);
 503
 504         wxPostEvent(wxTheApp, evt);
 505 }
 506
 507
 508
 509 ////////////////////////////////////////////////////////////
 510 // CAllocateFileTask
 511
 512 #ifdef HAVE_FALLOCATE
 513 #       ifndef _GNU_SOURCE
 514 #               define _GNU_SOURCE
 515 #       endif
 516 #       ifdef HAVE_FCNTL_H
 517 #               include <fcntl.h>
 518 #       endif
 519 #       include <linux/falloc.h>
 520 #elif defined HAVE_SYS_FALLOCATE
 521 #       include <sys/syscall.h>
 522 #       include <sys/types.h>
 523 #       include <unistd.h>
 524 #elif defined HAVE_POSIX_FALLOCATE
 525 #       define _XOPEN_SOURCE 600
 526 #       include <stdlib.h>
 527 #       ifdef HAVE_FCNTL_H
 528 #               include <fcntl.h>
 529 #       endif
 530 #endif
 531 #include <stdlib.h>
 532 #include <errno.h>
 533
 534 CAllocateFileTask::CAllocateFileTask(CPartFile *file, bool pause)
 535         // GetPrintable is used to improve the readability of the log.
 536         : CThreadTask(wxT("Allocating"), file->GetFullName().RemoveExt().GetPrintable(), ETP_High),
 537           m_file(file), m_pause(pause), m_result(ENOSYS)
 538 {
 539         wxASSERT(file != NULL);
 540 }
 541
 542 void CAllocateFileTask::Entry()
 543 {
 544         if (m_file->GetFileSize() == 0) {
 545                 m_result = 0;
 546                 return;
 547         }
 548
 549         uint64_t minFree = thePrefs::IsCheckDiskspaceEnabled() ? thePrefs::GetMinFreeDiskSpace() : 0;
 550         int64_t freeSpace = CPath::GetFreeSpaceAt(thePrefs::GetTempDir());
 551
 552         // Don't even try to allocate, if there's no space to complete the operation.
 553         if (freeSpace != wxInvalidOffset) {
 554                 if ((uint64_t)freeSpace < m_file->GetFileSize() + minFree) {
 555                         m_result = ENOSPC;
 556                         return;
 557                 }
 558         }
 559
 560         CFile file;
 561         file.Open(m_file->GetFullName().RemoveExt(), CFile::read_write);
 562
 563 #ifdef __WINDOWS__
 564         try {
 565                 // File is already created as non-sparse, so we only need to set the length.
 566                 // This will fail to allocate the file e.g. under wine on linux/ext3,
 567                 // but works with NTFS and FAT32.
 568                 file.Seek(m_file->GetFileSize() - 1, wxFromStart);
 569                 file.WriteUInt8(0);
 570                 file.Close();
 571                 m_result = 0;
 572         } catch (const CSafeIOException&) {
 573                 m_result = errno;
 574         }
 575 #else
 576         // Use kernel level routines if possible
 577 #  ifdef HAVE_FALLOCATE
 578         m_result = fallocate(file.fd(), 0, 0, m_file->GetFileSize());
 579 #  elif defined HAVE_SYS_FALLOCATE
 580         m_result = syscall(SYS_fallocate, file.fd(), 0, (loff_t)0, (loff_t)m_file->GetFileSize());
 581         if (m_result == -1) {
 582                 m_result = errno;
 583         }
 584 #  elif defined HAVE_POSIX_FALLOCATE
 585         // otherwise use glibc implementation, if available
 586         m_result = posix_fallocate(file.fd(), 0, m_file->GetFileSize());
 587 #  endif
 588
 589         if (m_result != 0 && m_result != ENOSPC) {
 590                 // If everything else fails, use slow-and-dirty method of allocating the file: write the whole file with zeroes.
 591 #  define BLOCK_SIZE    1048576         /* Write 1 MB blocks */
 592                 void *zero = calloc(1, BLOCK_SIZE);
 593                 if (zero != NULL) {
 594                         try {
 595                                 uint64_t size = m_file->GetFileSize();
 596                                 for (; size >= BLOCK_SIZE; size -= BLOCK_SIZE) {
 597                                         file.Write(zero, BLOCK_SIZE);
 598                                 }
 599                                 if (size > 0) {
 600                                         file.Write(zero, size);
 601                                 }
 602                                 file.Close();
 603                                 m_result = 0;
 604                         } catch (const CSafeIOException&) {
 605                                 m_result = errno;
 606                         }
 607                         free(zero);
 608                 } else {
 609                         m_result = ENOMEM;
 610                 }
 611         }
 612
 613 #endif
 614         if (file.IsOpened()) {
 615                 file.Close();
 616         }
 617 }
 618
 619 void CAllocateFileTask::OnExit()
 620 {
 621         // Notify the app that the preallocation has finished for this file.
 622         CAllocFinishedEvent evt(m_file, m_pause, m_result);
 623
 624         wxPostEvent(wxTheApp, evt);
 625 }
 626
 627
 628
 629 ////////////////////////////////////////////////////////////
 630 // CHashingEvent
 631
 632 DEFINE_LOCAL_EVENT_TYPE(MULE_EVT_HASHING)
 633 DEFINE_LOCAL_EVENT_TYPE(MULE_EVT_AICH_HASHING)
 634
 635 CHashingEvent::CHashingEvent(wxEventType type, CKnownFile* result, const CKnownFile* owner)
 636         : wxEvent(-1, type),
 637           m_owner(owner),
 638           m_result(result)
 639 {
 640 }
 641
 642
 643 wxEvent* CHashingEvent::Clone() const
 644 {
 645         return new CHashingEvent(GetEventType(), m_result, m_owner);
 646 }
 647
 648
 649 const CKnownFile* CHashingEvent::GetOwner() const
 650 {
 651         return m_owner;
 652 }
 653
 654
 655 CKnownFile* CHashingEvent::GetResult() const
 656 {
 657         return m_result;
 658 }
 659
 660
 661
 662
 663 ////////////////////////////////////////////////////////////
 664 // CCompletionEvent
 665
 666 DEFINE_LOCAL_EVENT_TYPE(MULE_EVT_FILE_COMPLETED)
 667
 668
 669 CCompletionEvent::CCompletionEvent(bool errorOccured, const CPartFile* owner, const CPath& fullPath)
 670         : wxEvent(-1, MULE_EVT_FILE_COMPLETED),
 671           m_fullPath(fullPath),
 672           m_owner(owner),
 673           m_error(errorOccured)
 674 {
 675 }
 676
 677
 678 wxEvent* CCompletionEvent::Clone() const
 679 {
 680         return new CCompletionEvent(m_error, m_owner, m_fullPath);
 681 }
 682
 683
 684 bool CCompletionEvent::ErrorOccured() const
 685 {
 686         return m_error;
 687 }
 688
 689
 690 const CPartFile* CCompletionEvent::GetOwner() const
 691 {
 692         return m_owner;
 693 }
 694
 695
 696 const CPath& CCompletionEvent::GetFullPath() const
 697 {
 698         return m_fullPath;
 699 }
 700
 701
 702 ////////////////////////////////////////////////////////////
 703 // CAllocFinishedEvent
 704
 705 DEFINE_LOCAL_EVENT_TYPE(MULE_EVT_ALLOC_FINISHED)
 706
 707 wxEvent *CAllocFinishedEvent::Clone() const
 708 {
 709         return new CAllocFinishedEvent(m_file, m_pause, m_result);
 710 }
 711
 712 // File_checked_for_headers