yanczi/VoidArchive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'streaming'

Browse source
This commit is contained in:
yanczi 2025-12-23 21:43:41 +01:00
commit f9ea960cf0
24 changed files with 582 additions and 722 deletions
Download patch file Download diff file Expand all files Collapse all files

114
ChunkManager.cpp
View file

@ -1,114 +0,0 @@
#include "ChunkManager.h"
ChunkManager::ChunkManager(EncryptionManager& em)
:eman(em)
{ }
ChunkManager::~ChunkManager()
{ }
//-----------------------------------------------------------------------------
// Kompresja blokowa
//
// Dzielenie vectora na chunki dok³adnie po 128KB
// Kompresowanie chunków bez nag³ówka
//-----------------------------------------------------------------------------
std::vector<char> ChunkManager::chunked(const std::vector<char>& raw, const bool& compress, const bool& encrypt)
{
//std::vector<BlockSize> blockSizes;
// Maksymalny rozmiar chunka
const size_t maxBlockSize = BLOCK_SIZE;
const size_t rawSize = raw.size();
uint16_t blockLen = 0;
uint32_t lastChunkRawSize;
std::vector<char> compressedBlocks;
for (size_t offset = 0; offset < rawSize; offset += maxBlockSize)
{
// Rozmiar chunka
const size_t chunkSize = std::min(maxBlockSize, rawSize - offset);
auto begin = raw.begin() + offset;
auto end = begin + chunkSize;
// Skopiuj fragment danych do chunka
std::vector<char> chunk(begin, end);
std::vector<char> outChunk;
// Przetwórz chunki i przetwórz
if (compress)
{
// Zaszyfruj i skompresuj lub tylko skompresuj
outChunk = encrypt ? eman.encrypt(cman.compress(chunk)) : cman.compress(chunk);
}
else
{
// Zaszyfruj lub skopiuj
outChunk = encrypt ? eman.encrypt(chunk) : std::move(chunk);
}
uint32_t chs = chunk.size();
uint32_t zch = outChunk.size();
//addIntToVector<uint32_t>(compressedBlocks, chs);
lastChunkRawSize = chs;
addIntToVector<uint32_t>(compressedBlocks, zch);
compressedBlocks.insert(compressedBlocks.end(), outChunk.begin(), outChunk.end());
blockLen++;
}
std::vector<char> zip;
// Wstaw liczbê o iloœci bloków do vectora;
// Przekonpwertuj usigned int32 na ci¹g znkaów
// uint16_t blockLen = blockSizes .size();
addIntToVector<uint16_t>(zip, blockLen);
addIntToVector<uint32_t>(zip, maxBlockSize);
addIntToVector<uint32_t>(zip, lastChunkRawSize);
// Dodaj skompresowane dane
zip.insert(zip.end(), compressedBlocks.begin(), compressedBlocks.end());
return zip;
}
//////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
// Dekompresja blokowa
//-----------------------------------------------------------------------------
std::vector<char> ChunkManager::dechunked(const std::vector<char>& zip, const bool& compress, const bool& encrypt)
{
size_t offset = 0;
const uint16_t chunkLen = getIntFromVector<uint16_t>(zip, offset);
const uint32_t chunkBeforeSize = getIntFromVector<uint32_t>(zip, offset);
const uint32_t chunkLastSize = getIntFromVector<uint32_t>(zip, offset);
std::vector<char> chunksString;
// Dekompresja bloków
for (size_t i = 0; i < chunkLen; ++i)
{
// Pobierz rozmiar chunków przed i po skompresowaniem
uint32_t chunkSize = i < chunkLen - 1 ? chunkBeforeSize : chunkLastSize;
uint32_t chunkZipSize = getIntFromVector<uint32_t>(zip, offset);
// Pobierz blok chunka
std::vector<char> inChunk(chunkZipSize);
std::memcpy(inChunk.data(), zip.data() + offset, chunkZipSize);
offset += chunkZipSize;
// Jeœli flaga encrypt jest aktywna najpierw zdeszyfruj blok
std::vector<char> zipChunk = encrypt ? eman.decrypt(inChunk) : std::move(inChunk);
// Zdeklarój pusty chunk
std::vector<char> chunk = compress ? cman.decompress(zipChunk, chunkSize) : std::move(zipChunk);
// Scal chunki
chunksString.insert(chunksString.end(), chunk.begin(), chunk.end());
}
return chunksString;
}

51
ChunkManager.h
View file

@ -1,51 +0,0 @@
#pragma once
#include <vector>
#include <cstdint>
#include <cstring>
#include <stdexcept>
#include <algorithm>
#include <iostream>
#include "EncryptionManager.h"
#include "CompressionManager.h"
#define BLOCK_SIZE 131072 // 128KB
class ChunkManager
{
public:
ChunkManager(EncryptionManager& em);
~ChunkManager();
// Kompresja danych
std::vector<char> chunked(const std::vector<char>&, const bool&, const bool&);
// Dekompresja
std::vector<char> dechunked(const std::vector<char>&, const bool&, const bool&);
private:
EncryptionManager eman;
CompressionManager cman;
// Przekonwertuj zmienn¹ na ci¹g na vector
template <typename T>
void addIntToVector(std::vector<char>& vec, const T& val)
{
size_t tmpSize = vec.size();
vec.resize(tmpSize + sizeof(val));
std::memcpy(vec.data() + tmpSize, &val, sizeof(val));
}
// Pobierz zmienn¹ z vectora
template <typename T>
T getIntFromVector(const std::vector<char>& vec, size_t& offset)
{
T tmp{};
std::memcpy(&tmp, vec.data() + offset, sizeof(tmp));
offset += sizeof(tmp);
return tmp;
}
};

19
CompressionManager.cpp
View file

@ -1,3 +1,22 @@
/*
* This file is part of VoidArchiveTool.
*
* Copyright (C) 2025 Yanczi
*
* Void Archive Toolis free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "CompressionManager.h" #include "CompressionManager.h"
CompressionManager::CompressionManager() CompressionManager::CompressionManager()

19
CompressionManager.h
View file

@ -1,3 +1,22 @@
/*
* This file is part of VoidArchiveTool.
*
* Copyright (C) 2025 Yanczi
*
* Void Archive Toolis free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <iostream> #include <iostream>

242
CreateCargo.cpp
View file

@ -20,14 +20,16 @@
#include "CreateCargo.h" #include "CreateCargo.h"
CreateCargo::CreateCargo() CreateCargo::CreateCargo()
: signature(SIGNATURE) : signature(fl::sigpak)
, extension(EXTENSION) , extension(fl::extpak)
, version(VERSION) , version(VERSION)
, methodFlags(0) , methodFlags(0)
, xxhState(XXH64_createState())
, offset(0) , offset(0)
, hppKey(false) , hppKey(false)
{ {
// TODO Auto-generated constructor stub // TODO Auto-generated constructor stub
XXH64_reset(xxhState, 0);
} }
CreateCargo::~CreateCargo() { CreateCargo::~CreateCargo() {
@ -38,7 +40,7 @@ CreateCargo::~CreateCargo() {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Punk wej𦣇ia do tworzenia archivum // Punk wej𦣇ia do tworzenia archivum
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool CreateCargo::Create(const std::string& path, const int16_t& flag) bool CreateCargo::Create(const std::string& path, const uint8_t& flag)
{ {
cargoFile = path + "." + extension; cargoFile = path + "." + extension;
catalogPath = path; catalogPath = path;
@ -88,9 +90,9 @@ bool CreateCargo::Create(const std::string& path, const int16_t& flag)
} }
// Zapisywanie klucza szyfruj鉍ego // Zapisywanie klucza szyfruj鉍ego
if (flag == 2 || flag == 3 || encList.size() > 0) if (flag == flag::enc || flag == flag::ezd || encList.size() > 0)
{ {
crypt.saveKey(catalogPath, hppKey); eman.saveKey(catalogPath, hppKey);
} }
return true; return true;
@ -111,29 +113,37 @@ bool CreateCargo::GetFileList(const std::string& path)
else else
{ {
std::string fileRef = RemoveStartPath(PathToUnixLike(tmpPath)); std::string fileRef = RemoveStartPath(PathToUnixLike(tmpPath));
PathConf pc;
if (methodFlags > -1) if (fileRef.length() > 255)
{ {
pc.path = PathToUnixLike(tmpPath); std::cerr << "The file path is too long. It exceeds 255 characters." << std::endl;
pc.parameter = methodFlags;
filesPaths.push_back(pc);
} }
else else
{ {
if (!FindOnTheList(ignoreList, fileRef) || !CheckFileExtension(fileRef, ignoreList)) PathConf pc;
if (methodFlags != 0xAB)
{ {
if (FindOnTheList(zipList, fileRef) || CheckFileExtension(fileRef, zipList))
{
pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? 3 : 1;
}
else
{
pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? 2 : 0;
}
pc.path = PathToUnixLike(tmpPath); pc.path = PathToUnixLike(tmpPath);
std::cout << pc.path << " - " << pc.parameter << std::endl; pc.parameter = methodFlags;
filesPaths.push_back(pc); filesPaths.push_back(pc);
} }
else
{
if (!FindOnTheList(ignoreList, fileRef) || !CheckFileExtension(fileRef, ignoreList))
{
if (FindOnTheList(zipList, fileRef) || CheckFileExtension(fileRef, zipList))
{
pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? FILE_FLAG_ZIPENC : FILE_FLAG_COMPRESS;
}
else
{
pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? FILE_FLAG_ENCRYPT : FILE_FLAG_RAW;
}
pc.path = PathToUnixLike(tmpPath);
std::cout << pc.path << " - " << pc.parameter << std::endl;
filesPaths.push_back(pc);
}
}
} }
} }
} }
@ -175,47 +185,13 @@ CargoHead CreateCargo::CreateCargoHead(const uint32_t& filesLen, const uint64_t&
{ {
CargoHead ch; CargoHead ch;
ch.signature = signature; ch.signature = fl::sigpak;
ch.version = version;
ch.files = filesLen;
ch.table = table; ch.table = table;
ch.files = filesLen;
return ch; return ch;
} }
//-----------------------------------------------------------------------------
// Sprawdza czy plik znajduje siê na liœcie
//-----------------------------------------------------------------------------
void CreateCargo::computingBytes(const int16_t& flag, std::vector<char>& input, std::vector<char>& output)
{
//Flaga aktywna sprawdza czy plik jest na liœcie. Jeœli jest to zwraca surowedane
//Przeciwnie kompresuje dane
ChunkManager cm(crypt);
switch (flag)
{
case 1:
output = cm.chunked(input, true, false);
break;
case 2:
output = cm.chunked(input, false, true);
break;
case 3:
output = cm.chunked(input, true, true);
break;
case 4:
output = cm.chunked(input, false, false);
break;
default:
output = std::move(input);
break;
}
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Przygotowanie nag堯wk闚 i plik闚 // Przygotowanie nag堯wk闚 i plik闚
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -223,13 +199,12 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
{ {
//Utw鏎z header TMP. Zabezpiecza Pierwsze bajty na w豉𦣇iwy nag堯wek //Utw鏎z header TMP. Zabezpiecza Pierwsze bajty na w豉𦣇iwy nag堯wek
CargoHead cargoHead = CreateCargoHead(0, 0); CargoHead cargoHead = CreateCargoHead(0, 0);
offset += cargoHead.signature.length() + sizeof(cargoHead.version) + sizeof(cargoHead.files) + sizeof(cargoHead.table); offset += cargoHead.signature.length() + sizeof(cargoHead.files) + sizeof(cargoHead.table);
//Zapisanie tymczasowego nag這wka jako rezerwacja miejsca //Zapisanie tymczasowego nag這wka jako rezerwacja miejsca
cargo.write(cargoHead.signature.data(), cargoHead.signature.length()); cargo.write(cargoHead.signature.data(), cargoHead.signature.length());
cargo.write(reinterpret_cast<const char*>(&cargoHead.version), sizeof(cargoHead.version));
cargo.write(reinterpret_cast<const char*>(&cargoHead.files), sizeof(cargoHead.files));
cargo.write(reinterpret_cast<const char*>(&cargoHead.table), sizeof(cargoHead.table)); cargo.write(reinterpret_cast<const char*>(&cargoHead.table), sizeof(cargoHead.table));
cargo.write(reinterpret_cast<const char*>(&cargoHead.files), sizeof(cargoHead.files));
std::vector<FilesTable> filesTable; std::vector<FilesTable> filesTable;
@ -239,36 +214,108 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
std::string path = PathToUnixLike(RemoveStartPath(file.path)); std::string path = PathToUnixLike(RemoveStartPath(file.path));
std::ifstream f(file.path, std::ios::binary | std::ios::ate); std::ifstream f(file.path, std::ios::binary | std::ios::ate);
std::cout << path << std::endl;
//Obliczanie rozmiaru pliku //Obliczanie rozmiaru pliku
size_t size = f.tellg(); size_t size = f.tellg();
f.seekg(0, std::ios::beg); f.seekg(0, std::ios::beg);
//Wczytanie pliku do pamiêci if (size > ds::maxFileSize)
std::vector<char> buffer(size); {
f.read(buffer.data(), size); std::cerr << path << " is too large. It exceeds " << ds::maxFileSize / 1024 / 1024 / 1024 << "GB!" << std::endl;
f.close(); }
else
{
XXH64_reset(xxhState, 0);
//Tworzenie hashu CRC //Wczytanie pliku do pamiêci
const uint64_t crc = XXH64(buffer.data(), buffer.size(), VERSION); std::vector<char> buffer(ds::chunk_stream);
//Kompresjia uint64_t sizeFile = 0;
std::vector<char> pakBuffer;
computingBytes(file.parameter, buffer, pakBuffer);
FilesTable ft; const uint32_t chunkBlockSize = ds::block_size;
ft.nameFile = path; const uint32_t quantity = (size + chunkBlockSize) / chunkBlockSize;
ft.nameLen = path.length(); const uint32_t lastChunkSize = size - (chunkBlockSize * (quantity - 1));
ft.hashName = fnv64(path);
ft.offset = offset;
ft.size = pakBuffer.size();
ft.flag = file.parameter;
ft.crc = crc;
cargo.write(reinterpret_cast<const char*>(pakBuffer.data()), pakBuffer.size()); // Jeœli jest ustawiona flaga inna ni¿ RAW
// Dodaj do kontenera konfiguracjê chunków
if (file.parameter != flag::raw)
{
cargo.write(reinterpret_cast<const char*>(&quantity), sizeof(quantity));
cargo.write(reinterpret_cast<const char*>(&chunkBlockSize), sizeof(chunkBlockSize));
cargo.write(reinterpret_cast<const char*>(&lastChunkSize), sizeof(lastChunkSize));
sizeFile = sizeof(quantity) + sizeof(chunkBlockSize) + sizeof(lastChunkSize);
}
filesTable.push_back(ft); // Strumieniowanie danych
offset += pakBuffer.size(); while (f.read(buffer.data(), ds::chunk_stream) || f.gcount() > 0)
{
const int bufferSize = f.gcount();
buffer.resize(bufferSize);
// Aktualizacja XXH64
XXH64_update(xxhState, buffer.data(), buffer.size());
if (file.parameter == flag::raw)
{
// Zapisywanie strumienia do kontenera
cargo.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
sizeFile += bufferSize;
}
else
{
for (uint32_t ofs = 0; ofs < bufferSize; ofs += chunkBlockSize)
{
// Rozmiar chunka
const uint32_t chunkSize = std::min(chunkBlockSize, bufferSize - ofs);
auto begin = buffer.begin() + ofs;
auto end = begin + chunkSize;
// Skopiuj fragment danych do chunka
std::vector<char> chunk(begin, end);
std::vector<char> outChunk;
// Przetwórz chunki i przetwórz
if ((file.parameter & flag::zip) == flag::zip)
{
// Zaszyfruj i skompresuj lub tylko skompresuj
outChunk = (file.parameter & flag::enc) == flag::enc ?
eman.encrypt(cman.compress(chunk)) : cman.compress(chunk);
}
else
{
// Zaszyfruj lub skopiuj
outChunk = eman.encrypt(chunk);
}
const uint32_t outSize = outChunk.size();
cargo.write(reinterpret_cast<const char*>(&outSize), sizeof(outSize));
sizeFile += sizeof(outSize);
cargo.write(reinterpret_cast<const char*>(outChunk.data()), outChunk.size());
sizeFile += outSize;
}
}
}
f.close();
FilesTable ft;
ft.nameFile = path;
ft.nameLen = path.length();
ft.offset = offset;
ft.size = sizeFile;
ft.flag = file.parameter;
ft.crc = XXH64_digest(xxhState);
filesTable.push_back(ft);
offset += sizeFile;
}
} }
return filesTable; return filesTable;
} }
@ -285,24 +332,25 @@ void CreateCargo::GetFilters(const std::string& filterFile)
file.close(); file.close();
// Lista plik闚 do skompresowania // Lista plik闚 do skompresowania
if (jslist.contains(KEY_ZIP)) if (jslist.contains(key::zip))
{ {
zipList = jslist[KEY_ZIP].get<std::vector<std::string>>(); zipList = jslist[key::zip].get<std::vector<std::string>>();
} }
// Lista plik闚 do zaszyfrowania // Lista plik闚 do zaszyfrowania
if (jslist.contains(KEY_ENCRYPT)) if (jslist.contains(key::enc))
{ {
encList = jslist[KEY_ENCRYPT].get<std::vector<std::string>>(); encList = jslist[key::enc].get<std::vector<std::string>>();
} }
// Lista plik闚 do pomini璚ia // Lista plik闚 do pomini璚ia
if (jslist.contains(KEY_IGNORE)) if (jslist.contains(key::ignore))
{ {
ignoreList = jslist[KEY_IGNORE].get<std::vector<std::string>>(); ignoreList = jslist[key::ignore].get<std::vector<std::string>>();
} }
hppKey = jslist.value("keyhpp", false); // Flaga tworzenia klucza jako plik nag³ówka c++
hppKey = jslist.value(key::hpp, false);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -342,24 +390,6 @@ std::string CreateCargo::UpperString(std::string s) {
return s; return s;
} }
//-----------------------------------------------------------------------------
// Wygenerój FNV-1a HASH
//-----------------------------------------------------------------------------
uint64_t CreateCargo::fnv64(const std::string& data)
{
const uint64_t fnvOffset = 14695981039346656037u;
const uint64_t fnvPrime = 1099511628211u;
uint64_t hash = fnvOffset;
for (unsigned char c : data)
{
hash ^= c;
hash *= fnvPrime;
}
return hash;
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Trworzenie archiwum // Trworzenie archiwum
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -386,7 +416,6 @@ bool CreateCargo::WriteCargo()
cargo.write(reinterpret_cast<const char*>(&head.nameLen), sizeof(head.nameLen)); cargo.write(reinterpret_cast<const char*>(&head.nameLen), sizeof(head.nameLen));
cargo.write(head.nameFile.data(), head.nameLen); cargo.write(head.nameFile.data(), head.nameLen);
cargo.write(reinterpret_cast<const char*>(&head.hashName), sizeof(head.hashName));
cargo.write(reinterpret_cast<const char*>(&head.offset), sizeof(head.offset)); cargo.write(reinterpret_cast<const char*>(&head.offset), sizeof(head.offset));
cargo.write(reinterpret_cast<const char*>(&head.size), sizeof(head.size)); cargo.write(reinterpret_cast<const char*>(&head.size), sizeof(head.size));
cargo.write(reinterpret_cast<const char*>(&head.crc), sizeof(head.crc)); cargo.write(reinterpret_cast<const char*>(&head.crc), sizeof(head.crc));
@ -401,9 +430,8 @@ bool CreateCargo::WriteCargo()
//Nadpisz tymczasowy nag堯wek //Nadpisz tymczasowy nag堯wek
cargo.write(cargoHead.signature.data(), cargoHead.signature.length()); cargo.write(cargoHead.signature.data(), cargoHead.signature.length());
cargo.write(reinterpret_cast<const char*>(&cargoHead.version), sizeof(cargoHead.version));
cargo.write(reinterpret_cast<const char*>(&cargoHead.files), sizeof(cargoHead.files));
cargo.write(reinterpret_cast<const char*>(&cargoHead.table), sizeof(cargoHead.table)); cargo.write(reinterpret_cast<const char*>(&cargoHead.table), sizeof(cargoHead.table));
cargo.write(reinterpret_cast<const char*>(&cargoHead.files), sizeof(cargoHead.files));
cargo.close(); cargo.close();

33
CreateCargo.h
View file

@ -33,8 +33,8 @@
#include <nlohmann/json.hpp> #include <nlohmann/json.hpp>
#include "DataStruct.h" #include "DataStruct.h"
#include "ChunkManager.h"
#include "EncryptionManager.h" #include "EncryptionManager.h"
#include "CompressionManager.h"
#define KEY_ZIP "compress" // Pliki do skompresowania #define KEY_ZIP "compress" // Pliki do skompresowania
@ -44,10 +44,21 @@
#define ALL_FILE ".*" // Wszystkie pliki #define ALL_FILE ".*" // Wszystkie pliki
namespace key
{
inline constexpr std::string_view zip = "compress";
inline constexpr std::string_view raw = "raw";
inline constexpr std::string_view enc = "encrypt";
inline constexpr std::string_view ignore = "ignore";
inline constexpr std::string_view all = ".*";
inline constexpr std::string_view hpp = "keyhpp";
}
struct PathConf struct PathConf
{ {
std::string path; std::string path;
int16_t parameter; uint8_t parameter;
}; };
class CreateCargo { class CreateCargo {
@ -56,14 +67,16 @@ public:
virtual ~CreateCargo(); virtual ~CreateCargo();
// Punk wejœcia do tworzenia archivum // Punk wejœcia do tworzenia archivum
bool Create(const std::string&, const int16_t&); bool Create(const std::string&, const uint8_t&);
private: private:
const std::string signature; const std::string signature;
const std::string extension; const std::string extension;
const short version; const signed char version;
short methodFlags; uint8_t methodFlags;
XXH64_state_t* xxhState;
std::string catalogPath; std::string catalogPath;
@ -72,7 +85,8 @@ private:
std::vector<std::string> filesList; std::vector<std::string> filesList;
EncryptionManager crypt; EncryptionManager eman;
CompressionManager cman;
bool hppKey; bool hppKey;
// listy wyj¹tków // listy wyj¹tków
@ -88,7 +102,6 @@ private:
uint64_t offset; uint64_t offset;
// Tworzenie listy plików do spakowania // Tworzenie listy plików do spakowania
bool GetFileList(const std::string&); bool GetFileList(const std::string&);
@ -110,18 +123,12 @@ private:
// Wczytanie filtrów wyj¹tków // Wczytanie filtrów wyj¹tków
void GetFilters(const std::string&); void GetFilters(const std::string&);
// Sprawdza czy plik znajduje siê na liœcie
void computingBytes(const int16_t&, std::vector<char>&, std::vector<char>&);
// Sprawdzanie rozsze¿eñ plików // Sprawdzanie rozsze¿eñ plików
bool CheckFileExtension(const std::string&, const std::vector<std::string>&); bool CheckFileExtension(const std::string&, const std::vector<std::string>&);
// Zamieñ ca³y ci¹g na du¿e litery // Zamieñ ca³y ci¹g na du¿e litery
std::string UpperString(std::string); std::string UpperString(std::string);
// Wygenerój FNV-1a HASH
uint64_t fnv64(const std::string& data);
// ZnajdŸ wskazany element na liœcie // ZnajdŸ wskazany element na liœcie
bool FindOnTheList(const std::vector<std::string>&, const std::string&); bool FindOnTheList(const std::vector<std::string>&, const std::string&);
}; };

80
DataStruct.h
View file

@ -25,52 +25,80 @@
#define EXTENSION "pak" #define EXTENSION "pak"
#define SIGNATURE "XPAK" #define SIGNATURE "XPAK"
#define SIGNATURE_KEY_FILE 1497713496 // XKEY #define SIGNATURE_KEY_FILE "XKEY"
#define VERSION 300 #define VERSION 0x03
enum StoreMethod // WielkoϾ pojedynczego bloku strumienia
{ #define CHUNK_STREAM_512KB 524288 // 512KB
FILTERING = -1, #define CHUNK_STREAM_16MB 16777216 // 16MB
RAW = 0, #define CHUNK_STREAM_256MB 268435456 // 256MB
COMPRESS = 1,
ENCRYPT = 2,
COMPRESSxENCRYPT = 3
};
// Rozmiar pojedynczego bloku
#define CHUNK_BLOCK_SIZE 131072 // 128KB
#define FILE_FLAG_RAW 0x00
#define FILE_FLAG_COMPRESS 0x0F
#define FILE_FLAG_ENCRYPT 0xF0
#define FILE_FLAG_ZIPENC 0xFF
#define FILE_FLAG_FILTERING 0xAB
//Prgoram title //Prgoram title
#define PROGRAM_TITLE "eXtendet PAK" #define PROGRAM_TITLE "eXtendet PAK"
#define PROGRAM_VERSION "v1.3" #define PROGRAM_VERSION "v0.5"
#define PROGRAM_AUTHOR "Yanczi" #define PROGRAM_AUTHOR "Yanczi"
#define PROGRAM_COMPILING "16 November 2025" #define PROGRAM_COMPILING "19 December 2025"
#define PROGRAM_LICENSE "GNU LGPL v3" #define PROGRAM_LICENSE "GNU LGPL v3"
//Limity // Pliki
#define MAX_FILE_SIZE 2147483648 // 2GB namespace fl {
#define MAX_PAK_SIZE 8796093022208 // 8TB inline constexpr std::string_view sigpak = "XPAK";
inline constexpr std::string_view sigkey = "XKEY";
// Metody zapisania pliku inline constexpr std::string_view extpak = "pak";
#define RAW_FILE 0 inline constexpr std::string_view extkey = "key";
#define ZIP_FILE 1 }
#define CRYPT_FILE 2
#define CRYPT_ZIP 3 // Size
namespace ds
{
// Chunki streamowania
inline constexpr uint32_t chunk_stream = 268435456; // 256MB
// Blok chunków
inline constexpr uint32_t block_size = 131072; // 128KB
// Maksymalny rozmiar pliku do spakowania
inline constexpr uint64_t maxFileSize = 8589934592; // 8GB
}
// Flagi
namespace flag
{
inline constexpr uint8_t raw = 0x00; // Surowy plik
inline constexpr uint8_t zip = 0x0F; // Kompresja
inline constexpr uint8_t enc = 0xF0; // Szyfrowanie
inline constexpr uint8_t ezd = 0xFF; // Kompresja z szyfrowaniem
// Flaga do aktywacji filtra zdefiniowanego w json
inline constexpr uint8_t filter = 0xAB;
}
struct CargoHead struct CargoHead
{ {
std::string signature; std::string signature;
int16_t version; uint8_t version;
uint32_t files;
uint64_t table; uint64_t table;
uint32_t files;
}; };
struct FilesTable struct FilesTable
{ {
int16_t nameLen; uint8_t nameLen;
std::string nameFile; std::string nameFile;
uint64_t hashName;
uint64_t offset; uint64_t offset;
uint32_t size; uint64_t size;
uint64_t crc; uint64_t crc;
int16_t flag; uint8_t flag;
}; };

34
EncryptionManager.cpp
View file

@ -1,3 +1,22 @@
/*
* This file is part of VoidArchiveTool.
*
* Copyright (C) 2025 Yanczi
*
* Void Archive Toolis free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "EncryptionManager.h" #include "EncryptionManager.h"
EncryptionManager::EncryptionManager() EncryptionManager::EncryptionManager()
@ -48,8 +67,8 @@ void EncryptionManager::generateKeys()
void EncryptionManager::saveKey(const std::string& path, bool hpp) void EncryptionManager::saveKey(const std::string& path, bool hpp)
{ {
const int sig = SIGNATURE_KEY_FILE; const std::string sig = SIGNATURE_KEY_FILE;
const short ver = VERSION; const int8_t ver = VERSION;
// Wygeneruj time stamp // Wygeneruj time stamp
std::time_t now = std::time(nullptr); std::time_t now = std::time(nullptr);
@ -65,7 +84,7 @@ void EncryptionManager::saveKey(const std::string& path, bool hpp)
std::ofstream file(path + ".key", std::ios::binary); std::ofstream file(path + ".key", std::ios::binary);
if (!file) { std::cout << "Failed to save encryption key to file" << std::endl; } if (!file) { std::cout << "Failed to save encryption key to file" << std::endl; }
file.write(reinterpret_cast<const char*>(&sig), sizeof(sig)); file.write(sig.data(), sig.length());
file.write(reinterpret_cast<const char*>(&ver), sizeof(ver)); file.write(reinterpret_cast<const char*>(&ver), sizeof(ver));
file.write(reinterpret_cast<const char*>(&time), sizeof(time)); file.write(reinterpret_cast<const char*>(&time), sizeof(time));
file.write(reinterpret_cast<const char*>(keyVec.data()), keyVec.size()); file.write(reinterpret_cast<const char*>(keyVec.data()), keyVec.size());
@ -119,16 +138,17 @@ void EncryptionManager::loadKey(const std::string& path)
{ {
std::ifstream file(path + ".key", std::ios::binary); std::ifstream file(path + ".key", std::ios::binary);
int sig; const std::string signature = SIGNATURE_KEY_FILE;
short ver; std::vector<char> sig(signature.size());
int8_t ver;
int time; int time;
// Wczytaj // Wczytaj
file.read(reinterpret_cast<char*>(&sig), sizeof(sig)); file.read(sig.data(), sig.size());
file.read(reinterpret_cast<char*>(&ver), sizeof(ver)); file.read(reinterpret_cast<char*>(&ver), sizeof(ver));
// SprawdŸ czy plik klucza jest poprawny // SprawdŸ czy plik klucza jest poprawny
if (sig != SIGNATURE_KEY_FILE || ver != VERSION) if (std::string(sig.begin(), sig.end()) != signature || ver != VERSION)
{ {
throw std::runtime_error("Invalid key file!"); throw std::runtime_error("Invalid key file!");
} }

23
EncryptionManager.h
View file

@ -1,3 +1,22 @@
/*
* This file is part of VoidArchiveTool.
*
* Copyright (C) 2025 Yanczi
*
* Void Archive Toolis free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once #pragma once
#include <sodium.h> #include <sodium.h>
@ -26,6 +45,10 @@ public:
void saveKey(const std::string&, bool); void saveKey(const std::string&, bool);
void loadKey(const std::string&); void loadKey(const std::string&);
// Generowanie hash BLAKE2b
//static std::array<char, 16> hashBlake(const std::vector<char>&);
//static bool compareBlake(const std::vector<char>&, const std::array<char, 16>&);
private: private:
std::array<unsigned char, crypto_stream_chacha20_ietf_KEYBYTES> key{}; std::array<unsigned char, crypto_stream_chacha20_ietf_KEYBYTES> key{};
bool keyReady; bool keyReady;

140
ExtractCargo.cpp
View file

@ -22,12 +22,11 @@
ExtractCargo::ExtractCargo() ExtractCargo::ExtractCargo()
:filesLen(0) :filesLen(0)
, tablePosition(0) , tablePosition(0)
, filesHeadsOffset(0) , xxhState(XXH64_createState())
, version(VERSION)
, signature(SIGNATURE) , signature(SIGNATURE)
{ {
// TODO Auto-generated constructor stub // TODO Auto-generated constructor stub
XXH64_reset(xxhState, 0);
} }
ExtractCargo::~ExtractCargo() ExtractCargo::~ExtractCargo()
@ -89,7 +88,7 @@ bool ExtractCargo::Extract(const std::string& cFile)
bool ExtractCargo::CheckCargoFile() bool ExtractCargo::CheckCargoFile()
{ {
std::vector<char> magic(signature.size()); std::vector<char> magic(signature.size());
short cargoVer = 0; int8_t cargoVer = 0;
if (!cargoFile.is_open()) if (!cargoFile.is_open())
{ {
@ -98,73 +97,19 @@ bool ExtractCargo::CheckCargoFile()
} }
cargoFile.read(magic.data(), magic.size()); cargoFile.read(magic.data(), magic.size());
cargoFile.read(reinterpret_cast<char*>(&cargoVer), sizeof(cargoVer));
cargoFile.read(reinterpret_cast<char*>(&filesLen), sizeof(filesLen));
cargoFile.read(reinterpret_cast<char*>(&tablePosition), sizeof(tablePosition));
if (std::string(magic.begin(), magic.end()) != signature) if (std::string(magic.begin(), magic.end()) != signature)
{ {
std::cerr << "Error: Corrupted Cargo" << std::endl; std::cerr << "Error: Corrupted Cargo" << std::endl;
return false; return false;
} }
if (cargoVer != version) // Pobierz pozycjê tablicy plików i jej rozmiar
{ cargoFile.read(reinterpret_cast<char*>(&tablePosition), sizeof(tablePosition));
std::cerr << "Error: Wrong cargo version" << std::endl; cargoFile.read(reinterpret_cast<char*>(&filesLen), sizeof(filesLen));
return false;
}
filesHeadsOffset = signature.length() + sizeof(cargoVer) + sizeof(filesLen);
return true; return true;
} }
//-----------------------------------------------------------------------------
// Sprawdzanie sumy kontrolnej
//-----------------------------------------------------------------------------
bool ExtractCargo::HashValid(const std::vector<char>& data, const uint64_t& crc)
{
uint64_t actualCrc = XXH64(data.data(), data.size(), VERSION);
if (actualCrc != crc)
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Magiczna funkcja do dekompresji i deszyfracji danych
//-----------------------------------------------------------------------------
void ExtractCargo::computingBytes(const std::vector<char>& input, std::vector<char>& output, const int16_t& flag)
{
ChunkManager cm(eman);
switch (flag)
{
case 1:
output = cm.dechunked(input, true, false);
break;
case 2:
output = cm.dechunked(input, false, true);
break;
case 3:
output = cm.dechunked(input, true, true);
break;
case 4:
output = cm.dechunked(input, false, false);
break;
default:
output = input;
break;
}
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Pobieranie nag³ówków plików // Pobieranie nag³ówków plików
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -180,7 +125,6 @@ void ExtractCargo::LoadFilesTable()
cargoFile.read(nameBuffor.data(), fhTmp.nameLen); cargoFile.read(nameBuffor.data(), fhTmp.nameLen);
fhTmp.nameFile = std::string(nameBuffor.begin(), nameBuffor.end()); fhTmp.nameFile = std::string(nameBuffor.begin(), nameBuffor.end());
cargoFile.read(reinterpret_cast<char*>(&fhTmp.hashName), sizeof(fhTmp.hashName));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.offset), sizeof(fhTmp.offset)); cargoFile.read(reinterpret_cast<char*>(&fhTmp.offset), sizeof(fhTmp.offset));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.size), sizeof(fhTmp.size)); cargoFile.read(reinterpret_cast<char*>(&fhTmp.size), sizeof(fhTmp.size));
cargoFile.read(reinterpret_cast<char*>(&fhTmp.crc), sizeof(fhTmp.crc)); cargoFile.read(reinterpret_cast<char*>(&fhTmp.crc), sizeof(fhTmp.crc));
@ -199,24 +143,76 @@ void ExtractCargo::ExtractingFilesFromCargo()
{ {
std::filesystem::path dir = cargoFileName.stem() / fh.nameFile; std::filesystem::path dir = cargoFileName.stem() / fh.nameFile;
CreateDirections(dir); CreateDirections(dir);
std::cout << dir.string() << std::endl;
std::ofstream file(dir, std::ios::binary); std::ofstream file(dir, std::ios::binary);
cargoFile.seekg(fh.offset); cargoFile.seekg(fh.offset);
std::vector<char> buffor(fh.size);
cargoFile.read(buffor.data(), fh.size); XXH64_reset(xxhState, 0);
std::vector<char> rawBuffor; // Strumieñ wyci¹gaj¹cy
computingBytes(buffor, rawBuffor, fh.flag); if (fh.flag == flag::raw)
if (!HashValid(rawBuffor, fh.crc))
{ {
std::cerr << fh.nameFile << " Error: Corrupted data integration CRC" << std::endl; for (uint64_t sc = 0; sc < fh.size; sc += ds::chunk_stream)
{
const uint32_t streamChunk = std::min(ds::chunk_stream, static_cast<uint32_t>(fh.size - sc));
std::vector<char> buffer(streamChunk);
cargoFile.read(buffer.data(), streamChunk);
XXH64_update(xxhState, buffer.data(), buffer.size());
file.write(reinterpret_cast<const char*>(buffer.data()), streamChunk);
}
}
else
{
uint32_t chunkLen;
uint32_t chunkBeforeSize;
uint32_t chunkLastSize;
cargoFile.read(reinterpret_cast<char*>(&chunkLen), sizeof(chunkLen));
cargoFile.read(reinterpret_cast<char*>(&chunkBeforeSize), sizeof(chunkBeforeSize));
cargoFile.read(reinterpret_cast<char*>(&chunkLastSize), sizeof(chunkLastSize));
std::vector<char> chunksString;
// Dekompresja bloków
for (size_t i = 0; i < chunkLen; ++i)
{
// Pobierz rozmiar chunków przed i po skompresowaniem
uint32_t chunkSize = i < chunkLen - 1 ? chunkBeforeSize : chunkLastSize;
uint32_t chunkZipSize;
cargoFile.read(reinterpret_cast<char*>(&chunkZipSize), sizeof(chunkZipSize));
// Pobierz blok chunka
std::vector<char> buffer(chunkZipSize);
cargoFile.read(buffer.data(), chunkZipSize);
std::vector<char> rawBuffer(chunkSize);
if ((fh.flag & flag::zip) == flag::zip)
{
rawBuffer = (fh.flag & flag::enc) == flag::enc ?
cman.decompress(eman.decrypt(buffer), chunkSize) :
cman.decompress(buffer, chunkSize);
}
else
{
rawBuffer = eman.decrypt(buffer);
}
XXH64_update(xxhState, rawBuffer.data(), rawBuffer.size());
file.write(reinterpret_cast<const char*>(rawBuffer.data()), chunkSize);
}
} }
file.write(reinterpret_cast<const char*>(rawBuffor.data()), rawBuffor.size());
file.close(); file.close();
if (XXH64_digest(xxhState) != fh.crc)
{
std::cerr << dir.string() << " Error: Corrupted data integration CRC" << std::endl;
}
} }
std::cout << "Unpacking complete!" << std::endl; std::cout << "Unpacking complete!" << std::endl;

14
ExtractCargo.h
View file

@ -28,11 +28,12 @@
#include <sstream> #include <sstream>
#include <cstdint> #include <cstdint>
#include <string> #include <string>
#include <utility>
#include <xxhash.h> #include <xxhash.h>
#include "DataStruct.h" #include "DataStruct.h"
#include "ChunkManager.h"
#include "EncryptionManager.h" #include "EncryptionManager.h"
#include "CompressionManager.h"
class ExtractCargo { class ExtractCargo {
public: public:
@ -47,9 +48,8 @@ private:
uint32_t filesLen; uint32_t filesLen;
uint64_t tablePosition; uint64_t tablePosition;
int filesHeadsOffset; XXH64_state_t* xxhState;
const short version;
const std::string signature; const std::string signature;
std::vector<FilesTable> filesHeads; std::vector<FilesTable> filesHeads;
@ -58,7 +58,7 @@ private:
std::ifstream cargoFile; std::ifstream cargoFile;
EncryptionManager eman; EncryptionManager eman;
CompressionManager cman;
// Sprawdzenie poprawnoœci archiwum // Sprawdzenie poprawnoœci archiwum
bool CheckCargoFile(); bool CheckCargoFile();
@ -69,13 +69,7 @@ private:
// Pobieranie nag³ówków plików // Pobieranie nag³ówków plików
void LoadFilesTable(); void LoadFilesTable();
// Sprawdzanie sumy kontrolnej
bool HashValid(const std::vector<char>&, const uint64_t&);
// Utwórz katalog // Utwórz katalog
void CreateDirections(std::filesystem::path); void CreateDirections(std::filesystem::path);
// Magiczna funkcja do dekompresji i deszyfracji danych
void computingBytes(const std::vector<char>&, std::vector<char>&, const int16_t&);
}; };

18
Interface.cpp
View file

@ -1,18 +0,0 @@
#include "Interface.h"
Interface::Interface() {
// TODO Auto-generated constructor stub
}
Interface::~Interface() {
// TODO Auto-generated destructor stub
}
void Interface::TextBorder(const std::string& title, const std::string& text)
{
auto element = ftxui::window(ftxui::text(title), ftxui::paragraphAlignLeft(text));
auto screen = ftxui::Screen::Create(ftxui::Dimension::Fit(element));
ftxui::Render(screen, element);
screen.Print();
}

14
Interface.h
View file

@ -1,14 +0,0 @@
#pragma once
#include <ftxui/dom/elements.hpp>
#include <ftxui/screen/screen.hpp>
#include <string>
class Interface {
public:
Interface();
virtual ~Interface();
void TextBorder(const std::string&, const std::string&);
};

71
Tui.cpp Normal file
View file

@ -0,0 +1,71 @@
/*
* This file is part of VoidArchiveTool.
*
* Copyright (C) 2025 Yanczi
*
* Void Archive Toolis free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "Tui.h"
Tui::Tui() {
// TODO Auto-generated constructor stub
}
Tui::~Tui() {
// TODO Auto-generated destructor stub
}
void Tui::TextBorder(const std::string& title, const std::string& text)
{
auto element = ftxui::window(ftxui::text(title), ftxui::paragraphAlignLeft(text));
auto screen = ftxui::Screen::Create(ftxui::Dimension::Fit(element));
ftxui::Render(screen, element);
screen.Print();
}
void Tui::table(const std::vector<std::vector<std::string>>& data)
{
ftxui::Table table(data);
// Styl ogólny tabeli (ramki)
table.SelectAll().Border(ftxui::LIGHT);
// Oddzielenie nag³ówka od danych podwójn¹ lini¹
table.SelectRow(0).Border(ftxui::LIGHT);
table.SelectRow(0).Decorate(ftxui::bold); // Pogrubienie nag³ówka
table.SelectRow(0).SeparatorVertical(ftxui::LIGHT);
table.SelectRow(0).Border(ftxui::LIGHT);
table.SelectColumn(0).DecorateCells(ftxui::center);
table.SelectColumn(1).DecorateCells(ftxui::center);
table.SelectColumn(2).DecorateCells([](ftxui::Element e) {
return e | ftxui::flex;
});
table.SelectColumn(3).DecorateCells(ftxui::center);
table.SelectColumn(0).BorderRight(ftxui::LIGHT);
table.SelectColumn(1).BorderRight(ftxui::LIGHT);
table.SelectColumn(2).BorderRight(ftxui::LIGHT);
auto document = table.Render();
auto screen = ftxui::Screen::Create(ftxui::Dimension::Full(), ftxui::Dimension::Fit(document));
ftxui::Render(screen, document);
screen.Print();
}

34
Tui.h Normal file
View file

@ -0,0 +1,34 @@
/*
* This file is part of VoidArchiveTool.
*
* Copyright (C) 2025 Yanczi
*
* Void Archive Toolis free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <ftxui/dom/elements.hpp>
#include <ftxui/dom/table.hpp>
#include <ftxui/screen/screen.hpp>
#include <string>
class Tui {
public:
Tui();
virtual ~Tui();
void TextBorder(const std::string&, const std::string&);
void table(const std::vector<std::vector<std::string>>&);
};

136
ViewCargo.cpp
View file

@ -20,14 +20,7 @@
#include "ViewCargo.h" #include "ViewCargo.h"
ViewCargo::ViewCargo() ViewCargo::ViewCargo()
:signature(SIGNATURE) {}
, version(VERSION)
, filesLen(0)
, tablePos(0)
{
// TODO Auto-generated constructor stub
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Wywoływanie // Wywoływanie
@ -49,39 +42,26 @@ bool ViewCargo::View(const std::string& path)
} }
//Sprawdź czy kontener jest prawidłowy //Sprawdź czy kontener jest prawidłowy
if (!CheckCargoFile(path)) if (!ViewFiles(path))
{ {
std::cerr << "Nie prawidlowa struktura kontenera Void" << std::endl; std::cerr << "Nie prawidlowa struktura kontenera Void" << std::endl;
return false; return false;
} }
//Table Header
std::vector<ftxui::Element> headElements;
headElements.push_back(ftxui::text(" Compressed ") | ftxui::bold);
headElements.push_back(ftxui::text(" Encrypted ") | ftxui::bold);
headElements.push_back(ftxui::text("Nazwa pliku") | ftxui::bold | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 56));
headElements.push_back(ftxui::text("Hash Name") | ftxui::bold | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 20));
filesList.push_back(hbox(std::move(headElements)));
//Pobieranie listy plików
GetFileList(path);
//Renderowanie listy plików
RenderList();
return true; return true;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Sprawdzenie poprawności kontenera // Sprawdzenie poprawności kontenera
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool ViewCargo::CheckCargoFile(const std::string& path) bool ViewCargo::ViewFiles(const std::string& path)
{ {
uint64_t tabPos = 0;
uint32_t tabSize = 0;
const std::string signature = SIGNATURE;
std::vector<char> magic(signature.length()); std::vector<char> magic(signature.length());
short cargoVer = 0; int8_t cargoVer = 0;
std::ifstream cargo(path, std::ios::binary); std::ifstream cargo(path, std::ios::binary);
@ -92,15 +72,14 @@ bool ViewCargo::CheckCargoFile(const std::string& path)
} }
//--------------------------------------------------------------- //---------------------------------------------------------------
// Odczytywanie pierwszych 11 bajtów nagłówka pliku // Odczytywanie pierwszych 16 bajtów nag³ówka pliku
// 6 pierwszych to sygnatura // 4 Sygnatura kontenera XPAK
// 1 wersja kontenera // 8 Offset tablicy plików
// 4 ilość plików w kontenerze // 4 Rozmiar tablicy plików
//--------------------------------------------------------------- //---------------------------------------------------------------
cargo.read(magic.data(), magic.size()); cargo.read(magic.data(), magic.size());
cargo.read(reinterpret_cast<char*>(&cargoVer), sizeof(cargoVer)); cargo.read(reinterpret_cast<char*>(&tabPos), sizeof(tabPos));
cargo.read(reinterpret_cast<char*>(&filesLen), sizeof(filesLen)); cargo.read(reinterpret_cast<char*>(&tabSize), sizeof(tabSize));
cargo.read(reinterpret_cast<char*>(&tablePos), sizeof(tablePos));
//Sprawdź czy kontener ma poprawną sygnature //Sprawdź czy kontener ma poprawną sygnature
if (std::string(magic.begin(), magic.end()) != signature) if (std::string(magic.begin(), magic.end()) != signature)
@ -110,28 +89,13 @@ bool ViewCargo::CheckCargoFile(const std::string& path)
return false; return false;
} }
//Sprawdź spójność wersji kontenera std::cout << "ZIP" << " " << "ENC" << " " << "Path" << std::endl;
if (cargoVer != version)
{
std::cerr << "Error: Wrong cargo version" << std::endl;
cargo.close();
return false;
}
cargo.close(); // Przeskocz do tablicy plików
cargo.seekg(tabPos);
return true; // Za³aduj dane o plikach
} for (uint32_t i = 0; i < tabSize; ++i)
//-----------------------------------------------------------------------------
// Pobieranie listy plików z kontenera
//-----------------------------------------------------------------------------
void ViewCargo::GetFileList(const std::string& path)
{
std::ifstream cargo(path, std::ios::binary);
cargo.seekg(tablePos);
for (uint32_t i = 0; i < filesLen; ++i)
{ {
FilesTable fhTmp; FilesTable fhTmp;
cargo.read(reinterpret_cast<char*>(&fhTmp.nameLen), sizeof(fhTmp.nameLen)); cargo.read(reinterpret_cast<char*>(&fhTmp.nameLen), sizeof(fhTmp.nameLen));
@ -140,76 +104,50 @@ void ViewCargo::GetFileList(const std::string& path)
cargo.read(nameBuffor.data(), fhTmp.nameLen); cargo.read(nameBuffor.data(), fhTmp.nameLen);
fhTmp.nameFile = std::string(nameBuffor.begin(), nameBuffor.end()); fhTmp.nameFile = std::string(nameBuffor.begin(), nameBuffor.end());
cargo.read(reinterpret_cast<char*>(&fhTmp.hashName), sizeof(fhTmp.hashName));
cargo.read(reinterpret_cast<char*>(&fhTmp.offset), sizeof(fhTmp.offset)); cargo.read(reinterpret_cast<char*>(&fhTmp.offset), sizeof(fhTmp.offset));
cargo.read(reinterpret_cast<char*>(&fhTmp.size), sizeof(fhTmp.size)); cargo.read(reinterpret_cast<char*>(&fhTmp.size), sizeof(fhTmp.size));
cargo.read(reinterpret_cast<char*>(&fhTmp.crc), sizeof(fhTmp.crc)); cargo.read(reinterpret_cast<char*>(&fhTmp.crc), sizeof(fhTmp.crc));
cargo.read(reinterpret_cast<char*>(&fhTmp.flag), sizeof(fhTmp.flag)); cargo.read(reinterpret_cast<char*>(&fhTmp.flag), sizeof(fhTmp.flag));
//Tworzenie wierszy tabeli //Tworzenie wierszy tabeli
CreateTableRow(fhTmp.nameFile, fhTmp.flag, fhTmp.hashName); ShowFile(fhTmp.nameFile, fhTmp.flag);
} }
cargo.close(); cargo.close();
return true;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Generowanie wierszy do tabeli // Generowanie wierszy do tabeli
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void ViewCargo::CreateTableRow(const std::string& file, const uint8_t& zip, const uint64_t& hash) void ViewCargo::ShowFile(const std::string& file, const uint8_t& flag)
{ {
//Zamiania crc liczbowej na hex string std::string compresedCheck = "[ ]";
std::stringstream ss; std::string encryptedCheck = "[ ]";
ss << "0x" << std::hex << std::uppercase << hash;
std::vector<ftxui::Element> cell;
ftxui::Element eZip;
ftxui::Element eEnc;
// Ustawianie checkboxów // Ustawianie checkboxów
switch (zip) switch (flag)
{ {
case 1: case FILE_FLAG_COMPRESS:
eZip = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan); compresedCheck = "[x]";
eEnc = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White);
break; break;
case 2: case FILE_FLAG_ENCRYPT:
eZip = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White); encryptedCheck = "[x]";
eEnc = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan);
break; break;
case 3: case FILE_FLAG_ZIPENC:
eZip = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan); compresedCheck = "[x]";
eEnc = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan); encryptedCheck = "[x]";
break; break;
default: default:
eZip = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White); compresedCheck = "[ ]";
eEnc = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White); encryptedCheck = "[ ]";
break; break;
} }
//Dodawanie komurek // Wyœwietlanie
cell.push_back(eZip); std::cout << compresedCheck << " " << encryptedCheck << " " << file << std::endl;
cell.push_back(eEnc | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 7));
cell.push_back(ftxui::text(file) | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 56));
cell.push_back(ftxui::text(ss.str()) | ftxui::size(ftxui::WIDTH, ftxui::EQUAL, 20));
//Konwersja komurek na wiersz
filesList.push_back(ftxui::hbox(std::move(cell)));
}
//-----------------------------------------------------------------------------
// Renderowanie listy plików
//-----------------------------------------------------------------------------
void ViewCargo::RenderList()
{
//Dodawanie wierszy do kolumn
ftxui::Element table = ftxui::vbox(std::move(filesList));
auto screen = ftxui::Screen::Create(ftxui::Dimension::Fit(table));
ftxui::Render(screen, table);
screen.Print();
} }

14
ViewCargo.h
View file

@ -27,6 +27,7 @@
#include <sstream> #include <sstream>
#include <ftxui/dom/elements.hpp> #include <ftxui/dom/elements.hpp>
#include <ftxui/screen/screen.hpp> #include <ftxui/screen/screen.hpp>
#include <ftxui/dom/table.hpp>
#include "DataStruct.h" #include "DataStruct.h"
@ -38,17 +39,8 @@ public:
bool View(const std::string&); bool View(const std::string&);
private: private:
const std::string signature; bool ViewFiles(const std::string&);
const uint16_t version; void ShowFile(const std::string&, const uint8_t&);
uint32_t filesLen;
uint64_t tablePos;
std::vector<ftxui::Element> filesList;
bool CheckCargoFile(const std::string&);
void GetFileList(const std::string&);
void RenderList();
void CreateTableRow(const std::string&, const uint8_t&, const uint64_t&);
}; };

21
license/FTXUI/LICENSE.txt Normal file
View file

@ -0,0 +1,21 @@
The MIT License
Copyright (c) 2019 Arthur Sonzogni.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

12
license/lz4/LICENSE.txt
View file

@ -1,12 +0,0 @@
This repository uses 2 different licenses :
- all files in the `lib` directory use a BSD 2-Clause license
- all other files use a GPL-2.0-or-later license, unless explicitly stated otherwise
Relevant license is reminded at the top of each source file,
and with presence of COPYING or LICENSE file in associated directories.
This model is selected to emphasize that
files in the `lib` directory are designed to be included into 3rd party applications,
while all other files, in `programs`, `tests` or `examples`,
are intended to be used "as is", as part of their intended scenarios,
with no intention to support 3rd party integration use cases.

30
license/zstd/LICENSE.txt Normal file
View file

@ -0,0 +1,30 @@
BSD License
For Zstandard software
Copyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name Facebook, nor Meta, nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

127
testx/text_file.txt
View file

@ -1,251 +1,126 @@
Nam strzelać nie kazano. - Wstąpiłem na działo Nam strzelać nie kazano. - Wstąpiłem na działo
I spójrzałem na pole; dwieście armat grzmiało. I spójrzałem na pole; dwieście armat grzmiało.
Artyleryi ruskiej ciągną się szeregi, Artyleryi ruskiej ciągną się szeregi,
Prosto, długo, daleko, jako morza brzegi; Prosto, długo, daleko, jako morza brzegi;
I widziałem ich wodza: przybiegł, mieczem skinął I widziałem ich wodza: przybiegł, mieczem skinął
I jak ptak jedno skrzydło wojska swego zwinął; I jak ptak jedno skrzydło wojska swego zwinął;
Wylewa się spod skrzydła ściśniona piechota Wylewa się spod skrzydła ściśniona piechota
Długą czarną kolumną, jako lawa błota, Długą czarną kolumną, jako lawa błota,
Nasypana iskrami bagnetów. Jak sępy Nasypana iskrami bagnetów. Jak sępy
Czarne chorągwie na śmierć prowadzą zastępy. Czarne chorągwie na śmierć prowadzą zastępy.
Przeciw nim sterczy biała, wąska, zaostrzona, Przeciw nim sterczy biała, wąska, zaostrzona,
Jak głaz bodzący morze, reduta Ordona. Jak głaz bodzący morze, reduta Ordona.
Sześć tylko miała armat; wciąż dymią i świecą; Sześć tylko miała armat; wciąż dymią i świecą;
I nie tyle prędkich słów gniewne usta miecą, I nie tyle prędkich słów gniewne usta miecą,
Nie tyle przejdzie uczuć przez duszę w rozpaczy, Nie tyle przejdzie uczuć przez duszę w rozpaczy,
Ile z tych dział leciało bomb, kul i kartaczy. Ile z tych dział leciało bomb, kul i kartaczy.
Patrz, tam granat w sam środek kolumny się nurza, Patrz, tam granat w sam środek kolumny się nurza,
Jak w fale bryła lawy, pułk dymem zachmurza; Jak w fale bryła lawy, pułk dymem zachmurza;
Pęka śród dymu granat, szyk pod niebo leci Pęka śród dymu granat, szyk pod niebo leci
I ogromna łysina śród kolumny świeci. I ogromna łysina śród kolumny świeci.
Tam kula, lecąc, z dala grozi, szumi, wyje. Tam kula, lecąc, z dala grozi, szumi, wyje.
Ryczy jak byk przed bitwą, miota się, grunt ryje; - Ryczy jak byk przed bitwą, miota się, grunt ryje; -
Już dopadła; jak boa śród kolumn się zwija, Już dopadła; jak boa śród kolumn się zwija,
Pali piersią, rwie zębem, oddechem zabija. Pali piersią, rwie zębem, oddechem zabija.
Najstraszniejszej nie widać, lecz słychać po dźwięku, Najstraszniejszej nie widać, lecz słychać po dźwięku,
Po waleniu się trupów, po ranionych jęku: Po waleniu się trupów, po ranionych jęku:
Gdy kolumnę od końca do końca przewierci, Gdy kolumnę od końca do końca przewierci,
Jak gdyby środkiem wojska przeszedł anioł śmierci. Jak gdyby środkiem wojska przeszedł anioł śmierci.
Gdzież jest król, co na rzezie tłumy te wyprawia? Gdzież jest król, co na rzezie tłumy te wyprawia?
Czy dzieli ich odwagę, czy pierś sam nadstawia? Czy dzieli ich odwagę, czy pierś sam nadstawia?
Nie, on siedzi o pięćset mil na swej stolicy, Nie, on siedzi o pięćset mil na swej stolicy,
Król wielki, samowładnik świata połowicy; Król wielki, samowładnik świata połowicy;
Zmarszczył brwi, - i tysiące kibitek wnet leci; Zmarszczył brwi, - i tysiące kibitek wnet leci;
Podpisał, - tysiąc matek opłakuje dzieci; Podpisał, - tysiąc matek opłakuje dzieci;
Skinął, - padają knuty od Niemna do Chiwy. Skinął, - padają knuty od Niemna do Chiwy.
Mocarzu, jak Bóg silny, jak szatan złośliwy, Mocarzu, jak Bóg silny, jak szatan złośliwy,
Gdy Turków za Bałkanem twoje straszą spiże, Gdy Turków za Bałkanem twoje straszą spiże,
Gdy poselstwo paryskie twoje stopy liże, - Gdy poselstwo paryskie twoje stopy liże, -
Warszawa jedna twojej mocy się urąga, Warszawa jedna twojej mocy się urąga,
Podnosi na cię rękę i koronę ściąga, Podnosi na cię rękę i koronę ściąga,
Koronę Kazimierzów, Chrobrych z twojej głowy, Koronę Kazimierzów, Chrobrych z twojej głowy,
Boś ją ukradł i skrwawił, synu Wasilowy! Boś ją ukradł i skrwawił, synu Wasilowy!
Car dziwi się - ze strachu. drzą Petersburczany, Car dziwi się - ze strachu. drzą Petersburczany,
Car gniewa się - ze strachu mrą jego dworzany; Car gniewa się - ze strachu mrą jego dworzany;
Ale sypią się wojska, których Bóg i wiara Ale sypią się wojska, których Bóg i wiara
Jest Car. - Car gniewny: umrzem, rozweselim Cara. Jest Car. - Car gniewny: umrzem, rozweselim Cara.
Posłany wódz kaukaski z siłami pół-świata, Posłany wódz kaukaski z siłami pół-świata,
Wierny, czynny i sprawny - jak knut w ręku kata. Wierny, czynny i sprawny - jak knut w ręku kata.
Ura! ura! Patrz, blisko reduty, już w rowy Ura! ura! Patrz, blisko reduty, już w rowy
Walą się, na faszynę kładąc swe tułowy; Walą się, na faszynę kładąc swe tułowy;
Już czernią się na białych palisadach wałów. Już czernią się na białych palisadach wałów.
Jeszcze reduta w środku, jasna od wystrzałów, Jeszcze reduta w środku, jasna od wystrzałów,
Czerwieni się nad czernią: jak w środek mrowiaka Czerwieni się nad czernią: jak w środek mrowiaka
Wrzucony motyl błyska, - mrowie go naciska, - Wrzucony motyl błyska, - mrowie go naciska, -
Zgasł - tak zgasła reduta. Czyż ostatnie działo Zgasł - tak zgasła reduta. Czyż ostatnie działo
Strącone z łoża w piasku paszczę zagrzebało? Strącone z łoża w piasku paszczę zagrzebało?
Czy zapał krwią ostatni bombardyjer zalał? Czy zapał krwią ostatni bombardyjer zalał?
Zgasnął ogień. - Już Moskal rogatki wywalał. Zgasnął ogień. - Już Moskal rogatki wywalał.
Gdzież ręczna broń? - Ach, dzisiaj pracowała więcej Gdzież ręczna broń? - Ach, dzisiaj pracowała więcej
Niż na wszystkich przeglądach za władzy książęcej; Niż na wszystkich przeglądach za władzy książęcej;
Zgadłem, dlaczego milczy, - bo nieraz widziałem Zgadłem, dlaczego milczy, - bo nieraz widziałem
Garstkę naszych walczącą z Moskali nawałem. Garstkę naszych walczącą z Moskali nawałem.
Gdy godzinę wołano dwa słowa: pal, nabij; Gdy godzinę wołano dwa słowa: pal, nabij;
Gdy oddechy dym tłumi, trud ramiona słabi; Gdy oddechy dym tłumi, trud ramiona słabi;
A wciąż grzmi rozkaz wodzów, wre żołnierza czynność; A wciąż grzmi rozkaz wodzów, wre żołnierza czynność;
Na koniec bez rozkazu pełnią swą powinność, Na koniec bez rozkazu pełnią swą powinność,
Na koniec bez rozwagi, bez czucia, pamięci, Na koniec bez rozwagi, bez czucia, pamięci,
Żołnierz jako młyn palny nabija - grzmi - kręci Żołnierz jako młyn palny nabija - grzmi - kręci
Broń od oka do nogi, od nogi na oko: Broń od oka do nogi, od nogi na oko:
Aż ręka w ładownicy długo i głęboko Aż ręka w ładownicy długo i głęboko
Szukała, nie znalazła - i żołnierz pobladnął, Szukała, nie znalazła - i żołnierz pobladnął,
Nie znalazłszy ładunku, już bronią nie władnął; Nie znalazłszy ładunku, już bronią nie władnął;
I uczuł, że go pali strzelba rozogniona; I uczuł, że go pali strzelba rozogniona;
Upuścił ją i upadł; - nim dobiją, skona. Upuścił ją i upadł; - nim dobiją, skona.
Takem myślił, - a w szaniec nieprzyjaciół kupa Takem myślił, - a w szaniec nieprzyjaciół kupa
Już łazła, jak robactwo na świeżego trupa. Już łazła, jak robactwo na świeżego trupa.
Pociemniało mi w oczach - a gdym łzy ocierał, Pociemniało mi w oczach - a gdym łzy ocierał,
Słyszałem, że coś do mnie mówił mój Jenerał. Słyszałem, że coś do mnie mówił mój Jenerał.
On przez lunetę wspartą na moim ramieniu On przez lunetę wspartą na moim ramieniu
Długo na szturm i szaniec poglądał w milczeniu. Długo na szturm i szaniec poglądał w milczeniu.
Na koniec rzekł; "Stracona". - Spod lunety jego Na koniec rzekł; "Stracona". - Spod lunety jego
Wymknęło się łez kilka, - rzekł do mnie: "Kolego, Wymknęło się łez kilka, - rzekł do mnie: "Kolego,
Wzrok młody od szkieł lepszy; patrzaj, tam na wale, Wzrok młody od szkieł lepszy; patrzaj, tam na wale,
Znasz Ordona, czy widzisz, gdzie jest?" - "Jenerale, Znasz Ordona, czy widzisz, gdzie jest?" - "Jenerale,
Czy go znam? - Tam stał zawsze, to działo kierował. Czy go znam? - Tam stał zawsze, to działo kierował.
Nie widzę - znajdę - dojrzę! - śród dymu się schował: Nie widzę - znajdę - dojrzę! - śród dymu się schował:
Lecz śród najgęstszych kłębów dymu ileż razy Lecz śród najgęstszych kłębów dymu ileż razy
Widziałem rękę jego, dającą rozkazy. - Widziałem rękę jego, dającą rozkazy. -
Widzę go znowu, - widzę rękę - błyskawicę, Widzę go znowu, - widzę rękę - błyskawicę,
Wywija, grozi wrogom, trzyma palną świécę, Wywija, grozi wrogom, trzyma palną świécę,
Biorą go - zginął - o nie, - skoczył w dół, - do lochów"! Biorą go - zginął - o nie, - skoczył w dół, - do lochów"!
"Dobrze - rzecze Jenerał - nie odda im prochów". "Dobrze - rzecze Jenerał - nie odda im prochów".
Tu blask - dym - chwila cicho - i huk jak stu gromów. Tu blask - dym - chwila cicho - i huk jak stu gromów.
Zaćmiło się powietrze od ziemi wylomów, Zaćmiło się powietrze od ziemi wylomów,
Harmaty podskoczyły i jak wystrzelone Harmaty podskoczyły i jak wystrzelone
Toczyły się na kołach - lonty zapalone Toczyły się na kołach - lonty zapalone
Nie trafiły do swoich panew. I dym wionął Nie trafiły do swoich panew. I dym wionął
Prosto ku nam; i w gęstej chmurze nas ochłonął. Prosto ku nam; i w gęstej chmurze nas ochłonął.
I nie było nic widać prócz granatów blasku
I nie było nic widać prócz granatów blasku,
I powoli dym rzedniał, opadał deszcz piasku. I powoli dym rzedniał, opadał deszcz piasku.
Spojrzałem na redutę; - wały, palisady, Spojrzałem na redutę; - wały, palisady,
Działa i naszych garstka, i wrogów gromady; Działa i naszych garstka, i wrogów gromady;
Wszystko jako sen znikło. - Tylko czarna bryła Wszystko jako sen znikło. - Tylko czarna bryła
Ziemi niekształtnej leży - rozjemcza mogiła. Ziemi niekształtnej leży - rozjemcza mogiła.
Tam i ci, co bronili, -i ci, co się wdarli, Tam i ci, co bronili, -i ci, co się wdarli,
Pierwszy raz pokój szczery i wieczny zawarli. Pierwszy raz pokój szczery i wieczny zawarli.
Choćby cesarz Moskalom kazał wstać, już dusza Choćby cesarz Moskalom kazał wstać, już dusza
Moskiewska. tam raz pierwszy, cesarza nie słusza. Moskiewska. tam raz pierwszy, cesarza nie słusza.
Tam zagrzebane tylu set ciała, imiona: Tam zagrzebane tylu set ciała, imiona:
Dusze gdzie? nie wiem; lecz wiem, gdzie dusza Ordona. Dusze gdzie? nie wiem; lecz wiem, gdzie dusza Ordona.
On będzie Patron szańców! - Bo dzieło zniszczenia On będzie Patron szańców! - Bo dzieło zniszczenia
W dobrej sprawie jest święte, Jak dzieło tworzenia; W dobrej sprawie jest święte, Jak dzieło tworzenia;
Bóg wyrzekł słowo stań się, Bóg i zgiń wyrzecze. Bóg wyrzekł słowo stań się, Bóg i zgiń wyrzecze.
Kiedy od ludzi wiara i wolność uciecze, Kiedy od ludzi wiara i wolność uciecze,
Kiedy ziemię despotyzm i duma szalona Kiedy ziemię despotyzm i duma szalona
Obleją, jak Moskale redutę Ordona - Obleją, jak Moskale redutę Ordona -
Karząc plemię zwyciężców zbrodniami zatrute, Karząc plemię zwyciężców zbrodniami zatrute,
Bóg wysadzi tę ziemię, jak on swą redutę. Bóg wysadzi tę ziemię, jak on swą redutę.

24
voidcmd.cpp
View file

@ -32,7 +32,7 @@
#include "CreateCargo.h" #include "CreateCargo.h"
#include "ExtractCargo.h" #include "ExtractCargo.h"
#include "ViewCargo.h" #include "ViewCargo.h"
#include "Interface.h" #include "Tui.h"
void RenderHelp() void RenderHelp()
{ {
@ -82,17 +82,7 @@ static bool EmptyPath(std::string path)
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
std::string path = ""; std::string path = "";
std::cout << std::cout << PROGRAM_VERSION << " Release " << PROGRAM_COMPILING << std::endl;
" 8888888b. d8888 888 d8P \n"
" 888 Y88b d88888 888 d8P \n"
" 888 888 d88P888 888 d8P \n"
" .d88b. 888 888 888 d88P d88P 888 888d88K \n"
"d8P Y8b `Y8bd8P' 8888888P\" d88P 888 8888888b \n"
"88888888 X88K 888 d88P 888 888 Y88b \n"
"Y8b. .d8\"\"8b. 888 d8888888888 888 Y88b \n"
" \"Y8888 888 888 888 d88P 888 888 Y88b\n"
<< std::endl;
std::cout << "\n" << PROGRAM_VERSION << " Release " << PROGRAM_COMPILING << std::endl;
std::cout << "Author: " << PROGRAM_AUTHOR << std::endl; std::cout << "Author: " << PROGRAM_AUTHOR << std::endl;
std::cout << "License: " << PROGRAM_LICENSE << "\n" << std::endl; std::cout << "License: " << PROGRAM_LICENSE << "\n" << std::endl;
@ -110,7 +100,7 @@ int main(int argc, char* argv[]) {
if (!EmptyPath(path)) { return 1; } if (!EmptyPath(path)) { return 1; }
if (!cargo.Create(path, 1)) if (!cargo.Create(path, 0x0F))
{ {
return 1; return 1;
} }
@ -120,7 +110,7 @@ int main(int argc, char* argv[]) {
if (arg == "-r" && i + 1 < argc) if (arg == "-r" && i + 1 < argc)
{ {
path = argv[i + 1]; path = argv[i + 1];
if (!cargo.Create(path, 0)) if (!cargo.Create(path, 0x00))
{ {
return 1; return 1;
} }
@ -130,7 +120,7 @@ int main(int argc, char* argv[]) {
if (arg == "-e" && i + 1 < argc) if (arg == "-e" && i + 1 < argc)
{ {
path = argv[i + 1]; path = argv[i + 1];
if (!cargo.Create(path, 2)) if (!cargo.Create(path, 0xF0))
{ {
return 1; return 1;
} }
@ -140,7 +130,7 @@ int main(int argc, char* argv[]) {
if (arg == "-s" && i + 1 < argc) if (arg == "-s" && i + 1 < argc)
{ {
path = argv[i + 1]; path = argv[i + 1];
if (!cargo.Create(path, 3)) if (!cargo.Create(path, 0xFF))
{ {
return 1; return 1;
} }
@ -151,7 +141,7 @@ int main(int argc, char* argv[]) {
{ {
path = argv[i + 1]; path = argv[i + 1];
if (!EmptyPath(path)) { return 1; } if (!EmptyPath(path)) { return 1; }
if (!cargo.Create(path, -1)) if (!cargo.Create(path, 0xAB))
{ {
return 1; return 1;
} }

22
voidcmd.vcxproj
View file

@ -101,16 +101,16 @@
<ClCompile> <ClCompile>
<WarningLevel>Level3</WarningLevel> <WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck> <SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions);SODIUM_STATIC</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode> <ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard> <LanguageStandard>stdcpp20</LanguageStandard>
<AdditionalIncludeDirectories>3rd\ftxui\include;3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include;3rd\xxhash\include</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include</AdditionalIncludeDirectories>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>3rd\zstd\lib\Debug;3rd\ftxui\Debug;3rd\xxhash\lib\Debug;3rd\libsodium\lib\Debug</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>3rd\zstd\lib\Debug;3rd\xxhash\lib\Debug;3rd\libsodium\x64\Debug\v143\static</AdditionalLibraryDirectories>
<AdditionalDependencies>ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib;libsodium.lib;zstd_static.lib;xxhash.lib</AdditionalDependencies> <AdditionalDependencies>libsodium.lib;zstd_static.lib;xxhash.lib</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'"> <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@ -119,36 +119,32 @@
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions> <IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck> <SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions);SODIUM_STATIC</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode> <ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpp17</LanguageStandard> <LanguageStandard>stdcpp17</LanguageStandard>
<AdditionalIncludeDirectories>3rd\ftxui\include;3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include;</AdditionalIncludeDirectories> <AdditionalIncludeDirectories>3rd\libsodium\include;3rd\json\include;3rd\zstd\include;3rd\xxhash\include</AdditionalIncludeDirectories>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalLibraryDirectories>3rd\zstd\lib\Release;3rd\libsodium\lib\Release;3rd\xxhash\lib\Release;3rd\ftxui\Release</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>3rd\zstd\lib\Release;3rd\libsodium\x64\Release\v143\static;3rd\xxhash\lib\Release</AdditionalLibraryDirectories>
<AdditionalDependencies>ftxui-component.lib;ftxui-dom.lib;ftxui-screen.lib;libsodium.lib;zstd_static.lib;xxhash.lib</AdditionalDependencies> <AdditionalDependencies>libsodium.lib;zstd_static.lib;xxhash.lib</AdditionalDependencies>
</Link> </Link>
</ItemDefinitionGroup> </ItemDefinitionGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="ChunkManager.cpp" />
<ClCompile Include="CompressionManager.cpp" /> <ClCompile Include="CompressionManager.cpp" />
<ClCompile Include="CreateCargo.cpp" /> <ClCompile Include="CreateCargo.cpp" />
<ClCompile Include="EncryptionManager.cpp" /> <ClCompile Include="EncryptionManager.cpp" />
<ClCompile Include="ExtractCargo.cpp" /> <ClCompile Include="ExtractCargo.cpp" />
<ClCompile Include="Interface.cpp" />
<ClCompile Include="ViewCargo.cpp" /> <ClCompile Include="ViewCargo.cpp" />
<ClCompile Include="voidcmd.cpp" /> <ClCompile Include="voidcmd.cpp" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="ChunkManager.h" />
<ClInclude Include="CompressionManager.h" /> <ClInclude Include="CompressionManager.h" />
<ClInclude Include="CreateCargo.h" /> <ClInclude Include="CreateCargo.h" />
<ClInclude Include="DataStruct.h" /> <ClInclude Include="DataStruct.h" />
<ClInclude Include="EncryptionManager.h" /> <ClInclude Include="EncryptionManager.h" />
<ClInclude Include="ExtractCargo.h" /> <ClInclude Include="ExtractCargo.h" />
<ClInclude Include="Interface.h" />
<ClInclude Include="ViewCargo.h" /> <ClInclude Include="ViewCargo.h" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>

12
voidcmd.vcxproj.filters
View file

@ -27,12 +27,6 @@
<ClCompile Include="ViewCargo.cpp"> <ClCompile Include="ViewCargo.cpp">
<Filter>Pliki źródłowe</Filter> <Filter>Pliki źródłowe</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Interface.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="ChunkManager.cpp">
<Filter>Pliki źródłowe</Filter>
</ClCompile>
<ClCompile Include="EncryptionManager.cpp"> <ClCompile Include="EncryptionManager.cpp">
<Filter>Pliki źródłowe</Filter> <Filter>Pliki źródłowe</Filter>
</ClCompile> </ClCompile>
@ -53,12 +47,6 @@
<ClInclude Include="DataStruct.h"> <ClInclude Include="DataStruct.h">
<Filter>Pliki nagłówkowe</Filter> <Filter>Pliki nagłówkowe</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Interface.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="ChunkManager.h">
<Filter>Pliki nagłówkowe</Filter>
</ClInclude>
<ClInclude Include="EncryptionManager.h"> <ClInclude Include="EncryptionManager.h">
<Filter>Pliki nagłówkowe</Filter> <Filter>Pliki nagłówkowe</Filter>
</ClInclude> </ClInclude>