VPK.h

Go to the documentation of this file.

// ReSharper disable CppRedundantQualifier
 
#pragma once
 
#include <array>
 
#include "../PackFile.h"
 
namespace vpkpp {
 
constexpr uint32_t VPK_SIGNATURE = 0x55aa1234;
constexpr uint16_t VPK_DIR_INDEX = 0x7fff;
constexpr uint16_t VPK_ENTRY_TERM = 0xffff;
constexpr std::string_view VPK_DIR_SUFFIX = "_dir";
constexpr std::string_view VPK_EXTENSION = ".vpk";
 
constexpr std::string_view VPK_KEYPAIR_PUBLIC_KEY_TEMPLATE = "public_key\n{\n\ttype \"rsa\"\n\trsa_public_key \"%s\"\n}\n";
constexpr std::string_view VPK_KEYPAIR_PRIVATE_KEY_TEMPLATE = "private_key\n{\n\ttype \"rsa\"\n\trsa_private_key \"%s\"\n\tprivate_key_encrypted 0\n\tpublic_key\n\t{\n\t\ttype \"rsa\"\n\t\trsa_public_key \"%s\"\n\t}\n}\n";

constexpr uint16_t VPK_MAX_PRELOAD_BYTES = 1024;

constexpr uint32_t VPK_DEFAULT_CHUNK_SIZE = 200 * 1024 * 1024;
 
class VPK : public PackFile {
protected:
#pragma pack(push, 1)
    struct Header1 {
        uint32_t signature;
        uint32_t version;
        uint32_t treeSize;
    };
 
    struct Header2 {
        uint32_t fileDataSectionSize;
        uint32_t archiveMD5SectionSize;
        uint32_t otherMD5SectionSize;
        uint32_t signatureSectionSize;
    };
 
    struct Footer2 {
        std::array<std::byte, 16> treeChecksum{};
        std::array<std::byte, 16> md5EntriesChecksum{};
        std::array<std::byte, 16> wholeFileChecksum{};
        std::vector<std::byte> publicKey{};
        std::vector<std::byte> signature{};
    };
 
    struct MD5Entry {
        uint32_t archiveIndex;
        uint32_t offset;
        uint32_t length;
        std::array<std::byte, 16> checksum;
    };
#pragma pack(pop)
 
    struct FreedChunk {
        uint64_t offset;
        uint64_t length;
        uint32_t archiveIndex;
    };
 
public:
    static std::unique_ptr<PackFile> create(const std::string& path, uint32_t version = 2);

    [[nodiscard]] static std::unique_ptr<PackFile> open(const std::string& path, const EntryCallback& callback = nullptr);
 
    static constexpr std::string_view GUID = "98148F7C8701469CB2D8F8620FD738A3";
 
    [[nodiscard]] constexpr std::string_view getGUID() const override {
        return VPK::GUID;
    }
 
    [[nodiscard]] constexpr bool hasEntryChecksums() const override {
        return true;
    }
 
    [[nodiscard]] std::vector<std::string> verifyEntryChecksums() const override;
 
    [[nodiscard]] bool hasPackFileChecksum() const override;
 
    [[nodiscard]] bool verifyPackFileChecksum() const override;
 
    [[nodiscard]] bool hasPackFileSignature() const override;
 
    [[nodiscard]] bool verifyPackFileSignature() const override;
 
    [[nodiscard]] std::optional<std::vector<std::byte>> readEntry(const std::string& path_) const override;
 
    bool removeEntry(const std::string& filename_) override;
 
    std::size_t removeDirectory(const std::string& dirName_) override;
 
    bool bake(const std::string& outputDir_ /*= ""*/, BakeOptions options /*= {}*/, const EntryCallback& callback /*= nullptr*/) override;
 
    [[nodiscard]] std::string getTruncatedFilestem() const override;
 
    [[nodiscard]] Attribute getSupportedEntryAttributes() const override;
 
    [[nodiscard]] explicit operator std::string() const override;

    static bool generateKeyPairFiles(const std::string& name);

    bool sign(const std::string& filename_);

    bool sign(const std::vector<std::byte>& privateKey, const std::vector<std::byte>& publicKey);

    [[nodiscard]] uint32_t getVersion() const;

    void setVersion(uint32_t version);

    [[nodiscard]] uint32_t getChunkSize() const;

    void setChunkSize(uint32_t newChunkSize);
 
protected:
    using PackFile::PackFile;
 
    [[nodiscard]] static std::unique_ptr<PackFile> openInternal(const std::string& path, const EntryCallback& callback = nullptr);
 
    void addEntryInternal(Entry& entry, const std::string& path, std::vector<std::byte>& buffer, EntryOptions options) override;
 
    [[nodiscard]] bool hasExtendedHeader() const;
 
    [[nodiscard]] bool hasCompression() const;
 
    [[nodiscard]] uint32_t getHeaderLength() const;
 
    int32_t numArchives = -1;
    uint32_t currentlyFilledChunkSize = 0;
    uint32_t chunkSize = VPK_DEFAULT_CHUNK_SIZE;
 
    std::vector<FreedChunk> freedChunks;
 
    Header1 header1{}; // Present in all VPK versions
    Header2 header2{}; // Present in VPK v2
    Footer2 footer2{}; // Present in VPK v2
 
    std::vector<MD5Entry> md5Entries;
 
private:
    VPKPP_REGISTER_PACKFILE_OPEN(VPK_EXTENSION, &VPK::open);
};
 
} // namespace vpkpp