//

// This file is part of the aMule Project.

//

// Copyright (c) 2003-2026 aMule Team ( https://amule-org.github.io )

// Copyright (c) 2002-2011 Merkur ( [email protected] / http://www.emule-project.net )

//

// Any parts of this program derived from the xMule, lMule or eMule project,

// or contributed by third-party developers are copyrighted by their

// respective authors.

//

// This program is free software; you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA

//

#include <wx/wx.h>

#include "PartFile.h" // Interface declarations.

#include "PartFileWriteThread.h" // Needed for PB_READY etc.

#include "PartFileHashThread.h" // Needed for QueueHashCheck

#include "config.h" // Needed for VERSION

#include <protocol/kad/Constants.h>

#include <protocol/ed2k/Client2Client/TCP.h>

#include <protocol/Protocols.h>

#include <common/DataFileVersion.h>

#include <common/Constants.h>

#include <tags/FileTags.h>

#include <wx/utils.h>

#include <wx/tokenzr.h> // Needed for wxStringTokenizer

#ifndef AMULE_DAEMON

#include <wx/notifmsg.h> // Needed for wxNotificationMessage

#endif

#include "KnownFileList.h" // Needed for CKnownFileList

#include "CanceledFileList.h"

#include "UploadQueue.h" // Needed for CFileHash

#include "IPFilter.h" // Needed for CIPFilter

#include "Server.h" // Needed for CServer

#include "ServerConnect.h" // Needed for CServerConnect

#ifdef CLIENT_GUI

#include "UpDownClientEC.h" // Needed for CUpDownClient

#else

#include "updownclient.h" // Needed for CUpDownClient

#endif

#include "MemFile.h" // Needed for CMemFile

#include "Preferences.h" // Needed for CPreferences

#include "DownloadQueue.h" // Needed for CDownloadQueue

#include "amule.h" // Needed for theApp

#include "ED2KLink.h" // Needed for CED2KLink

#include "Packet.h" // Needed for CTag

#include "SearchList.h" // Needed for CSearchFile

#include "ClientList.h" // Needed for clientlist

#include "Statistics.h" // Needed for theStats

#include "Logger.h"

#include <common/Format.h> // Needed for CFormat

#include <common/FileFunctions.h> // Needed for GetLastModificationTime

#include "ThreadTasks.h" // Needed for CHashingTask/CCompletionTask/CAllocateFileTask

#include "GuiEvents.h" // Needed for Notify_*

#include "DataToText.h" // Needed for OriginToText()

#include "PlatformSpecific.h" // Needed for CreateSparseFile()

#include "FileArea.h" // Needed for CFileArea

#include "ScopedPtr.h" // Needed for CScopedArray

#include "CorruptionBlackBox.h"

#include "kademlia/kademlia/Kademlia.h"

#include "kademlia/kademlia/Search.h"

#include "kademlia/kademlia/Entry.h" // Needed for Kademlia::CEntry (Kad notes)

#include "kademlia/kademlia/Indexed.h" // Needed for CKadEntryPtrList

SFileRating::SFileRating(const wxString &u, const wxString &f, sint16 r, const wxString &c)

: UserName(u)

, FileName(f)

, Rating(r)

, Comment(c)

{

}

#ifndef CLIENT_GUI

SFileRating::SFileRating(const CUpDownClient &client)

: UserName(client.GetUserName())

, FileName(client.GetClientFilename())

, Rating(client.GetFileRating())

, Comment(client.GetFileComment())

{

}

#endif

// PartFileBufferedData is defined in PartFile.h

typedef std::list<Chunk> ChunkList;

#ifndef CLIENT_GUI

CPartFile::CPartFile()

{

Init();

}

CPartFile::CPartFile(CSearchFile *searchresult)

{

Init();

m_abyFileHash = searchresult->GetFileHash();

SetFileName(searchresult->GetFileName());

SetFileSize(searchresult->GetFileSize());

for (unsigned int i = 0; i < searchresult->m_taglist.size(); ++i) {

const CTag &pTag = searchresult->m_taglist[i];

bool bTagAdded = false;

if (pTag.GetNameID() == 0 && !pTag.GetName().IsEmpty() && (pTag.IsStr() || pTag.IsInt())) {

static const struct

{

wxString pszName;

uint8 nType;

} _aMetaTags[] = { { FT_ED2K_MEDIA_ARTIST, 2 },

{ FT_ED2K_MEDIA_ALBUM, 2 },

{ FT_ED2K_MEDIA_TITLE, 2 },

{ FT_ED2K_MEDIA_LENGTH, 2 },

{ FT_ED2K_MEDIA_BITRATE, 3 },

{ FT_ED2K_MEDIA_CODEC, 2 } };

for (unsigned int t = 0; t < itemsof(_aMetaTags); ++t) {

if (pTag.GetType() == _aMetaTags[t].nType &&

(pTag.GetName() == _aMetaTags[t].pszName)) {

// skip string tags with empty string values

if (pTag.IsStr() && pTag.GetStr().IsEmpty()) {

break;

}

// skip "length" tags with "0: 0" values

if (pTag.GetName() == FT_ED2K_MEDIA_LENGTH) {

if (pTag.GetStr().IsSameAs("0: 0") ||

pTag.GetStr().IsSameAs("0:0")) {

break;

}

}

// skip "bitrate" tags with '0' values

if ((pTag.GetName() == FT_ED2K_MEDIA_BITRATE) && !pTag.GetInt()) {

break;

}

AddDebugLogLineN(logPartFile,

"CPartFile::CPartFile(CSearchFile*): added tag " +

pTag.GetFullInfo());

m_taglist.push_back(pTag);

bTagAdded = true;

break;

}

}

} else if (pTag.GetNameID() != 0 && pTag.GetName().IsEmpty() &&

(pTag.IsStr() || pTag.IsInt())) {

static const struct

{

uint8 nID;

uint8 nType;

} _aMetaTags[] = { { FT_FILETYPE, 2 },

{ FT_FILEFORMAT, 2 },

// Media metadata (#280) advertised by the source: length /

// bitrate (uint32) + codec (string). Inherit it so a download

// carries FT_MEDIA_* immediately -- visible while downloading

// and persisted on completion -- without needing a local

// ffprobe. Source-agnostic: ed2k and Kad use the same tag IDs

// (TAG_MEDIA_* == FT_MEDIA_*), and the completion probe still

// fills in files whose source advertised nothing (its

// FT_MEDIA_LENGTH>0 gate skips the ones handled here).

// (type 3 = TAGTYPE_UINT32, type 2 = TAGTYPE_STRING; bare

// literals to match the FT_FILETYPE/FT_FILEFORMAT entries above.)

{ FT_MEDIA_LENGTH, 3 },

{ FT_MEDIA_BITRATE, 3 },

{ FT_MEDIA_CODEC, 2 } };

for (unsigned int t = 0; t < itemsof(_aMetaTags); ++t) {

if (pTag.GetType() == _aMetaTags[t].nType &&

pTag.GetNameID() == _aMetaTags[t].nID) {

// skip string tags with empty string values

if (pTag.IsStr() && pTag.GetStr().IsEmpty()) {

break;

}

AddDebugLogLineN(logPartFile,

"CPartFile::CPartFile(CSearchFile*): added tag " +

pTag.GetFullInfo());

m_taglist.push_back(pTag);

bTagAdded = true;

break;

}

}

}

if (!bTagAdded) {

AddDebugLogLineN(logPartFile,

"CPartFile::CPartFile(CSearchFile*): ignored tag " + pTag.GetFullInfo());

}

}

CreatePartFile();

}

CPartFile::CPartFile(const CED2KFileLink *fileLink)

{

Init();

SetFileName(CPath(fileLink->GetName()));

SetFileSize(fileLink->GetSize());

m_abyFileHash = fileLink->GetHashKey();

CreatePartFile();

if (fileLink->m_hashset) {

if (!LoadHashsetFromFile(fileLink->m_hashset, true)) {

AddDebugLogLineC(

logPartFile, "eD2K link contained invalid hashset: " + fileLink->GetLink());

}

}

}

CPartFile::~CPartFile()

{

// Gate Phase 3 below; see m_inDestructor comment in PartFile.h.

m_inDestructor = true;

AddDebugLogLineN(

logPartFile, CFormat("~CPartFile entered, m_inDestructor set: '%s'") % GetFileName());

// Wait for any in-flight HashJobs targeting this file to finish.

// CPartFileHashThread reads m_hpartfile via HashSinglePart; we must

// not close the file out from under it. m_inDestructor was set above

// so Phase 3 will not enqueue anything new.

if (m_pendingHashes > 0) {

AddDebugLogLineN(logPartFile,

CFormat("~CPartFile waiting for %d pending hash job(s) of '%s'") %

(int)m_pendingHashes % GetFileName());

while (m_pendingHashes > 0) {

wxMilliSleep(10);

}

}

// if it's not opened, it was completed or deleted

if (m_hpartfile.IsOpened()) {

// FlushBuffer drains buffered writes / harvests Phase 2's

// PB_WRITTEN items into m_aChangedPart. Phase 3 itself returns

// early due to m_inDestructor.

FlushBuffer();

// Sync-hash any parts still flagged dirty in m_aChangedPart.

//

// Why this is needed: in normal operation Phase 3 enqueues

// dirty parts to CPartFileHashThread asynchronously. But at

// shutdown the hash thread is torn down before downloadqueue

// (see CamuleApp::OnExit ordering), so async enqueue isn't

// available here — and a forced-quit during an active download

// can leave many parts harvested-but-not-yet-hashed

// (m_aChangedPart-true but never enqueued because the

// quiescent guard never opened during the receive burst).

//

// Without this, .met would be saved with gaplist marking

// those parts complete and m_corrupted_list empty, so on

// next launch they would be treated as implicitly verified

// (the existing "verified iff IsComplete && !IsCorruptedPart"

// invariant) — even though they were never hashed.

//

// Run the verification synchronously on the main thread.

// Slow shutdown is acceptable for the rare cancel-mid-download

// case; the common paths (natural completion, pause/resume,

// idle drain) keep m_aChangedPart drained throughout the

// session, so the loop usually has nothing to do.

if (m_aChangedPart.size() == GetPartCount()) {

uint16 verified = 0, corrupt = 0;

for (uint16 i = 0; i < GetPartCount(); ++i) {

if (!m_aChangedPart[i]) {

continue;

}

m_aChangedPart[i] = false;

// Only hash parts whose data is actually on disk.

if (!IsComplete(i)) {

continue;

}

// Lock m_hpartfileMutex against CPartFileWriteThread:

// Phase 1 of FlushBuffer above may have queued writes

// that the write thread is still draining concurrently

// with this sync-hash loop. See m_hpartfileMutex.

bool ok;

{

std::lock_guard<std::mutex> lock(m_hpartfileMutex);

ok = HashSinglePart(i);

}

if (ok) {

// Part is good. If it was carried in

// m_corrupted_list from before, drop it so the

// .met save below records the new clean state.

if (IsCorruptedPart(i)) {

EraseFirstValue(m_corrupted_list, i);

}

++verified;

} else {

// Part is bad. Re-open the gap and record in

// m_corrupted_list so next launch knows to

// re-download + retry.

AddGap(i);

if (!IsCorruptedPart(i)) {

m_corrupted_list.push_back(i);

}

m_iLostDueToCorruption += (uint64)GetPartSize(i);

++corrupt;

}

}

if (verified > 0 || corrupt > 0) {

AddDebugLogLineN(logPartFile,

CFormat("~CPartFile sync-hashed %u remaining dirty part(s) "

"(%u verified, %u corrupt) for '%s'") %

(verified + corrupt) % verified % corrupt % GetFileName());

}

}

m_hpartfile.Close();

// Update met file (with current directory entry)

SavePartFile();

}

DeleteContents(m_BufferedData_list);

delete m_CorruptionBlackBox;

wxASSERT(m_SrcList.empty());

wxASSERT(m_A4AFsrclist.empty());

}

void CPartFile::CreatePartFile(bool isImporting)

{

// use lowest free partfilenumber for free file (InterCeptor)

int i = 0;

do {

++i;

m_partmetfilename = CPath(CFormat("%03i.part.met") % i);

m_fullname = thePrefs::GetTempDir().JoinPaths(m_partmetfilename);

} while (m_fullname.FileExists());

m_CorruptionBlackBox->SetPartFileInfo(

GetFileName().GetPrintable(), m_partmetfilename.RemoveAllExt().GetPrintable());

m_gaplist.Init(GetFileSize(), true); // Init empty

m_PartPath = m_fullname.RemoveExt();

bool fileCreated;

if (thePrefs::GetAllocFullFile() || !thePrefs::CreateFilesSparse()) {

fileCreated = m_hpartfile.Create(m_PartPath, true);

m_hpartfile.Close();

} else {

fileCreated = PlatformSpecific::CreateSparseFile(m_PartPath, GetFileSize());

}

if (!fileCreated) {

AddLogLineN(_("ERROR: Failed to create partfile"));

SetStatus(PS_ERROR);

}

SetFilePath(thePrefs::GetTempDir());

if (!isImporting && thePrefs::GetAllocFullFile()) {

SetStatus(PS_ALLOCATING);

CThreadScheduler::AddTask(new CAllocateFileTask(this, thePrefs::AddNewFilesPaused()));

} else {

AllocationFinished();

}

m_hashsetneeded = (GetED2KPartHashCount() > 0);

SavePartFile(true);

SetActive(theApp->IsConnected());

}

uint8 CPartFile::LoadPartFile(

const CPath &in_directory, const CPath &filename, bool from_backup, bool getsizeonly)

{

bool isnewstyle = false;

uint8 version, partmettype = PMT_UNKNOWN;

std::map<uint16, Gap_Struct *> gap_map; // Slugfiller

transferred = 0;

m_partmetfilename = filename;

m_CorruptionBlackBox->SetPartFileInfo(

GetFileName().GetPrintable(), m_partmetfilename.RemoveAllExt().GetPrintable());

m_filePath = in_directory;

m_fullname = m_filePath.JoinPaths(m_partmetfilename);

m_PartPath = m_fullname.RemoveExt();

// readfile data form part.met file

CPath curMetFilename = m_fullname;

if (from_backup) {

curMetFilename = curMetFilename.AppendExt(PARTMET_BAK_EXT);

AddLogLineN(CFormat(_("Trying to load backup of met-file from %s")) % curMetFilename);

}

try {

CFile metFile(curMetFilename, CFile::read);

if (!metFile.IsOpened()) {

AddLogLineN(CFormat(_("ERROR: Failed to open part.met file: %s ==> %s")) %

curMetFilename % GetFileName());

return false;

} else if (metFile.GetLength() == 0) {

AddLogLineN(CFormat(_("ERROR: part.met file is 0 size: %s ==> %s")) %

m_partmetfilename % GetFileName());

return false;

}

version = metFile.ReadUInt8();

if (version != PARTFILE_VERSION && version != PARTFILE_SPLITTEDVERSION &&

version != PARTFILE_VERSION_LARGEFILE) {

metFile.Close();

// if (version == 83) return ImportShareazaTempFile(...)

AddLogLineN(CFormat(_("ERROR: Invalid part.met file version: %s ==> %s")) %

m_partmetfilename % GetFileName());

return false;

}

isnewstyle = (version == PARTFILE_SPLITTEDVERSION);

partmettype = isnewstyle ? PMT_SPLITTED : PMT_DEFAULTOLD;

if (version == PARTFILE_VERSION) { // Do we still need this check ?

uint8 test[4]; // It will fail for certain files.

metFile.Seek(24, wxFromStart);

metFile.Read(test, 4);

metFile.Seek(1, wxFromStart);

if (test[0] == 0 && test[1] == 0 && test[2] == 2 && test[3] == 1) {

isnewstyle = true; // edonkeys so called "old part style"

partmettype = PMT_NEWOLD;

}

}

if (isnewstyle) {

uint32 temp = metFile.ReadUInt32();

if (temp == 0) { // 0.48 partmets - different again

LoadHashsetFromFile(&metFile, false);

} else {

metFile.Seek(2, wxFromStart);

LoadDateFromFile(&metFile);

m_abyFileHash = metFile.ReadHash();

}

} else {

LoadDateFromFile(&metFile);

LoadHashsetFromFile(&metFile, false);

}

uint32 tagcount = metFile.ReadUInt32();

for (uint32 j = 0; j < tagcount; ++j) {

CTag newtag(metFile, true);

if (!getsizeonly || (getsizeonly && (newtag.GetNameID() == FT_FILESIZE ||

newtag.GetNameID() == FT_FILENAME))) {

switch (newtag.GetNameID()) {

case FT_FILENAME: {

if (!GetFileName().IsOk()) {

// If it's not empty, we already loaded the unicoded one

SetFileName(CPath(newtag.GetStr()));

}

break;

}

case FT_LASTSEENCOMPLETE: {

lastseencomplete = newtag.GetInt();

break;

}

case FT_FILESIZE: {

SetFileSize(newtag.GetInt());

break;

}

case FT_TRANSFERRED: {

transferred = newtag.GetInt();

break;

}

case FT_FILETYPE: {

// #warning needs setfiletype string

// SetFileType(newtag.GetStr());

break;

}

case FT_CATEGORY: {

m_category = newtag.GetInt();

if (m_category > theApp->glob_prefs->GetCatCount() - 1) {

m_category = 0;

}

break;

}

case FT_OLDDLPRIORITY:

case FT_DLPRIORITY: {

if (!isnewstyle) {

m_iDownPriority = newtag.GetInt();

if (m_iDownPriority == PR_AUTO) {

m_iDownPriority = PR_HIGH;

SetAutoDownPriority(true);

} else {

if (m_iDownPriority != PR_LOW &&

m_iDownPriority != PR_NORMAL &&

m_iDownPriority != PR_HIGH)

m_iDownPriority = PR_NORMAL;

SetAutoDownPriority(false);

}

}

break;

}

case FT_STATUS: {

m_paused = (newtag.GetInt() == 1);

m_stopped = m_paused;

break;

}

case FT_OLDULPRIORITY:

case FT_ULPRIORITY: {

if (!isnewstyle) {

SetUpPriority(newtag.GetInt(), false);

if (GetUpPriority() == PR_AUTO) {

SetUpPriority(PR_HIGH, false);

SetAutoUpPriority(true);

} else {

SetAutoUpPriority(false);

}

}

break;

}

case FT_KADLASTPUBLISHSRC: {

SetLastPublishTimeKadSrc(newtag.GetInt(), 0);

if (GetLastPublishTimeKadSrc() >

(uint32)time(NULL) + KADEMLIAREPUBLISHTIMES) {

// There may be a possibility of an older client that saved a

// random number here.. This will check for that..

SetLastPublishTimeKadSrc(0, 0);

}

break;

}

case FT_KADLASTPUBLISHNOTES: {

SetLastPublishTimeKadNotes(newtag.GetInt());

break;

}

// old tags: as long as they are not needed, take the chance to purge them

case FT_PERMISSIONS:

case FT_KADLASTPUBLISHKEY:

case FT_PARTFILENAME:

break;

case FT_DL_ACTIVE_TIME:

if (newtag.IsInt()) {

m_nDlActiveTime = newtag.GetInt();

}

break;

case FT_CORRUPTEDPARTS: {

wxASSERT(m_corrupted_list.empty());

const wxString &strCorruptedParts(newtag.GetStr());

wxStringTokenizer tokenizer(strCorruptedParts, ",");

while (tokenizer.HasMoreTokens()) {

wxString token = tokenizer.GetNextToken();

unsigned long uPart;

if (token.ToULong(&uPart)) {

if (uPart < GetPartCount() &&

!IsCorruptedPart(uPart)) {

m_corrupted_list.push_back(uPart);

}

}

}

break;

}

case FT_AICH_HASH: {

CAICHHash hash;

bool hashSizeOk = hash.DecodeBase32(newtag.GetStr()) ==

CAICHHash::GetHashSize();

wxASSERT(hashSizeOk);

if (hashSizeOk) {

m_pAICHHashSet->SetMasterHash(hash, AICH_VERIFIED);

// EC exports GetAICHMasterHash().

MarkECChanged();

}

break;

}

case FT_ATTRANSFERRED: {

statistic.SetAllTimeTransferred(

statistic.GetAllTimeTransferred() + (uint64)newtag.GetInt());

break;

}

case FT_ATTRANSFERREDHI: {

statistic.SetAllTimeTransferred(statistic.GetAllTimeTransferred() +

(((uint64)newtag.GetInt()) << 32));

break;

}

case FT_ATREQUESTED: {

statistic.SetAllTimeRequests(newtag.GetInt());

break;

}

case FT_ATACCEPTED: {

statistic.SetAllTimeAccepts(newtag.GetInt());

break;

}

default: {

// Start Changes by Slugfiller for better exception handling

wxCharBuffer tag_ansi_name = newtag.GetName().ToAscii();

char gap_mark = tag_ansi_name.data() ? tag_ansi_name[0u] : 0;

if (newtag.IsInt() && (newtag.GetName().Length() > 1) &&

((gap_mark == FT_GAPSTART) || (gap_mark == FT_GAPEND))) {

Gap_Struct *gap = NULL;

unsigned long int gapkey;

if (newtag.GetName().Mid(1).ToULong(&gapkey)) {

if (gap_map.find(gapkey) == gap_map.end()) {

gap = new Gap_Struct;

gap_map[gapkey] = gap;

gap->start = (uint64)-1;

gap->end = (uint64)-1;

} else {

gap = gap_map[gapkey];

}

if (gap_mark == FT_GAPSTART) {

gap->start = newtag.GetInt();

}

if (gap_mark == FT_GAPEND) {

gap->end = newtag.GetInt() - 1;

}

} else {

AddDebugLogLineN(logPartFile,

"Wrong gap map key while reading met file!");

wxFAIL;

}

// End Changes by Slugfiller for better exception handling

} else {

m_taglist.push_back(newtag);

}

}

}

} else {

// Nothing. Else, nothing.

}

}

// load the hashsets from the hybridstylepartmet

if (isnewstyle && !getsizeonly && (metFile.GetPosition() < metFile.GetLength())) {

metFile.Seek(1, wxFromCurrent);

uint16 parts = GetPartCount(); // assuming we will get all hashsets

for (uint16 i = 0; i < parts && (metFile.GetPosition() + 16 < metFile.GetLength());

++i) {

CMD4Hash cur_hash = metFile.ReadHash();

m_hashlist.push_back(cur_hash);

}

CMD4Hash checkhash;

if (!m_hashlist.empty()) {

CreateHashFromHashlist(m_hashlist, &checkhash);

}

if (m_abyFileHash != checkhash) {

m_hashlist.clear();

}

}

} catch (const CInvalidPacket &e) {

AddLogLineC(CFormat(_("Error: %s (%s) is corrupt (bad tags: %s), unable to load file.")) %

m_partmetfilename % GetFileName() % e.what());

return false;

} catch (const CIOFailureException &e) {

AddDebugLogLineC(logPartFile,

CFormat("IO failure while loading '%s': %s") % m_partmetfilename % e.what());

return false;

} catch (const CEOFException &WXUNUSED(e)) {

AddLogLineC(CFormat(_("ERROR: %s (%s) is corrupt (wrong tagcount), unable to load file.")) %

m_partmetfilename % GetFileName());

AddLogLineC(_("Trying to recover file info..."));

// Safe file is that who have

// - FileSize

if (GetFileSize()) {

// We have filesize, try other needed info

// Do we need to check gaps? I think not,

// because they are checked below. Worst

// scenario will only mark file as 0 bytes downloaded.

// -Filename

if (!GetFileName().IsOk()) {

// Not critical, let's put a random filename.

AddLogLineC(_("Recovering no-named file - will try to recover it as "

"RecoveredFile.dat"));

SetFileName(CPath("RecoveredFile.dat"));

}

AddLogLineC(_("Recovered all available file info :D - Trying to use it..."));

} else {

AddLogLineC(_("Unable to recover file info :("));

return false;

}

}

if (getsizeonly) {

return partmettype;

}

// Init Gaplist

m_gaplist.Init(GetFileSize(), false); // Init full, then add gaps

// Now to flush the map into the list (Slugfiller)

std::map<uint16, Gap_Struct *>::iterator it = gap_map.begin();

for (; it != gap_map.end(); ++it) {

Gap_Struct *gap = it->second;

// SLUGFILLER: SafeHash - revised code, and extra safety

if ((gap->start != (uint64)-1) && (gap->end != (uint64)-1) && gap->start <= gap->end &&

gap->start < GetFileSize()) {

if (gap->end >= GetFileSize()) {

gap->end = GetFileSize() - 1; // Clipping

}

m_gaplist.AddGap(gap->start, gap->end); // All tags accounted for, use safe adding

}

delete gap;

// SLUGFILLER: SafeHash

}

// check if this is a backup

if (m_fullname.GetExt().MakeLower() == "backup") {

m_fullname = m_fullname.RemoveExt();

}

// open permanent handle

if (!m_hpartfile.Open(m_PartPath, CFile::read_write)) {

AddLogLineN(CFormat(_("Failed to open %s (%s)")) % m_fullname % GetFileName());

return false;

}

SetStatus(PS_EMPTY);

try {

// SLUGFILLER: SafeHash - final safety, make sure any missing part of the file is gap

if (m_hpartfile.GetLength() < GetFileSize())

AddGap(m_hpartfile.GetLength(), GetFileSize() - 1);

// Goes both ways - Partfile should never be too large

if (m_hpartfile.GetLength() > GetFileSize()) {

AddDebugLogLineC(logPartFile,

CFormat("Partfile \"%s\" is too large! Truncating %llu bytes.") %

GetFileName() % (m_hpartfile.GetLength() - GetFileSize()));

m_hpartfile.SetLength(GetFileSize());

}

// SLUGFILLER: SafeHash

} catch (const CIOFailureException &e) {

AddDebugLogLineC(logPartFile,

CFormat("Error while accessing partfile \"%s\": %s") % GetFileName() % e.what());

SetStatus(PS_ERROR);

}

// now close the file again until needed

m_hpartfile.Release(true);

// check hashcount, file status etc

if (GetHashCount() != GetED2KPartHashCount()) {

m_hashsetneeded = true;

ClearMetDirty();

ClearStatsDirty();

m_lastMetSaveTick = ::GetTickCount64();

return true;

} else {

m_hashsetneeded = false;

for (size_t i = 0; i < m_hashlist.size(); ++i) {

if (IsComplete(i)) {

SetStatus(PS_READY);

}

}

}

if (m_gaplist.IsComplete()) { // is this file complete already?

CompleteFile(false);

return true;

}

if (!isnewstyle) { // not for importing

const time_t file_date = CPath::GetModificationTime(m_PartPath);

if (m_lastDateChanged != file_date) {

// It's pointless to rehash an empty file, since the case

// where a user has zero'd a file is handled above ...

if (m_hpartfile.GetLength()) {

AddLogLineN(CFormat(_("WARNING: %s might be corrupted (%i)")) % m_PartPath %

(m_lastDateChanged - file_date));

// rehash

SetStatus(PS_WAITING_FOR_HASH);

CPath partFileName = m_partmetfilename.RemoveExt();

CThreadScheduler::AddTask(new CHashingTask(m_filePath, partFileName, this));

}

}

}

UpdateCompletedInfos();

if (completedsize > transferred) {

m_iGainDueToCompression = completedsize - transferred;

} else if (completedsize != transferred) {

m_iLostDueToCorruption = transferred - completedsize;

}

// In-memory state now matches the just-loaded .part.met. Setters

// invoked during tag parsing (SetUpPriority, SetAutoUpPriority,

// SetAutoDownPriority, SetStatus, etc.) may have set m_metDirty;

// drop it so the first FlushBuffer tick after load does not rewrite

// the .met with byte-identical content. Also seed m_lastMetSaveTick

// from load time so the stats-heartbeat is measured from now.

ClearMetDirty();

ClearStatsDirty();

m_lastMetSaveTick = ::GetTickCount64();

return true;

}

bool CPartFile::SavePartFile(bool Initial)

{

switch (status) {

case PS_WAITING_FOR_HASH:

case PS_HASHING:

case PS_COMPLETE:

return false;

}

/* Don't write anything to disk if less than 100 KB of free space is left. */

sint64 free = CPath::GetFreeSpaceAt(GetFilePath());

if ((free != wxInvalidOffset) && (free < (100 * 1024))) {

return false;

}

// Atomic-rename save.

//

// Old sequence (per partfile, every save tick):

// 1. CPath::BackupFile(m_fullname, ".backup") -- full content copy

// of .part.met into .part.met.backup as an in-flight intermediate.

// 2. CPath::RemoveFile(m_fullname).

// 3. Write new .part.met from scratch.

// 4. CPath::RemoveFile(".backup") on success.

// 5. CPath::BackupFile(m_fullname, PARTMET_BAK_EXT) -- full content

// copy of the freshly-written .part.met into .part.met.bak as the

// long-term recovery backup.

//

// Three full-size content copies per save plus a delete/create dance on

// the live .part.met. On a sharer with hundreds of dirty partfiles per

// timer tick the aggregate runs the main thread continuously through

// disk I/O (see issue #669) -- write() syscalls are microseconds each,

// but the loop length itself is the bottleneck.

//

// New sequence:

// 1. Write new content into .part.met.tmp.

// 2. rename(.part.met, .part.met.bak) -- O(1) metadata op, promotes

// the previous .part.met to long-term backup.

// 3. rename(.part.met.tmp, .part.met) -- atomic install of new

// content, POSIX rename guarantees the target is either fully

// old-content or fully new-content at every observable moment.

//

// One content write plus two metadata renames. ~3x reduction in

// per-save disk work, and stronger crash safety because the live

// .part.met is never absent or partial.

const CPath tmpName = m_fullname.AppendExt(".tmp");

const CPath bakName = m_fullname.AppendExt(PARTMET_BAK_EXT);

CFile file;

try {

if (!m_PartPath.FileExists()) {

throw wxString(".part file not found");

}

uint32 lsc = lastseencomplete;

file.Open(tmpName, CFile::write);

if (!file.IsOpened()) {

throw wxString("Failed to open part.met.tmp file");

}

// version

file.WriteUInt8(IsLargeFile() ? PARTFILE_VERSION_LARGEFILE : PARTFILE_VERSION);

file.WriteUInt32(CPath::GetModificationTime(m_PartPath));

// hash

file.WriteHash(m_abyFileHash);

uint16 parts = m_hashlist.size();

file.WriteUInt16(parts);

for (int x = 0; x < parts; ++x) {

file.WriteHash(m_hashlist[x]);

}

// tags

#define FIXED_TAGS 15

uint32 tagcount = m_taglist.size() + FIXED_TAGS + (m_gaplist.size() * 2);

if (!m_corrupted_list.empty()) {

++tagcount;

}

if (m_pAICHHashSet->HasValidMasterHash() && (m_pAICHHashSet->GetStatus() == AICH_VERIFIED)) {

++tagcount;

}

if (GetLastPublishTimeKadSrc()) {

++tagcount;

}

if (GetLastPublishTimeKadNotes()) {

++tagcount;

}

if (GetDlActiveTime()) {

++tagcount;

}

file.WriteUInt32(tagcount);

// #warning Kry - Where are lost by corruption and gained by compression?

// 0 (unicoded part file name)

// We write it with BOM to keep eMule compatibility. Note that the 'printable' filename is

// saved, as presently the filename does not represent an actual file.

CTagString(FT_FILENAME, GetFileName().GetPrintable()).WriteTagToFile(&file, utf8strOptBOM);

CTagString(FT_FILENAME, GetFileName().GetPrintable()).WriteTagToFile(&file); // 1

CTagIntSized(FT_FILESIZE, GetFileSize(), IsLargeFile() ? 64 : 32).WriteTagToFile(&file); // 2

CTagIntSized(FT_TRANSFERRED, transferred, IsLargeFile() ? 64 : 32).WriteTagToFile(&file); // 3

CTagInt32(FT_STATUS, (m_paused ? 1 : 0)).WriteTagToFile(&file); // 4

if (IsAutoDownPriority()) {

CTagInt32(FT_DLPRIORITY, (uint8)PR_AUTO).WriteTagToFile(&file); // 5

CTagInt32(FT_OLDDLPRIORITY, (uint8)PR_AUTO).WriteTagToFile(&file); // 6

} else {

CTagInt32(FT_DLPRIORITY, m_iDownPriority).WriteTagToFile(&file); // 5

CTagInt32(FT_OLDDLPRIORITY, m_iDownPriority).WriteTagToFile(&file); // 6

}

CTagInt32(FT_LASTSEENCOMPLETE, lsc).WriteTagToFile(&file); // 7

if (IsAutoUpPriority()) {

CTagInt32(FT_ULPRIORITY, (uint8)PR_AUTO).WriteTagToFile(&file); // 8

CTagInt32(FT_OLDULPRIORITY, (uint8)PR_AUTO).WriteTagToFile(&file); // 9

} else {

CTagInt32(FT_ULPRIORITY, GetUpPriority()).WriteTagToFile(&file); // 8

CTagInt32(FT_OLDULPRIORITY, GetUpPriority()).WriteTagToFile(&file); // 9

}

CTagInt32(FT_CATEGORY, m_category).WriteTagToFile(&file); // 10

CTagInt32(FT_ATTRANSFERRED, statistic.GetAllTimeTransferred() & 0xFFFFFFFF)

.WriteTagToFile(&file); // 11

CTagInt32(FT_ATTRANSFERREDHI, statistic.GetAllTimeTransferred() >> 32)

.WriteTagToFile(&file); // 12

CTagInt32(FT_ATREQUESTED, statistic.GetAllTimeRequests()).WriteTagToFile(&file); // 13

CTagInt32(FT_ATACCEPTED, statistic.GetAllTimeAccepts()).WriteTagToFile(&file); // 14

// corrupt part infos

if (!m_corrupted_list.empty()) {

wxString strCorruptedParts;

std::list<uint16>::iterator it = m_corrupted_list.begin();

for (; it != m_corrupted_list.end(); ++it) {

uint16 uCorruptedPart = *it;

if (!strCorruptedParts.IsEmpty()) {

strCorruptedParts += ",";

}

strCorruptedParts += CFormat("%u") % uCorruptedPart;

}

wxASSERT(!strCorruptedParts.IsEmpty());

CTagString(FT_CORRUPTEDPARTS, strCorruptedParts).WriteTagToFile(&file); // 11?

}

// AICH Filehash

if (m_pAICHHashSet->HasValidMasterHash() && (m_pAICHHashSet->GetStatus() == AICH_VERIFIED)) {

CTagString aichtag(FT_AICH_HASH, m_pAICHHashSet->GetMasterHash().GetString());

aichtag.WriteTagToFile(&file); // 12?

}

if (GetLastPublishTimeKadSrc()) {

CTagInt32(FT_KADLASTPUBLISHSRC, GetLastPublishTimeKadSrc())

.WriteTagToFile(&file); // 15?

}

if (GetLastPublishTimeKadNotes()) {

CTagInt32(FT_KADLASTPUBLISHNOTES, GetLastPublishTimeKadNotes())

.WriteTagToFile(&file); // 16?

}

if (GetDlActiveTime()) {

CTagInt32(FT_DL_ACTIVE_TIME, GetDlActiveTime()).WriteTagToFile(&file); // 17

}

for (uint32 j = 0; j < (uint32)m_taglist.size(); ++j) {

m_taglist[j].WriteTagToFile(&file);

}

// gaps

unsigned i_pos = 0;

for (CGapList::const_iterator it = m_gaplist.begin(); it != m_gaplist.end(); ++it) {

wxString tagName = CFormat(" %u") % i_pos;

// gap start = first missing byte but gap ends = first non-missing byte

// in edonkey but I think its easier to user the real limits

tagName[0] = FT_GAPSTART;

CTagIntSized(tagName, it.start(), IsLargeFile() ? 64 : 32).WriteTagToFile(&file);