INSANEMODE/OpenAssetTools
1
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-06-11 07:18:11 -05:00
Code Issues Packages Projects Releases Wiki Activity

refactor: hide implementation of loading steps inside file

Browse Source
This commit is contained in:
Jan
2025-05-02 21:12:48 +01:00
parent 955df98279
commit b92e85dc14
31 changed files with 649 additions and 477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/ZoneLoading/Loading/Steps/StepAddProcessor.cpp
View File

@ -2,15 +2,33 @@
#include <cassert>
StepAddProcessor::StepAddProcessor(std::unique_ptr<StreamProcessor> streamProcessor)
: m_stream_processor(std::move(streamProcessor))
namespace
{
}
class StepAddProcessor final : public ILoadingStep
{
public:
explicit StepAddProcessor(std::unique_ptr<StreamProcessor> streamProcessor)
: m_stream_processor(std::move(streamProcessor))
{
}
void StepAddProcessor::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
assert(m_stream_processor != nullptr);
zoneLoader.AddStreamProcessor(std::move(m_stream_processor));
m_stream_processor = nullptr;
}
private:
std::unique_ptr<StreamProcessor> m_stream_processor;
};
} // namespace
namespace step
{
assert(m_stream_processor != nullptr);
zoneLoader.AddStreamProcessor(std::move(m_stream_processor));
m_stream_processor = nullptr;
}
std::unique_ptr<ILoadingStep> CreateStepAddProcessor(std::unique_ptr<StreamProcessor> streamProcessor)
{
return std::make_unique<StepAddProcessor>(std::move(streamProcessor));
}
} // namespace step

12
src/ZoneLoading/Loading/Steps/StepAddProcessor.h
View File

@ -4,13 +4,7 @@
#include <memory>
class StepAddProcessor final : public ILoadingStep
namespace step
{
public:
explicit StepAddProcessor(std::unique_ptr<StreamProcessor> streamProcessor);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
std::unique_ptr<StreamProcessor> m_stream_processor;
};
std::unique_ptr<ILoadingStep> CreateStepAddProcessor(std::unique_ptr<StreamProcessor> streamProcessor);
}

54
src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
View File

@ -5,28 +5,40 @@
namespace
{
constexpr uint64_t MAX_XBLOCK_SIZE = 0x3C000000;
}
void StepAllocXBlocks::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
class StepAllocXBlocks final : public ILoadingStep
{
public:
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
const auto blockCount = static_cast<unsigned>(zoneLoader.m_blocks.size());
const auto blockSizes = std::make_unique<xblock_size_t[]>(blockCount);
stream.Load(blockSizes.get(), sizeof(xblock_size_t) * blockCount);
uint64_t totalMemory = 0;
for (unsigned int block = 0; block < blockCount; block++)
{
totalMemory += blockSizes[block];
}
if (totalMemory > MAX_XBLOCK_SIZE)
{
throw InvalidXBlockSizeException(totalMemory, MAX_XBLOCK_SIZE);
}
for (unsigned int block = 0; block < blockCount; block++)
{
zoneLoader.m_blocks[block]->Alloc(blockSizes[block]);
}
}
};
} // namespace
namespace step
{
const auto blockCount = static_cast<unsigned>(zoneLoader.m_blocks.size());
const auto blockSizes = std::make_unique<xblock_size_t[]>(blockCount);
stream.Load(blockSizes.get(), sizeof(xblock_size_t) * blockCount);
uint64_t totalMemory = 0;
for (unsigned int block = 0; block < blockCount; block++)
std::unique_ptr<ILoadingStep> CreateStepAllocXBlocks()
{
totalMemory += blockSizes[block];
return std::make_unique<StepAllocXBlocks>();
}
if (totalMemory > MAX_XBLOCK_SIZE)
{
throw InvalidXBlockSizeException(totalMemory, MAX_XBLOCK_SIZE);
}
for (unsigned int block = 0; block < blockCount; block++)
{
zoneLoader.m_blocks[block]->Alloc(blockSizes[block]);
}
}
} // namespace step

9
src/ZoneLoading/Loading/Steps/StepAllocXBlocks.h
View File

@ -2,8 +2,9 @@
#include "Loading/ILoadingStep.h"
class StepAllocXBlocks final : public ILoadingStep
#include <memory>
namespace step
{
public:
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
};
std::unique_ptr<ILoadingStep> CreateStepAllocXBlocks();
}

74
src/ZoneLoading/Loading/Steps/StepDumpData.cpp
View File

@ -2,39 +2,57 @@
#include <fstream>
StepDumpData::StepDumpData(const size_t dumpCount)
: m_dump_count(dumpCount)
namespace
{
}
void StepDumpData::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
{
uint8_t tempBuffer[128];
auto dumpedBytes = 0uz;
std::ofstream tempFile("dump.dat", std::fstream::out | std::fstream::binary);
while (dumpedBytes < m_dump_count)
class StepDumpData final : public ILoadingStep
{
size_t toDump;
if (m_dump_count - dumpedBytes < sizeof(tempBuffer))
public:
explicit StepDumpData(const size_t dumpCount)
: m_dump_count(dumpCount)
{
toDump = m_dump_count - dumpedBytes;
}
else
{
toDump = sizeof(tempBuffer);
}
const auto loadedSize = stream.Load(tempBuffer, toDump);
dumpedBytes += loadedSize;
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
uint8_t tempBuffer[128];
auto dumpedBytes = 0uz;
if (loadedSize == 0)
break;
std::ofstream tempFile("dump.dat", std::fstream::out | std::fstream::binary);
tempFile.write(reinterpret_cast<char*>(tempBuffer), static_cast<std::streamsize>(loadedSize));
while (dumpedBytes < m_dump_count)
{
size_t toDump;
if (m_dump_count - dumpedBytes < sizeof(tempBuffer))
{
toDump = m_dump_count - dumpedBytes;
}
else
{
toDump = sizeof(tempBuffer);
}
const auto loadedSize = stream.Load(tempBuffer, toDump);
dumpedBytes += loadedSize;
if (loadedSize == 0)
break;
tempFile.write(reinterpret_cast<char*>(tempBuffer), static_cast<std::streamsize>(loadedSize));
}
tempFile.close();
}
private:
size_t m_dump_count;
};
} // namespace
namespace step
{
std::unique_ptr<ILoadingStep> CreateStepDumpData(size_t dumpCount)
{
return std::make_unique<StepDumpData>(dumpCount);
}
tempFile.close();
}
} // namespace step

14
src/ZoneLoading/Loading/Steps/StepDumpData.h
View File

@ -2,13 +2,9 @@
#include "Loading/ILoadingStep.h"
class StepDumpData final : public ILoadingStep
#include <memory>
namespace step
{
public:
explicit StepDumpData(size_t dumpCount);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
size_t m_dump_count;
};
std::unique_ptr<ILoadingStep> CreateStepDumpData(size_t dumpCount);
}

80
src/ZoneLoading/Loading/Steps/StepLoadHash.cpp
View File

@ -4,38 +4,56 @@
#include <cassert>
StepLoadHash::StepLoadHash(const size_t hashSize, const unsigned hashCount)
: m_hash_size(hashSize),
m_hash_count(hashCount),
m_hashes(std::make_unique<uint8_t[]>(hashSize * hashCount))
namespace
{
}
class StepLoadHash final : public step::IStepLoadHash
{
public:
StepLoadHash(const size_t hashSize, const unsigned hashCount)
: m_hash_size(hashSize),
m_hash_count(hashCount),
m_hashes(std::make_unique<uint8_t[]>(hashSize * hashCount))
{
}
StepLoadHash::~StepLoadHash() = default;
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
if (stream.Load(m_hashes.get(), m_hash_size * m_hash_count) != m_hash_size * m_hash_count)
throw UnexpectedEndOfFileException();
}
void StepLoadHash::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
void GetHash(const unsigned hashIndex, const uint8_t** pHash, size_t* pSize) override
{
assert(pHash != nullptr);
assert(pSize != nullptr);
assert(hashIndex < m_hash_count);
assert(m_hashes);
*pHash = &m_hashes[m_hash_size * hashIndex];
*pSize = m_hash_size;
}
void GetCapturedData(const uint8_t** pCapturedData, size_t* pSize) override
{
assert(pCapturedData != nullptr);
assert(pSize != nullptr);
*pCapturedData = m_hashes.get();
*pSize = m_hash_size * m_hash_count;
}
private:
size_t m_hash_size;
unsigned m_hash_count;
std::unique_ptr<uint8_t[]> m_hashes;
};
} // namespace
namespace step
{
if (stream.Load(m_hashes.get(), m_hash_size * m_hash_count) != m_hash_size * m_hash_count)
throw UnexpectedEndOfFileException();
}
void StepLoadHash::GetHash(const unsigned hashIndex, const uint8_t** pHash, size_t* pSize)
{
assert(pHash != nullptr);
assert(pSize != nullptr);
assert(hashIndex < m_hash_count);
assert(m_hashes);
*pHash = &m_hashes[m_hash_size * hashIndex];
*pSize = m_hash_size;
}
void StepLoadHash::GetCapturedData(const uint8_t** pCapturedData, size_t* pSize)
{
assert(pCapturedData != nullptr);
assert(pSize != nullptr);
*pCapturedData = m_hashes.get();
*pSize = m_hash_size * m_hash_count;
}
std::unique_ptr<IStepLoadHash> CreateStepLoadHash(const size_t hashSize, const unsigned hashCount)
{
return std::make_unique<StepLoadHash>(hashSize, hashCount);
}
} // namespace step

25
src/ZoneLoading/Loading/Steps/StepLoadHash.h
View File

@ -4,26 +4,13 @@
#include "Loading/ILoadingStep.h"
#include "Utils/ICapturedDataProvider.h"
#include <cstdint>
#include <memory>
class StepLoadHash final : public ILoadingStep, public IHashProvider, public ICapturedDataProvider
namespace step
{
public:
StepLoadHash(size_t hashSize, unsigned hashCount);
~StepLoadHash() override;
class IStepLoadHash : public ILoadingStep, public IHashProvider, public ICapturedDataProvider
{
};
StepLoadHash(const StepLoadHash& other) = delete;
StepLoadHash(StepLoadHash&& other) noexcept = default;
StepLoadHash& operator=(const StepLoadHash& other) = delete;
StepLoadHash& operator=(StepLoadHash&& other) noexcept = delete;
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
void GetHash(unsigned hashIndex, const uint8_t** pHash, size_t* pSize) override;
void GetCapturedData(const uint8_t** pCapturedData, size_t* pSize) override;
private:
const size_t m_hash_size;
const unsigned m_hash_count;
std::unique_ptr<uint8_t[]> m_hashes;
};
std::unique_ptr<IStepLoadHash> CreateStepLoadHash(size_t hashSize, unsigned hashCount);
} // namespace step

57
src/ZoneLoading/Loading/Steps/StepLoadSignature.cpp
View File

@ -4,25 +4,44 @@
#include <cassert>
StepLoadSignature::StepLoadSignature(const size_t signatureSize)
: m_signature(std::make_unique<uint8_t[]>(signatureSize)),
m_signature_size(signatureSize)
namespace
{
}
class StepLoadSignature final : public step::IStepLoadSignature
{
public:
explicit StepLoadSignature(const size_t signatureSize)
: m_signature(std::make_unique<uint8_t[]>(signatureSize)),
m_signature_size(signatureSize)
{
}
void StepLoadSignature::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
if (stream.Load(m_signature.get(), m_signature_size) != m_signature_size)
throw UnexpectedEndOfFileException();
}
void GetSignature(const uint8_t** pSignature, size_t* pSize) override
{
assert(pSignature != nullptr);
assert(pSize != nullptr);
assert(m_signature != nullptr);
*pSignature = m_signature.get();
*pSize = m_signature_size;
}
private:
std::unique_ptr<uint8_t[]> m_signature;
size_t m_signature_size;
};
} // namespace
namespace step
{
if (stream.Load(m_signature.get(), m_signature_size) != m_signature_size)
throw UnexpectedEndOfFileException();
}
void StepLoadSignature::GetSignature(const uint8_t** pSignature, size_t* pSize)
{
assert(pSignature != nullptr);
assert(pSize != nullptr);
assert(m_signature != nullptr);
*pSignature = m_signature.get();
*pSize = m_signature_size;
}
std::unique_ptr<IStepLoadSignature> CreateStepLoadSignature(const size_t signatureSize)
{
return std::make_unique<StepLoadSignature>(signatureSize);
}
} // namespace step

16
src/ZoneLoading/Loading/Steps/StepLoadSignature.h
View File

@ -5,15 +5,11 @@
#include <memory>
class StepLoadSignature final : public ILoadingStep, public ISignatureProvider
namespace step
{
public:
explicit StepLoadSignature(size_t signatureSize);
class IStepLoadSignature : public ILoadingStep, public ISignatureProvider
{
};
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
void GetSignature(const uint8_t** pSignature, size_t* pSize) override;
private:
std::unique_ptr<uint8_t[]> m_signature;
size_t m_signature_size;
};
std::unique_ptr<IStepLoadSignature> CreateStepLoadSignature(size_t signatureSize);
} // namespace step

45
src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
View File

@ -2,20 +2,37 @@
#include "Zone/Stream/ZoneInputStream.h"
StepLoadZoneContent::StepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint,
Zone* zone,
const int offsetBlockBitCount,
const block_t insertBlock)
: m_content_loader(std::move(entryPoint)),
m_zone(zone),
m_offset_block_bit_count(offsetBlockBitCount),
m_insert_block(insertBlock)
namespace
{
}
class StepLoadZoneContent final : public ILoadingStep
{
public:
StepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint, const int offsetBlockBitCount, const block_t insertBlock)
: m_content_loader(std::move(entryPoint)),
m_offset_block_bit_count(offsetBlockBitCount),
m_insert_block(insertBlock)
{
}
void StepLoadZoneContent::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
const auto inputStream = ZoneInputStream::Create(zoneLoader.m_blocks, stream, m_offset_block_bit_count, m_insert_block);
m_content_loader->Load(*inputStream);
}
private:
std::unique_ptr<IContentLoadingEntryPoint> m_content_loader;
int m_offset_block_bit_count;
block_t m_insert_block;
};
} // namespace
namespace step
{
const auto inputStream = ZoneInputStream::Create(zoneLoader.m_blocks, stream, m_offset_block_bit_count, m_insert_block);
m_content_loader->Load(*inputStream);
}
std::unique_ptr<ILoadingStep>
CreateStepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint, const int offsetBlockBitCount, const block_t insertBlock)
{
return std::make_unique<StepLoadZoneContent>(std::move(entryPoint), offsetBlockBitCount, insertBlock);
}
} // namespace step

16
src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
View File

@ -5,16 +5,8 @@
#include <memory>
class StepLoadZoneContent final : public ILoadingStep
namespace step
{
public:
StepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint, Zone* zone, int offsetBlockBitCount, block_t insertBlock);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
std::unique_ptr<IContentLoadingEntryPoint> m_content_loader;
Zone* m_zone;
int m_offset_block_bit_count;
block_t m_insert_block;
};
std::unique_ptr<ILoadingStep>
CreateStepLoadZoneContent(std::unique_ptr<IContentLoadingEntryPoint> entryPoint, int offsetBlockBitCount, block_t insertBlock);
}

51
src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.cpp
View File

@ -1,23 +1,42 @@
#include "StepLoadZoneSizes.h"
StepLoadZoneSizes::StepLoadZoneSizes()
: m_size(0),
m_external_size(0)
namespace
{
}
class StepLoadZoneSizes final : public step::IStepLoadZoneSizes
{
public:
StepLoadZoneSizes()
: m_size(0),
m_external_size(0)
{
}
void StepLoadZoneSizes::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
{
stream.Load(&m_size, sizeof(m_size));
stream.Load(&m_external_size, sizeof(m_external_size));
}
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
stream.Load(&m_size, sizeof(m_size));
stream.Load(&m_external_size, sizeof(m_external_size));
}
size_t StepLoadZoneSizes::GetSize() const
{
return m_size;
}
[[nodiscard]] uint32_t GetSize() const override
{
return m_size;
}
size_t StepLoadZoneSizes::GetExternalSize() const
[[nodiscard]] uint32_t GetExternalSize() const override
{
return m_external_size;
}
private:
uint32_t m_size;
uint32_t m_external_size;
};
} // namespace
namespace step
{
return m_external_size;
}
std::unique_ptr<IStepLoadZoneSizes> CreateStepLoadZoneSizes()
{
return std::make_unique<StepLoadZoneSizes>();
}
} // namespace step

23
src/ZoneLoading/Loading/Steps/StepLoadZoneSizes.h
View File

@ -2,19 +2,16 @@
#include "Loading/ILoadingStep.h"
#include <cstddef>
#include <memory>
class StepLoadZoneSizes final : public ILoadingStep
namespace step
{
public:
StepLoadZoneSizes();
class IStepLoadZoneSizes : public ILoadingStep
{
public:
[[nodiscard]] virtual uint32_t GetSize() const = 0;
[[nodiscard]] virtual uint32_t GetExternalSize() const = 0;
};
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
[[nodiscard]] size_t GetSize() const;
[[nodiscard]] size_t GetExternalSize() const;
private:
size_t m_size;
size_t m_external_size;
};
std::unique_ptr<IStepLoadZoneSizes> CreateStepLoadZoneSizes();
} // namespace step

34
src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp
View File

@ -2,14 +2,32 @@
#include <cassert>
StepRemoveProcessor::StepRemoveProcessor(StreamProcessor* streamProcessor)
: m_stream_processor(streamProcessor)
namespace
{
}
class StepRemoveProcessor final : public ILoadingStep
{
public:
explicit StepRemoveProcessor(const StreamProcessor* streamProcessor)
: m_stream_processor(streamProcessor)
{
}
void StepRemoveProcessor::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
assert(m_stream_processor != nullptr);
zoneLoader.RemoveStreamProcessor(m_stream_processor);
}
private:
const StreamProcessor* m_stream_processor;
};
} // namespace
namespace step
{
assert(m_stream_processor != nullptr);
zoneLoader.RemoveStreamProcessor(m_stream_processor);
}
std::unique_ptr<ILoadingStep> CreateStepRemoveProcessor(const StreamProcessor* streamProcessor)
{
return std::make_unique<StepRemoveProcessor>(streamProcessor);
}
} // namespace step

15
src/ZoneLoading/Loading/Steps/StepRemoveProcessor.h
View File

@ -1,14 +1,11 @@
#pragma once
#include "Loading/ILoadingStep.h"
#include "Loading/StreamProcessor.h"
class StepRemoveProcessor final : public ILoadingStep
#include <memory>
namespace step
{
public:
explicit StepRemoveProcessor(StreamProcessor* streamProcessor);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
StreamProcessor* m_stream_processor;
};
std::unique_ptr<ILoadingStep> CreateStepRemoveProcessor(const StreamProcessor* streamProcessor);
}

60
src/ZoneLoading/Loading/Steps/StepSkipBytes.cpp
View File

@ -1,30 +1,48 @@
#include "StepSkipBytes.h"
StepSkipBytes::StepSkipBytes(const size_t skipCount)
: m_skip_count(skipCount)
namespace
{
}
void StepSkipBytes::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
{
uint8_t tempBuffer[128];
auto skippedBytes = 0uz;
while (skippedBytes < m_skip_count)
class StepSkipBytes final : public ILoadingStep
{
size_t toSkip;
if (m_skip_count - skippedBytes < sizeof(tempBuffer))
public:
explicit StepSkipBytes(const size_t skipCount)
: m_skip_count(skipCount)
{
toSkip = m_skip_count - skippedBytes;
}
else
{
toSkip = sizeof(tempBuffer);
}
stream.Load(tempBuffer, toSkip);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
uint8_t tempBuffer[128];
auto skippedBytes = 0uz;
skippedBytes += toSkip;
while (skippedBytes < m_skip_count)
{
size_t toSkip;
if (m_skip_count - skippedBytes < sizeof(tempBuffer))
{
toSkip = m_skip_count - skippedBytes;
}
else
{
toSkip = sizeof(tempBuffer);
}
stream.Load(tempBuffer, toSkip);
skippedBytes += toSkip;
}
}
private:
size_t m_skip_count;
};
} // namespace
namespace step
{
std::unique_ptr<ILoadingStep> CreateStepSkipBytes(size_t skipCount)
{
return std::make_unique<StepSkipBytes>(skipCount);
}
}
} // namespace step

14
src/ZoneLoading/Loading/Steps/StepSkipBytes.h
View File

@ -2,13 +2,9 @@
#include "Loading/ILoadingStep.h"
class StepSkipBytes final : public ILoadingStep
#include <memory>
namespace step
{
public:
explicit StepSkipBytes(size_t skipCount);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
size_t m_skip_count;
};
std::unique_ptr<ILoadingStep> CreateStepSkipBytes(size_t skipCount);
}

81
src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp
View File

@ -4,42 +4,61 @@
#include <sstream>
StepVerifyFileName::StepVerifyFileName(std::string fileName, const size_t fileNameBufferSize)
: m_expected_file_name(std::move(fileName)),
m_file_name_buffer_size(fileNameBufferSize)
namespace
{
if (m_expected_file_name.length() > (m_file_name_buffer_size - 1))
m_expected_file_name.erase(m_file_name_buffer_size - 1);
}
void StepVerifyFileName::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
{
std::stringstream originalFilenameStream;
unsigned bufferOffset = 0;
char c;
for (; bufferOffset < m_file_name_buffer_size; bufferOffset++)
class StepVerifyFileName final : public ILoadingStep
{
stream.Load(&c, sizeof(char));
if (c == '\00')
public:
StepVerifyFileName(std::string fileName, const size_t fileNameBufferSize)
: m_expected_file_name(std::move(fileName)),
m_file_name_buffer_size(fileNameBufferSize)
{
bufferOffset++;
break;
if (m_expected_file_name.length() > (m_file_name_buffer_size - 1))
m_expected_file_name.erase(m_file_name_buffer_size - 1);
}
originalFilenameStream << c;
}
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
std::stringstream originalFilenameStream;
unsigned bufferOffset = 0;
char c;
// Skip the rest of the buffer which should be null bytes
while (bufferOffset < m_file_name_buffer_size)
for (; bufferOffset < m_file_name_buffer_size; bufferOffset++)
{
stream.Load(&c, sizeof(char));
if (c == '\00')
{
bufferOffset++;
break;
}
originalFilenameStream << c;
}
// Skip the rest of the buffer which should be null bytes
while (bufferOffset < m_file_name_buffer_size)
{
stream.Load(&c, sizeof(char));
bufferOffset++;
}
const auto originalFileName = originalFilenameStream.str();
if (originalFileName != m_expected_file_name)
throw InvalidFileNameException(m_expected_file_name, originalFileName);
}
private:
std::string m_expected_file_name;
size_t m_file_name_buffer_size;
};
} // namespace
namespace step
{
std::unique_ptr<ILoadingStep> CreateStepVerifyFileName(std::string fileName, const size_t fileNameBufferSize)
{
stream.Load(&c, sizeof(char));
bufferOffset++;
return std::make_unique<StepVerifyFileName>(std::move(fileName), fileNameBufferSize);
}
const auto originalFileName = originalFilenameStream.str();
if (originalFileName != m_expected_file_name)
throw InvalidFileNameException(m_expected_file_name, originalFileName);
}
} // namespace step

16
src/ZoneLoading/Loading/Steps/StepVerifyFileName.h
View File

@ -2,14 +2,10 @@
#include "Loading/ILoadingStep.h"
class StepVerifyFileName final : public ILoadingStep
#include <memory>
#include <string>
namespace step
{
public:
explicit StepVerifyFileName(std::string fileName, size_t fileNameBufferSize);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
std::string m_expected_file_name;
size_t m_file_name_buffer_size;
};
std::unique_ptr<ILoadingStep> CreateStepVerifyFileName(std::string fileName, size_t fileNameBufferSize);
}

83
src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp
View File

@ -2,38 +2,61 @@
#include "Loading/Exception/InvalidHashException.h"
#include <cstring>
#include <memory>
StepVerifyHash::StepVerifyHash(std::unique_ptr<cryptography::IHashFunction> hashFunction,
const unsigned hashIndex,
IHashProvider* hashProvider,
ICapturedDataProvider* dataProvider)
: m_hash_function(std::move(hashFunction)),
m_hash_index(hashIndex),
m_hash_provider(hashProvider),
m_data_provider(dataProvider)
namespace
{
}
class StepVerifyHash final : public ILoadingStep
{
public:
StepVerifyHash(std::unique_ptr<cryptography::IHashFunction> hashFunction,
const unsigned hashIndex,
IHashProvider* hashProvider,
ICapturedDataProvider* dataProvider)
: m_hash_function(std::move(hashFunction)),
m_hash_index(hashIndex),
m_hash_provider(hashProvider),
m_data_provider(dataProvider)
{
}
void StepVerifyHash::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
const uint8_t* dataToHash = nullptr;
size_t dataToHashSize = 0;
m_data_provider->GetCapturedData(&dataToHash, &dataToHashSize);
const uint8_t* hashData = nullptr;
size_t hashSize = 0;
m_hash_provider->GetHash(m_hash_index, &hashData, &hashSize);
if (hashSize != m_hash_function->GetHashSize())
throw InvalidHashException();
const auto hashMemory = std::make_unique<uint8_t[]>(m_hash_function->GetHashSize());
m_hash_function->Init();
m_hash_function->Process(dataToHash, dataToHashSize);
m_hash_function->Finish(hashMemory.get());
if (std::memcmp(hashData, hashMemory.get(), m_hash_function->GetHashSize()) != 0)
throw InvalidHashException();
}
private:
std::unique_ptr<cryptography::IHashFunction> m_hash_function;
unsigned m_hash_index;
IHashProvider* m_hash_provider;
ICapturedDataProvider* m_data_provider;
};
} // namespace
namespace step
{
const uint8_t* dataToHash = nullptr;
size_t dataToHashSize = 0;
m_data_provider->GetCapturedData(&dataToHash, &dataToHashSize);
const uint8_t* hashData = nullptr;
size_t hashSize = 0;
m_hash_provider->GetHash(m_hash_index, &hashData, &hashSize);
if (hashSize != m_hash_function->GetHashSize())
throw InvalidHashException();
const auto hashMemory = std::make_unique<uint8_t[]>(m_hash_function->GetHashSize());
m_hash_function->Init();
m_hash_function->Process(dataToHash, dataToHashSize);
m_hash_function->Finish(hashMemory.get());
if (std::memcmp(hashData, hashMemory.get(), m_hash_function->GetHashSize()) != 0)
throw InvalidHashException();
}
std::unique_ptr<ILoadingStep> CreateStepVerifyHash(std::unique_ptr<cryptography::IHashFunction> hashFunction,
unsigned hashIndex,
IHashProvider* hashProvider,
ICapturedDataProvider* dataProvider)
{
return std::make_unique<StepVerifyHash>(std::move(hashFunction), hashIndex, hashProvider, dataProvider);
}
} // namespace step

21
src/ZoneLoading/Loading/Steps/StepVerifyHash.h
View File

@ -7,19 +7,10 @@
#include <memory>
class StepVerifyHash final : public ILoadingStep
namespace step
{
public:
StepVerifyHash(std::unique_ptr<cryptography::IHashFunction> hashFunction,
unsigned hashIndex,
IHashProvider* hashProvider,
ICapturedDataProvider* dataProvider);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
std::unique_ptr<cryptography::IHashFunction> m_hash_function;
unsigned m_hash_index;
IHashProvider* m_hash_provider;
ICapturedDataProvider* m_data_provider;
};
std::unique_ptr<ILoadingStep> CreateStepVerifyHash(std::unique_ptr<cryptography::IHashFunction> hashFunction,
unsigned hashIndex,
IHashProvider* hashProvider,
ICapturedDataProvider* dataProvider);
}

47
src/ZoneLoading/Loading/Steps/StepVerifyMagic.cpp
View File

@ -4,21 +4,40 @@
#include <cstring>
StepVerifyMagic::StepVerifyMagic(const char* magic)
namespace
{
m_magic = magic;
m_magic_len = strlen(m_magic);
}
void StepVerifyMagic::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
{
char currentCharacter;
for (unsigned i = 0; i < m_magic_len; i++)
class StepVerifyMagic final : public ILoadingStep
{
stream.Load(&currentCharacter, sizeof(char));
public:
explicit StepVerifyMagic(const char* magic)
: m_magic(magic),
m_magic_len(strlen(m_magic))
{
}
if (currentCharacter != m_magic[i])
throw InvalidMagicException(m_magic);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
char currentCharacter;
for (unsigned i = 0; i < m_magic_len; i++)
{
stream.Load(&currentCharacter, sizeof(char));
if (currentCharacter != m_magic[i])
throw InvalidMagicException(m_magic);
}
}
private:
const char* m_magic;
size_t m_magic_len;
};
} // namespace
namespace step
{
std::unique_ptr<ILoadingStep> CreateStepVerifyMagic(const char* magic)
{
return std::make_unique<StepVerifyMagic>(magic);
}
}
} // namespace step

15
src/ZoneLoading/Loading/Steps/StepVerifyMagic.h
View File

@ -2,14 +2,9 @@
#include "Loading/ILoadingStep.h"
class StepVerifyMagic final : public ILoadingStep
#include <memory>
namespace step
{
public:
explicit StepVerifyMagic(const char* magic);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
const char* m_magic;
size_t m_magic_len;
};
std::unique_ptr<ILoadingStep> CreateStepVerifyMagic(const char* magic);
}

72
src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp
View File

@ -4,31 +4,53 @@
#include <cassert>
StepVerifySignature::StepVerifySignature(std::unique_ptr<cryptography::IPublicKeyAlgorithm> signatureAlgorithm,
ISignatureProvider* signatureProvider,
ICapturedDataProvider* signatureDataProvider)
: m_algorithm(std::move(signatureAlgorithm)),
m_signature_provider(signatureProvider),
m_signature_data_provider(signatureDataProvider)
namespace
{
}
void StepVerifySignature::PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream)
{
assert(m_algorithm != nullptr);
assert(m_signature_provider != nullptr);
assert(m_signature_data_provider != nullptr);
const uint8_t* signature;
size_t signatureSize;
m_signature_provider->GetSignature(&signature, &signatureSize);
const uint8_t* signatureData;
size_t signatureDataSize;
m_signature_data_provider->GetCapturedData(&signatureData, &signatureDataSize);
if (!m_algorithm->Verify(signatureData, signatureDataSize, signature, signatureSize))
class StepVerifySignature final : public ILoadingStep
{
throw InvalidSignatureException();
public:
StepVerifySignature(std::unique_ptr<cryptography::IPublicKeyAlgorithm> signatureAlgorithm,
ISignatureProvider* signatureProvider,
ICapturedDataProvider* signatureDataProvider)
: m_algorithm(std::move(signatureAlgorithm)),
m_signature_provider(signatureProvider),
m_signature_data_provider(signatureDataProvider)
{
}
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
{
assert(m_algorithm != nullptr);
assert(m_signature_provider != nullptr);
assert(m_signature_data_provider != nullptr);
const uint8_t* signature;
size_t signatureSize;
m_signature_provider->GetSignature(&signature, &signatureSize);
const uint8_t* signatureData;
size_t signatureDataSize;
m_signature_data_provider->GetCapturedData(&signatureData, &signatureDataSize);
if (!m_algorithm->Verify(signatureData, signatureDataSize, signature, signatureSize))
{
throw InvalidSignatureException();
}
}
private:
std::unique_ptr<cryptography::IPublicKeyAlgorithm> m_algorithm;
ISignatureProvider* m_signature_provider;
ICapturedDataProvider* m_signature_data_provider;
};
} // namespace
namespace step
{
std::unique_ptr<ILoadingStep> CreateStepVerifySignature(std::unique_ptr<cryptography::IPublicKeyAlgorithm> signatureAlgorithm,
ISignatureProvider* signatureProvider,
ICapturedDataProvider* signatureDataProvider)
{
return std::make_unique<StepVerifySignature>(std::move(signatureAlgorithm), signatureProvider, signatureDataProvider);
}
}
} // namespace step

20
src/ZoneLoading/Loading/Steps/StepVerifySignature.h
View File

@ -5,17 +5,11 @@
#include "Loading/ISignatureProvider.h"
#include "Utils/ICapturedDataProvider.h"
class StepVerifySignature final : public ILoadingStep
#include <memory>
namespace step
{
public:
StepVerifySignature(std::unique_ptr<cryptography::IPublicKeyAlgorithm> signatureAlgorithm,
ISignatureProvider* signatureProvider,
ICapturedDataProvider* signatureDataProvider);
void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override;
private:
std::unique_ptr<cryptography::IPublicKeyAlgorithm> m_algorithm;
ISignatureProvider* m_signature_provider;
ICapturedDataProvider* m_signature_data_provider;
};
std::unique_ptr<ILoadingStep> CreateStepVerifySignature(std::unique_ptr<cryptography::IPublicKeyAlgorithm> signatureAlgorithm,
ISignatureProvider* signatureProvider,
ICapturedDataProvider* signatureDataProvider);
}