#include <node/blockstorage.h>

#include <clientversion.h>

#include <consensus/validation.h>

#include <hash.h>

#include <undo.h>

static FILE* OpenUndoFile(const FlatFilePos &pos, bool fReadOnly = false);

static FlatFileSeq BlockFileSeq();

static FlatFileSeq UndoFileSeq();

std::string CBlockFileInfo::ToString() const

{

return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)", nBlocks, nSize, nHeightFirst, nHeightLast, FormatISO8601Date(nTimeFirst), FormatISO8601Date(nTimeLast));

}

CBlockFileInfo* GetBlockFileInfo(size_t n)

{

LOCK(cs_LastBlockFile);

return &vinfoBlockFile.at(n);

}

static bool UndoWriteToDisk(const CBlockUndo& blockundo, FlatFilePos& pos, const uint256& hashBlock, const CMessageHeader::MessageStartChars& messageStart)

{

// Open history file to append

CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);

if (fileout.IsNull())

return error("%s: OpenUndoFile failed", __func__);

// Write index header

unsigned int nSize = GetSerializeSize(blockundo, fileout.GetVersion());

fileout << messageStart << nSize;

// Write undo data

long fileOutPos = ftell(fileout.Get());

if (fileOutPos < 0)

return error("%s: ftell failed", __func__);

pos.nPos = (unsigned int)fileOutPos;

fileout << blockundo;

// calculate & write checksum

CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);

hasher << hashBlock;

hasher << blockundo;

fileout << hasher.GetHash();

return true;

}

bool UndoReadFromDisk(CBlockUndo& blockundo, const CBlockIndex* pindex)

{

FlatFilePos pos = pindex->GetUndoPos();

if (pos.IsNull()) {

return error("%s: no undo data available", __func__);

}

// Open history file to read

CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);

if (filein.IsNull())

return error("%s: OpenUndoFile failed", __func__);

// Read block

uint256 hashChecksum;

CHashVerifier<CAutoFile> verifier(&filein); // We need a CHashVerifier as reserializing may lose data

try {

verifier << pindex->pprev->GetBlockHash();

verifier >> blockundo;

filein >> hashChecksum;

}

catch (const std::exception& e) {

return error("%s: Deserialize or I/O error - %s", __func__, e.what());

}

// Verify checksum

if (hashChecksum != verifier.GetHash())

return error("%s: Checksum mismatch", __func__);

return true;

}

static void FlushUndoFile(int block_file, bool finalize = false)

{

FlatFilePos undo_pos_old(block_file, vinfoBlockFile[block_file].nUndoSize);

if (!UndoFileSeq().Flush(undo_pos_old, finalize)) {

AbortNode("Flushing undo file to disk failed. This is likely the result of an I/O error.");

}

}

void FlushBlockFile(bool fFinalize = false, bool finalize_undo = false)

{

LOCK(cs_LastBlockFile);

FlatFilePos block_pos_old(nLastBlockFile, vinfoBlockFile[nLastBlockFile].nSize);

if (!BlockFileSeq().Flush(block_pos_old, fFinalize)) {

AbortNode("Flushing block file to disk failed. This is likely the result of an I/O error.");

}

// we do not always flush the undo file, as the chain tip may be lagging behind the incoming blocks,

// e.g. during IBD or a sync after a node going offline

if (!fFinalize || finalize_undo) FlushUndoFile(nLastBlockFile, finalize_undo);

}

uint64_t CalculateCurrentUsage()

{

LOCK(cs_LastBlockFile);

uint64_t retval = 0;

for (const CBlockFileInfo &file : vinfoBlockFile) {

retval += file.nSize + file.nUndoSize;

}

return retval;

}

void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune)

{

for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {

FlatFilePos pos(*it, 0);

fs::remove(BlockFileSeq().FileName(pos));

fs::remove(UndoFileSeq().FileName(pos));

LogPrintf("Prune: %s deleted blk/rev (%05u)\n", __func__, *it);

}

}

static FlatFileSeq BlockFileSeq()

{

return FlatFileSeq(gArgs.GetBlocksDirPath(), "blk", gArgs.GetBoolArg("-fastprune", false) ? 0x4000 /* 16kb */ : BLOCKFILE_CHUNK_SIZE);

}

static FlatFileSeq UndoFileSeq()

{

return FlatFileSeq(gArgs.GetBlocksDirPath(), "rev", UNDOFILE_CHUNK_SIZE);

}

FILE* OpenBlockFile(const FlatFilePos &pos, bool fReadOnly) {

return BlockFileSeq().Open(pos, fReadOnly);

}

static FILE* OpenUndoFile(const FlatFilePos &pos, bool fReadOnly) {

return UndoFileSeq().Open(pos, fReadOnly);

}

fs::path GetBlockPosFilename(const FlatFilePos &pos)

{

return BlockFileSeq().FileName(pos);

}

bool FindBlockPos(FlatFilePos& pos, unsigned int nAddSize, unsigned int nHeight, CChain& active_chain, uint64_t nTime, bool fKnown = false)

{

LOCK(cs_LastBlockFile);

unsigned int nFile = fKnown ? pos.nFile : nLastBlockFile;

if (vinfoBlockFile.size() <= nFile) {

vinfoBlockFile.resize(nFile + 1);

}

bool finalize_undo = false;

if (!fKnown) {

while (vinfoBlockFile[nFile].nSize + nAddSize >= (gArgs.GetBoolArg("-fastprune", false) ? 0x10000 /* 64kb */ : MAX_BLOCKFILE_SIZE)) {

// when the undo file is keeping up with the block file, we want to flush it explicitly

// when it is lagging behind (more blocks arrive than are being connected), we let the

// undo block write case handle it

assert(std::addressof(::ChainActive()) == std::addressof(active_chain));

finalize_undo = (vinfoBlockFile[nFile].nHeightLast == (unsigned int)active_chain.Tip()->nHeight);

nFile++;

if (vinfoBlockFile.size() <= nFile) {

vinfoBlockFile.resize(nFile + 1);

}

}

pos.nFile = nFile;

pos.nPos = vinfoBlockFile[nFile].nSize;

}

if ((int)nFile != nLastBlockFile) {

if (!fKnown) {

LogPrint(BCLog::VALIDATION, "Leaving block file %i: %s\n", nLastBlockFile, vinfoBlockFile[nLastBlockFile].ToString());

}

FlushBlockFile(!fKnown, finalize_undo);

nLastBlockFile = nFile;

}

vinfoBlockFile[nFile].AddBlock(nHeight, nTime);

if (fKnown)

vinfoBlockFile[nFile].nSize = std::max(pos.nPos + nAddSize, vinfoBlockFile[nFile].nSize);

else

vinfoBlockFile[nFile].nSize += nAddSize;

if (!fKnown) {

bool out_of_space;

size_t bytes_allocated = BlockFileSeq().Allocate(pos, nAddSize, out_of_space);

if (out_of_space) {

return AbortNode("Disk space is too low!", _("Disk space is too low!"));

}

if (bytes_allocated != 0 && fPruneMode) {

fCheckForPruning = true;

}

}

setDirtyFileInfo.insert(nFile);

return true;

}

static bool FindUndoPos(BlockValidationState &state, int nFile, FlatFilePos &pos, unsigned int nAddSize)

{

pos.nFile = nFile;

LOCK(cs_LastBlockFile);

pos.nPos = vinfoBlockFile[nFile].nUndoSize;

vinfoBlockFile[nFile].nUndoSize += nAddSize;

setDirtyFileInfo.insert(nFile);

bool out_of_space;

size_t bytes_allocated = UndoFileSeq().Allocate(pos, nAddSize, out_of_space);

if (out_of_space) {

return AbortNode(state, "Disk space is too low!", _("Disk space is too low!"));

}

if (bytes_allocated != 0 && fPruneMode) {

fCheckForPruning = true;

}

return true;

}

bool WriteUndoDataForBlock(const CBlockUndo& blockundo, BlockValidationState& state, CBlockIndex* pindex, const CChainParams& chainparams)

{

// Write undo information to disk

if (pindex->GetUndoPos().IsNull()) {

FlatFilePos _pos;

if (!FindUndoPos(state, pindex->nFile, _pos, ::GetSerializeSize(blockundo, CLIENT_VERSION) + 40))

return error("ConnectBlock(): FindUndoPos failed");

if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(), chainparams.MessageStart()))

return AbortNode(state, "Failed to write undo data");

// rev files are written in block height order, whereas blk files are written as blocks come in (often out of order)

// we want to flush the rev (undo) file once we've written the last block, which is indicated by the last height

// in the block file info as below; note that this does not catch the case where the undo writes are keeping up

// with the block writes (usually when a synced up node is getting newly mined blocks) -- this case is caught in

// the FindBlockPos function

if (_pos.nFile < nLastBlockFile && static_cast<uint32_t>(pindex->nHeight) == vinfoBlockFile[_pos.nFile].nHeightLast) {

FlushUndoFile(_pos.nFile, true);

}

// update nUndoPos in block index

pindex->nUndoPos = _pos.nPos;

pindex->nStatus |= BLOCK_HAVE_UNDO;

setDirtyBlockIndex.insert(pindex);

}

return true;

}

class BlockValidationState;

class CBlockFileInfo;

FILE* OpenBlockFile(const FlatFilePos &pos, bool fReadOnly = false);

fs::path GetBlockPosFilename(const FlatFilePos &pos);

CBlockFileInfo* GetBlockFileInfo(size_t n);

uint64_t CalculateCurrentUsage();

void UnlinkPrunedFiles(const std::set<int>& setFilesToPrune);

bool WriteUndoDataForBlock(const CBlockUndo& blockundo, BlockValidationState& state, CBlockIndex* pindex, const CChainParams& chainparams);