Merge pull request 'Wywołanie_i/o' (#11) from Wywołanie_i/o into master

Reviewed-on: #11

ChunkManager.h

@@ -18,10 +18,10 @@ public:
 	ChunkManager(EncryptionManager& em);
 	~ChunkManager();
 
-	// Kompresja danych
+	// Podział na chunki
 	std::vector<char> chunked(const std::vector<char>&, const bool&, const bool&);
 
-	// Dekompresja
+	// Zcalanie chunków
 	std::vector<char> dechunked(const std::vector<char>&, const bool&, const bool&);
 
 private:

CreateCargo.cpp

@@ -38,7 +38,7 @@ CreateCargo::~CreateCargo() {
 //-----------------------------------------------------------------------------
 //   Punk wejœcia do tworzenia archivum
 //-----------------------------------------------------------------------------
-bool CreateCargo::Create(const std::string& path, const int16_t& flag)
+bool CreateCargo::Create(const std::string& path, const short& flag)
 {
 	cargoFile = path + "." + extension;
 	catalogPath = path;
@@ -111,6 +111,13 @@ bool CreateCargo::GetFileList(const std::string& path)
 		else
 		{
 			std::string fileRef = RemoveStartPath(PathToUnixLike(tmpPath));
+
+			if (fileRef.length() > 255)
+			{
+				std::cerr << "The file path is too long. It exceeds 255 characters." << std::endl;
+			}
+			else
+			{
 				PathConf pc;
 				if (methodFlags > -1)
 				{
@@ -124,11 +131,11 @@ bool CreateCargo::GetFileList(const std::string& path)
 					{
 						if (FindOnTheList(zipList, fileRef) || CheckFileExtension(fileRef, zipList))
 						{
-						pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? 3 : 1;
+							pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? FILE_FLAG_ZIPENC : FILE_FLAG_COMPRESS;
 						}
 						else
 						{
-						pc.parameter = FindOnTheList(encList, fileRef) || CheckFileExtension(fileRef, encList) ? 2 : 0;
+							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;
@@ -137,6 +144,7 @@ bool CreateCargo::GetFileList(const std::string& path)
 				}
 			}
 		}
+	}
 
 	return filesPaths.size() > 0 ? true : false;
 }
@@ -186,7 +194,7 @@ CargoHead CreateCargo::CreateCargoHead(const uint32_t& filesLen, const uint64_t&
 //-----------------------------------------------------------------------------
 //   Sprawdza czy plik znajduje siê na liœcie
 //-----------------------------------------------------------------------------
-void CreateCargo::computingBytes(const int16_t& flag, std::vector<char>& input, std::vector<char>& output)
+void CreateCargo::computingBytes(const int8_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
@@ -194,19 +202,19 @@ void CreateCargo::computingBytes(const int16_t& flag, std::vector<char>& input,
 
 	switch (flag)
 	{
-	case 1:
+	case FILE_FLAG_COMPRESS:
 		output = cm.chunked(input, true, false);
 		break;
 
-	case 2:
+	case FILE_FLAG_ENCRYPT:
 		output = cm.chunked(input, false, true);
 		break;
 
-	case 3:
+	case FILE_FLAG_ZIPENC:
 		output = cm.chunked(input, true, true);
 		break;
 
-	case 4:
+	case FILE_FLAG_RAW:
 		output = cm.chunked(input, false, false);
 		break;
 
@@ -245,7 +253,7 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
 
 		if (size > MAX_FILE_SIZE)
 		{
-			std::cerr << path << " is too large. It exceeds 2GB!" << std::endl;
+			std::cerr << path << " is too large. It exceeds " << MAX_FILE_SIZE / 1024 / 1024 / 1024 << "GB!" << std::endl;
 		}
 		else
 		{
@@ -255,7 +263,7 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
 			f.close();
 
 			//Tworzenie hashu CRC
-			const uint64_t crc = XXH64(buffer.data(), buffer.size(), VERSION);
+			const uint64_t crc = XXH64(buffer.data(), buffer.size(), 0);
 
 			//Kompresjia
 			std::vector<char> pakBuffer;
@@ -267,7 +275,7 @@ std::vector<FilesTable> CreateCargo::ComputingHeadFiles()
 			ft.hashName = fnv64(path);
 			ft.offset = offset;
 			ft.size = pakBuffer.size();
-			ft.flag = file.parameter;
+			ft.flag = static_cast<int8_t>(file.parameter);
 			ft.crc = crc;
 
 			cargo.write(reinterpret_cast<const char*>(pakBuffer.data()), pakBuffer.size());

CreateCargo.h

@@ -47,7 +47,7 @@
 struct PathConf
 {
 	std::string path;
-	int16_t parameter;
+	int8_t parameter;
 };
 
 class CreateCargo {
@@ -56,12 +56,12 @@ public:
 	virtual ~CreateCargo();
 
 	// Punk wejœcia do tworzenia archivum
-	bool Create(const std::string&, const int16_t&);
+	bool Create(const std::string&, const short&);
 
 private:
 	const std::string signature;
 	const std::string extension;
-	const short version;
+	const signed char version;
 
 	short methodFlags;
 
@@ -87,10 +87,6 @@ private:
 	std::ofstream cargo;
 	uint64_t offset;
 
-	// Progress
-	std::atomic<uint64_t> progress;
-
-
 
 	// Tworzenie listy plików do spakowania
 	bool GetFileList(const std::string&);
@@ -114,7 +110,7 @@ private:
 	void GetFilters(const std::string&);
 
 	// Sprawdza czy plik znajduje siê na liœcie
-	void computingBytes(const int16_t&, std::vector<char>&, std::vector<char>&);
+	void computingBytes(const int8_t&, std::vector<char>&, std::vector<char>&);
 
 	// Sprawdzanie rozsze¿eñ plików
 	bool CheckFileExtension(const std::string&, const std::vector<std::string>&);

DataStruct.h

@@ -25,9 +25,14 @@
 #define EXTENSION "pak"
 #define SIGNATURE "XPAK"
 
-#define SIGNATURE_KEY_FILE   1497713496  // XKEY
+#define SIGNATURE_KEY_FILE "XKEY"
 
-#define VERSION	  300
+#define VERSION	  0x03
+
+// WielkoϾ pojedynczego bloku strumienia
+#define CHUNK_STREAM_512KB 524288 // 512KB
+#define CHUNK_STREAM_16MB  16777216 // 16MB
+#define CHUNK_STREAM_256MB 268435456 // 256MB
 
 enum StoreMethod
 {
@@ -38,39 +43,39 @@ enum StoreMethod
 	COMPRESSxENCRYPT = 3
 };
 
+#define FILE_FLAG_RAW      0x00
+#define FILE_FLAG_COMPRESS 0x01
+#define FILE_FLAG_ENCRYPT  0x02
+#define FILE_FLAG_ZIPENC   0x03
+#define FILE_FLAG_CHUNK    0x04
+
 
 //Prgoram title
 #define PROGRAM_TITLE     "eXtendet PAK"
-#define PROGRAM_VERSION   "v1.3"
+#define PROGRAM_VERSION   "v0.4"
 #define PROGRAM_AUTHOR    "Yanczi"
-#define PROGRAM_COMPILING "16 November 2025"
+#define PROGRAM_COMPILING "12 December 2025"
 #define PROGRAM_LICENSE   "GNU LGPL v3"
 
 //Limity
-#define MAX_FILE_SIZE   2147483648    // 2GB
+#define MAX_FILE_SIZE   8589934592    // 8GB
 #define MAX_PAK_SIZE    8796093022208 // 8TB
 
-// Metody zapisania pliku
-#define RAW_FILE    0
-#define ZIP_FILE    1
-#define CRYPT_FILE  2
-#define CRYPT_ZIP   3
-
 struct CargoHead
 {
 	std::string signature;
-	int16_t version;
+	int8_t version;
 	uint32_t files;
 	uint64_t table;
 };
 
 struct FilesTable
 {
-	int16_t nameLen;
+	uint8_t nameLen;
 	std::string nameFile;
 	uint64_t hashName;
 	uint64_t offset;
 	uint64_t size;
 	uint64_t crc;
-	int16_t flag;
+	int8_t flag;
 };

EncryptionManager.cpp

@@ -67,8 +67,8 @@ void EncryptionManager::generateKeys()
 
 void EncryptionManager::saveKey(const std::string& path, bool hpp)
 {
-    const int sig = SIGNATURE_KEY_FILE;
-    const short ver = VERSION;
+    const std::string sig = SIGNATURE_KEY_FILE;
+    const int8_t ver = VERSION;
 
     // Wygeneruj time stamp
     std::time_t now = std::time(nullptr);
@@ -84,7 +84,7 @@ void EncryptionManager::saveKey(const std::string& path, bool hpp)
     std::ofstream file(path + ".key", std::ios::binary);
     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*>(&time), sizeof(time));
     file.write(reinterpret_cast<const char*>(keyVec.data()), keyVec.size());
@@ -138,16 +138,17 @@ void EncryptionManager::loadKey(const std::string& path)
 {
     std::ifstream file(path + ".key", std::ios::binary);
 
-    int sig;
-    short ver;
+    const std::string signature = SIGNATURE_KEY_FILE;
+    std::vector<char> sig(signature.size());
+    int8_t ver;
     int time;
 
     // Wczytaj
-    file.read(reinterpret_cast<char*>(&sig), sizeof(sig));
+    file.read(sig.data(), sig.size());
     file.read(reinterpret_cast<char*>(&ver), sizeof(ver));
 
     // 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!");
     }

ExtractCargo.cpp

@@ -89,7 +89,7 @@ bool ExtractCargo::Extract(const std::string& cFile)
 bool ExtractCargo::CheckCargoFile()
 {
 	std::vector<char> magic(signature.size());
-	short cargoVer = 0;
+	int8_t cargoVer = 0;
 
 	if (!cargoFile.is_open())
 	{
@@ -124,7 +124,7 @@ bool ExtractCargo::CheckCargoFile()
 //-----------------------------------------------------------------------------
 bool ExtractCargo::HashValid(const std::vector<char>& data, const uint64_t& crc)
 {
-	uint64_t actualCrc = XXH64(data.data(), data.size(), VERSION);
+	uint64_t actualCrc = XXH64(data.data(), data.size(), 0);
 
 	if (actualCrc != crc)
 	{
@@ -137,25 +137,25 @@ bool ExtractCargo::HashValid(const std::vector<char>& data, const uint64_t& crc)
 //-----------------------------------------------------------------------------
 //   Magiczna funkcja do dekompresji i deszyfracji danych
 //-----------------------------------------------------------------------------
-void ExtractCargo::computingBytes(const std::vector<char>& input, std::vector<char>& output, const int16_t& flag)
+void ExtractCargo::computingBytes(const std::vector<char>& input, std::vector<char>& output, const int8_t& flag)
 {
 	ChunkManager cm(eman);
 	
 	switch (flag)
 	{
-	case 1:
+	case FILE_FLAG_COMPRESS:
 		output = cm.dechunked(input, true, false);
 		break;
 	
-	case 2:
+	case FILE_FLAG_ENCRYPT:
 		output = cm.dechunked(input, false, true);
 		break;
 	
-	case 3:
+	case FILE_FLAG_ZIPENC:
 		output = cm.dechunked(input, true, true);
 		break;
 
-	case 4:
+	case FILE_FLAG_CHUNK:
 		output = cm.dechunked(input, false, false);
 		break;
 	

ExtractCargo.h

@@ -49,7 +49,7 @@ private:
 	uint64_t tablePosition;
 	int filesHeadsOffset;
 
-	const short version;
+	const int8_t version;
 	const std::string signature;
 
 	std::vector<FilesTable> filesHeads;
@@ -76,6 +76,6 @@ private:
 	void CreateDirections(std::filesystem::path);
 
 	// Magiczna funkcja do dekompresji i deszyfracji danych
-	void computingBytes(const std::vector<char>&, std::vector<char>&, const int16_t&);
+	void computingBytes(const std::vector<char>&, std::vector<char>&, const int8_t&);
 
 };

ViewCargo.cpp

@@ -70,7 +70,7 @@ bool ViewCargo::View(const std::string& path)
 bool ViewCargo::CheckCargoFile(const std::string& path)
 {
 	std::vector<char> magic(signature.length());
-	short cargoVer = 0;
+	int8_t cargoVer = 0;
 
 	std::ifstream cargo(path, std::ios::binary);
 
@@ -146,7 +146,7 @@ void ViewCargo::GetFileList(const std::string& path)
 //-----------------------------------------------------------------------------
 //  Generowanie wierszy do tabeli
 //-----------------------------------------------------------------------------
-void ViewCargo::CreateTableRow(const std::string& file, const uint8_t& zip, const uint64_t& hash)
+void ViewCargo::CreateTableRow(const std::string& file, const uint8_t& flag, const uint64_t& hash)
 {
 	//Zamiania crc liczbowej na hex string
 	std::stringstream ss;
@@ -161,19 +161,19 @@ void ViewCargo::CreateTableRow(const std::string& file, const uint8_t& zip, cons
 	ftxui::Element eEnc;
 
 	// Ustawianie checkboxów
-	switch (zip)
+	switch (flag)
 	{
-	case 1:
+	case FILE_FLAG_COMPRESS:
 		//eZip = ftxui::text(" [x] ") | ftxui::color(ftxui::Color::Cyan);
 		//eEnc = ftxui::text(" [ ] ") | ftxui::color(ftxui::Color::White);
 		tmpList[0] = "[x]";
 		break;
 
-	case 2:
+	case FILE_FLAG_ENCRYPT:
 		tmpList[1] = "[x]";
 		break;
 
-	case 3:
+	case FILE_FLAG_ZIPENC:
 		tmpList[0] = "[x]";
 		tmpList[1] = "[x]";
 		break;

testx2/text_file.txt

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

voidcmd.cpp

@@ -110,7 +110,7 @@ int main(int argc, char* argv[]) {
 
 			if (!EmptyPath(path)) { return 1; }
 
-			if (!cargo.Create(path, 1))
+			if (!cargo.Create(path, 0x01))
 			{
 				return 1;
 			}
@@ -120,7 +120,7 @@ int main(int argc, char* argv[]) {
 		if (arg == "-r" && i + 1 < argc)
 		{
 			path = argv[i + 1];
-			if (!cargo.Create(path, 0))
+			if (!cargo.Create(path, 0x00))
 			{
 				return 1;
 			}
@@ -130,7 +130,7 @@ int main(int argc, char* argv[]) {
 		if (arg == "-e" && i + 1 < argc)
 		{
 			path = argv[i + 1];
-			if (!cargo.Create(path, 2))
+			if (!cargo.Create(path, 0x02))
 			{
 				return 1;
 			}
@@ -140,7 +140,7 @@ int main(int argc, char* argv[]) {
 		if (arg == "-s" && i + 1 < argc)
 		{
 			path = argv[i + 1];
-			if (!cargo.Create(path, 3))
+			if (!cargo.Create(path, 0x03))
 			{
 				return 1;
 			}
@@ -151,7 +151,7 @@ int main(int argc, char* argv[]) {
 		{
 			path = argv[i + 1];
 			if (!EmptyPath(path)) { return 1; }
-			if (!cargo.Create(path, -1))
+			if (!cargo.Create(path, 0xFF))
 			{
 				return 1;
 			}