Read IW4 signed headers

src/ZoneLoading/Loading/Processor/ProcessorAuthedBlocks.cpp

@@ -0,0 +1,47 @@
+#include "ProcessorAuthedBlocks.h"
+
+class ProcessorAuthedBlocks::Impl final : public StreamProcessor
+{
+    const int m_authed_chunk_count;
+    const int m_max_master_block_count;
+    IHashProvider* m_hash_provider;
+
+public:
+    Impl(const int authedChunkCount, const int maxMasterBlockCount, IHashProvider* masterBlockHashProvider)
+        : m_authed_chunk_count(authedChunkCount),
+          m_max_master_block_count(maxMasterBlockCount),
+          m_hash_provider(masterBlockHashProvider)
+    {
+    }
+
+    size_t Load(void* buffer, size_t length) override
+    {
+        return 0;
+    }
+
+    int64_t Pos() override
+    {
+        return 0;
+    }
+};
+
+ProcessorAuthedBlocks::ProcessorAuthedBlocks(const int authedChunkCount, const int maxMasterBlockCount, IHashProvider* masterBlockHashProvider)
+    : m_impl(new Impl(authedChunkCount, maxMasterBlockCount, masterBlockHashProvider))
+{
+}
+
+ProcessorAuthedBlocks::~ProcessorAuthedBlocks()
+{
+    delete m_impl;
+    m_impl = nullptr;
+}
+
+size_t ProcessorAuthedBlocks::Load(void* buffer, const size_t length)
+{
+    return m_impl->Load(buffer, length);
+}
+
+int64_t ProcessorAuthedBlocks::Pos()
+{
+    return m_impl->Pos();
+}

src/ZoneLoading/Loading/Processor/ProcessorAuthedBlocks.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "Loading/StreamProcessor.h"
+#include "Loading/IHashProvider.h"
+
+class ProcessorAuthedBlocks : public StreamProcessor
+{
+    class Impl;
+    Impl* m_impl;
+
+public:
+    ProcessorAuthedBlocks(int authedChunkCount, int maxMasterBlockCount, IHashProvider* masterBlockHashProvider);
+    ~ProcessorAuthedBlocks() override;
+
+    size_t Load(void* buffer, size_t length) override;
+    int64_t Pos() override;
+};

src/ZoneLoading/Loading/Processor/ProcessorCaptureData.cpp

@@ -0,0 +1,50 @@
+#include "ProcessorCaptureData.h"
+
+#include <cassert>
+
+ProcessorCaptureData::ProcessorCaptureData(const size_t captureSize)
+    : m_data(std::make_unique<uint8_t[]>(captureSize)),
+      m_capture_size(captureSize),
+      m_captured_data_size(0)
+{
+}
+
+ProcessorCaptureData::~ProcessorCaptureData()
+= default;
+
+size_t ProcessorCaptureData::Load(void* buffer, const size_t length)
+{
+    if (m_captured_data_size >= m_capture_size)
+        return m_base_stream->Load(buffer, length);
+
+    size_t dataToCapture = m_capture_size - m_captured_data_size;
+
+    if (length < dataToCapture)
+        dataToCapture = length;
+
+    size_t loadedSize = m_base_stream->Load(&m_data[m_captured_data_size], dataToCapture);
+    memcpy_s(buffer, length, &m_data[m_captured_data_size], loadedSize);
+
+    m_captured_data_size += loadedSize;
+
+    if(length > dataToCapture)
+        loadedSize += m_base_stream->Load(&static_cast<uint8_t*>(buffer)[dataToCapture], length - dataToCapture);
+
+    return loadedSize;
+}
+
+int64_t ProcessorCaptureData::Pos()
+{
+    return m_base_stream->Pos();
+}
+
+void ProcessorCaptureData::GetCapturedData(const uint8_t** pCapturedData, size_t* pSize)
+{
+    assert(pCapturedData != nullptr);
+    assert(pSize != nullptr);
+
+    assert(m_captured_data_size == m_capture_size);
+
+    *pCapturedData = m_data.get();
+    *pSize = m_captured_data_size;
+}

src/ZoneLoading/Loading/Processor/ProcessorCaptureData.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <memory>
+
+#include "Loading/StreamProcessor.h"
+#include "Loading/ICapturedDataProvider.h"
+
+class ProcessorCaptureData final : public StreamProcessor, public ICapturedDataProvider
+{
+    std::unique_ptr<uint8_t[]> m_data;
+    const size_t m_capture_size;
+    size_t m_captured_data_size;
+
+public:
+    explicit ProcessorCaptureData(size_t captureSize);
+    ~ProcessorCaptureData() override;
+
+    size_t Load(void* buffer, size_t length) override;
+    int64_t Pos() override;
+    void GetCapturedData(const uint8_t** pCapturedData, size_t* pSize) override;
+};

src/ZoneLoading/Loading/Processor/XChunks/ChunkProcessorSalsa20.cpp

@@ -150,7 +150,7 @@ size_t ChunkProcessorSalsa20::Process(const int streamNumber, const uint8_t* inp
     return m_impl->Process(streamNumber, input, inputLength, output, outputBufferSize);
 }
 
-void ChunkProcessorSalsa20::GetSignatureData(const uint8_t** pSignatureData, size_t* pSize)
+void ChunkProcessorSalsa20::GetCapturedData(const uint8_t** pCapturedData, size_t* pSize)
 {
-    m_impl->GetSignatureData(pSignatureData, pSize);
+    m_impl->GetSignatureData(pCapturedData, pSize);
 }

src/ZoneLoading/Loading/Processor/XChunks/ChunkProcessorSalsa20.h

@@ -1,9 +1,9 @@
 #pragma once
 #include "IXChunkProcessor.h"
-#include "Loading/ISignatureDataProvider.h"
+#include "Loading/ICapturedDataProvider.h"
 #include <string>
 
-class ChunkProcessorSalsa20 : public IXChunkProcessor, public ISignatureDataProvider
+class ChunkProcessorSalsa20 : public IXChunkProcessor, public ICapturedDataProvider
 {
     class ChunkProcessorSalsa20Impl;
     ChunkProcessorSalsa20Impl* m_impl;
@@ -13,5 +13,5 @@ public:
     ~ChunkProcessorSalsa20() override;
 
     size_t Process(int streamNumber, const uint8_t* input, size_t inputLength, uint8_t* output, size_t outputBufferSize) override;
-    void GetSignatureData(const uint8_t** pSignatureData, size_t* pSize) override;
+    void GetCapturedData(const uint8_t** pCapturedData, size_t* pSize) override;
 };