482 lines
14 KiB
C++
482 lines
14 KiB
C++
/*
|
|
* 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 "CreateCargo.h"
|
|
|
|
CreateCargo::CreateCargo()
|
|
: signature(SIGNATURE)
|
|
, extension(EXTENSION)
|
|
, version(VERSION)
|
|
, methodFlags(0)
|
|
, offset(0)
|
|
{
|
|
// TODO Auto-generated constructor stub
|
|
}
|
|
|
|
CreateCargo::~CreateCargo() {
|
|
// TODO Auto-generated destructor stub
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Punk wejœcia do tworzenia archivum
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::Create(const std::string& path, const int16_t& flag)
|
|
{
|
|
cargoFile = path + "." + extension;
|
|
catalogPath = path;
|
|
methodFlags = flag;
|
|
|
|
std::cout << "#1 FLAG: " << flag << " - " << methodFlags << std::endl;
|
|
|
|
//Sprawdzanie pakowanego kontentu
|
|
if (!std::filesystem::is_directory(path))
|
|
{
|
|
std::cerr << "Error: The specified directory is a file!" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!std::filesystem::exists(path))
|
|
{
|
|
std::cerr << "Error: The specified directory does not exist!" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// Pobieranie listy plików wyj¹tków
|
|
if (flag == -1)
|
|
{
|
|
std::string filterFile = path + ".json";
|
|
if (!std::filesystem::exists(filterFile))
|
|
{
|
|
std::cerr << "Error: Missing " << filterFile << " file!" << std::endl;
|
|
return false;
|
|
}
|
|
GetFilters(filterFile);
|
|
}
|
|
|
|
//Pobieranie listy plików do spakowania
|
|
std::cout << "Creating a file list..." << std::endl;
|
|
if (!GetFileList(path))
|
|
{
|
|
std::cerr << "Error: The specified directory contains no files!" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// Utworzenie kontenera
|
|
cargo.open(cargoFile, std::ios::binary);
|
|
|
|
//Rozpocznij process zapisywania danych do kontenera
|
|
if (!WriteCargo())
|
|
{
|
|
std::cerr << "Error: Failed to create container!" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// Zapisywanie klucza szyfruj¹cego
|
|
if (flag == 2 || flag == 3)
|
|
{
|
|
crypt.saveKey(catalogPath);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Tworzenie listy plików do spakowania
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::GetFileList(const std::string& path)
|
|
{
|
|
for (const auto& el : encList)
|
|
{
|
|
std::cout << el << std::endl;
|
|
}
|
|
|
|
for (const auto& entry : std::filesystem::directory_iterator(path))
|
|
{
|
|
std::string tmpPath = entry.path().string();
|
|
if (std::filesystem::is_directory(tmpPath))
|
|
{
|
|
GetFileList(tmpPath);
|
|
}
|
|
else
|
|
{
|
|
std::string fileRef = RemoveStartPath(PathToUnixLike(tmpPath));
|
|
if (CheckIgnorePath(tmpPath))
|
|
{
|
|
std::cout << "FLAG: " << methodFlags << std::endl;
|
|
PathConf pc;
|
|
if (methodFlags > -1)
|
|
{
|
|
std::cout << "NO FLAG" << std::endl;
|
|
pc.path = PathToUnixLike(tmpPath);
|
|
pc.parameter = methodFlags;
|
|
filesPaths.push_back(pc);
|
|
}
|
|
else
|
|
{
|
|
if (!FindOnTheList(ignoreList, fileRef))
|
|
{
|
|
if (FindOnTheList(zipList, fileRef))
|
|
{
|
|
pc.parameter = FindOnTheList(encList, fileRef) ? 3 : 1;
|
|
}
|
|
else
|
|
{
|
|
pc.parameter = FindOnTheList(encList, fileRef) ? 2 : 0;
|
|
}
|
|
pc.path = PathToUnixLike(tmpPath);
|
|
std::cout << pc.parameter << std::endl;
|
|
filesPaths.push_back(pc);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return filesPaths.size() > 0 ? true : false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Konwersja œcie¿ki na unix like
|
|
//-----------------------------------------------------------------------------
|
|
std::string CreateCargo::PathToUnixLike(std::string path)
|
|
{
|
|
std::replace(path.begin(), path.end(), '\\', '/');
|
|
return path;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Kasowanie wskazanego katalogu ze œcie¿ki
|
|
//-----------------------------------------------------------------------------
|
|
std::string CreateCargo::RemoveStartPath(const std::filesystem::path& path)
|
|
{
|
|
std::filesystem::path cleanPath;
|
|
|
|
auto it = path.begin();
|
|
if (it != path.end()) { ++it; }
|
|
|
|
for (; it != path.end(); ++it)
|
|
{
|
|
cleanPath /= *it;
|
|
}
|
|
|
|
return cleanPath.string();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Tworzenie nag³owka pliku
|
|
//-----------------------------------------------------------------------------
|
|
CargoHead CreateCargo::CreateCargoHead(const uint32_t& filesLen, const uint64_t& table)
|
|
{
|
|
CargoHead ch;
|
|
|
|
ch.signature = signature;
|
|
ch.version = version;
|
|
ch.files = filesLen;
|
|
ch.table = table;
|
|
|
|
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
|
|
CompressingManager cm;
|
|
|
|
switch (flag)
|
|
{
|
|
case 1:
|
|
output = cm.compress(input);
|
|
break;
|
|
|
|
case 2:
|
|
output = crypt.encrypt(input);
|
|
break;
|
|
|
|
case 3:
|
|
output = crypt.encrypt(cm.compress(input));
|
|
break;
|
|
|
|
default:
|
|
output = std::move(input);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Przygotowanie nag³ówków i plików
|
|
//-----------------------------------------------------------------------------
|
|
std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
|
|
{
|
|
//Utwórz header TMP. Zabezpiecza Pierwsze bajty na w³aœciwy nag³ówek
|
|
CargoHead cargoHead = CreateCargoHead(0, 0);
|
|
offset += cargoHead.signature.length() + sizeof(cargoHead.version) + sizeof(cargoHead.files) + sizeof(cargoHead.table);
|
|
|
|
//Zapisanie tymczasowego nag³owka jako rezerwacja miejsca
|
|
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));
|
|
|
|
std::vector<FilesTable> filesTable;
|
|
|
|
//Tworzenie nag³ówków plików jednoczeœnie zapisywanie plików
|
|
for (const auto& file : filesPaths)
|
|
{
|
|
std::string path = PathToUnixLike(RemoveStartPath(file.path));
|
|
std::ifstream f(file.path, std::ios::binary | std::ios::ate);
|
|
|
|
//Obliczanie rozmiaru pliku
|
|
size_t size = f.tellg();
|
|
f.seekg(0, std::ios::beg);
|
|
|
|
//Wczytanie pliku do pamiêci
|
|
std::vector<char> buffer(size);
|
|
f.read(buffer.data(), size);
|
|
f.close();
|
|
|
|
//Tworzenie hashu CRC
|
|
const uint64_t crc = XXH64(buffer.data(), buffer.size(), VERSION);
|
|
|
|
//Kompresjia
|
|
std::vector<char> pakBuffer;
|
|
computingBytes(file.parameter, buffer, pakBuffer);
|
|
|
|
FilesTable ft;
|
|
ft.nameFile = path;
|
|
ft.nameLen = path.length();
|
|
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());
|
|
|
|
filesTable.push_back(ft);
|
|
offset += pakBuffer.size();
|
|
}
|
|
return filesTable;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Wczytanie filtrów wyj¹tków
|
|
//-----------------------------------------------------------------------------
|
|
void CreateCargo::GetFilters(const std::string& filterFile)
|
|
{
|
|
std::cout << "Downloading the exception list" << std::endl;
|
|
|
|
std::ifstream file(filterFile);
|
|
nlohmann::json jslist;
|
|
file >> jslist;
|
|
file.close();
|
|
|
|
// Lista plików do skompresowania
|
|
zipList = jslist[KEY_ZIP].get<std::vector<std::string>>();
|
|
|
|
// Lista plików do zaszyfrowania
|
|
encList = jslist[KEY_ENCRYPT].get<std::vector<std::string>>();
|
|
|
|
// Lista plików do pominiêcia
|
|
ignoreList = jslist[KEY_IGNORE].get<std::vector<std::string>>();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ZnajdŸ wskazany element na liœcie
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::FindOnTheList(const std::vector<std::string>& list, const std::string& element)
|
|
{
|
|
auto it = std::find(list.begin(), list.end(), element);
|
|
return it == list.end() ? false : true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Rozdzielanie paternu od œcie¿ki
|
|
//-----------------------------------------------------------------------------
|
|
void CreateCargo::ExtPatternAndPathDetection(const std::vector<std::string>& data, std::vector<std::string>& pattern, std::vector<std::string>& path)
|
|
{
|
|
for (const auto& d : data)
|
|
{
|
|
if (d.front() == '*')
|
|
{
|
|
std::string tmpPattern = d;
|
|
tmpPattern.erase(tmpPattern.begin());
|
|
pattern.push_back(UpperString(tmpPattern));
|
|
}
|
|
else
|
|
{
|
|
path.push_back(d);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprawdzanie rozsze¿eñ plików
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::CheckFileExtension(const std::filesystem::path& p, const std::vector<std::string>& patterns) {
|
|
std::string ext = UpperString(p.extension().string());
|
|
|
|
return FindOnTheList(patterns, ext);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Zamieñ ca³y ci¹g na du¿e litery
|
|
//-----------------------------------------------------------------------------
|
|
std::string CreateCargo::UpperString(std::string s) {
|
|
std::transform(s.begin(), s.end(), s.begin(),
|
|
[](unsigned char c) { return static_cast<char>(std::toupper(c)); });
|
|
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;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sprawdzanie czy plik znajduje siê na liœcie
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::FilteringData(const std::string& path)
|
|
{
|
|
std::vector<std::string> cmPatterns;
|
|
std::vector<std::string> cmPaths;
|
|
|
|
// Rozdziel œcie¿ki i patterny na osobne listy
|
|
ExtPatternAndPathDetection(zipList, cmPatterns, cmPaths);
|
|
|
|
if (FindOnTheList(cmPatterns, ALL_FILE))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Sprawd¿ czy istnieje plik o danym rozsze¿eniu
|
|
if (CheckFileExtension(path, cmPatterns))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// SprawdŸ czy instnieje dany plik w danej lokalizacji
|
|
if (FindOnTheList(cmPaths, path))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Kasowanie z listy plików ignorow
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::CheckIgnorePath(const std::string& path)
|
|
{
|
|
std::vector<std::string> igPatterns;
|
|
std::vector<std::string> igPaths;
|
|
|
|
ExtPatternAndPathDetection(ignoreList, igPatterns, igPaths);
|
|
|
|
// Sprawd¿ czy istnieje plik o danym rozsze¿eniu
|
|
if (CheckFileExtension(path, igPatterns))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Obrubka œcierzki
|
|
// Usuwanie katalogu root
|
|
std::string cleanPath = RemoveStartPath(path);
|
|
|
|
// Przekszta³cenie œcierzki na format unixowy
|
|
std::string unixPath = PathToUnixLike(cleanPath);
|
|
|
|
// SprawdŸ czy instnieje dany plik w danej lokalizacji
|
|
if (FindOnTheList(igPaths, unixPath))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Trworzenie archiwum
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateCargo::WriteCargo()
|
|
{
|
|
std::cout << "Packing files..." << std::endl;
|
|
|
|
uint32_t filesLen = filesPaths.size();
|
|
|
|
//Przygotowanie nag³ówków plików i przetworzenie danych
|
|
std::vector<FilesTable> filesHead = ComputingHeadFiles();
|
|
|
|
//std::ofstream cargo(cargoFile, std::ios::binary);
|
|
|
|
if (!cargo.is_open())
|
|
{
|
|
std::cerr << "ERROR: Failed to create container " << cargoFile << std::endl;
|
|
return false;
|
|
}
|
|
|
|
for (const auto& head : filesHead)
|
|
{
|
|
// Œcie¿ka do plików
|
|
cargo.write(reinterpret_cast<const char*>(&head.nameLen), sizeof(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.size), sizeof(head.size));
|
|
cargo.write(reinterpret_cast<const char*>(&head.crc), sizeof(head.crc));
|
|
cargo.write(reinterpret_cast<const char*>(&head.flag), sizeof(head.flag));
|
|
}
|
|
|
|
//Cofnij siê na pocz¹tek pliku
|
|
cargo.seekp(std::ios::beg);
|
|
|
|
//Utwórz header
|
|
CargoHead cargoHead = CreateCargoHead(filesLen, offset);
|
|
|
|
//Nadpisz tymczasowy nag³ówek
|
|
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.close();
|
|
|
|
std::cout << "The container was successfully created! " << cargoFile << std::endl;
|
|
|
|
return true;
|
|
}
|