PulseStudio/VoxelEngine
PulseStudio/VoxelEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

cleanup

Browse Source
This commit is contained in:
MihailRis 2025-02-26 00:22:57 +03:00
parent b52cc1aea0
commit 7facc33a7e
2 changed files with 74 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
src/io/devices/ZipFileDevice.cpp
View File

@ -81,19 +81,19 @@ ZipFileDevice::Entry ZipFileDevice::readEntry() {
read_int(file, entry.crc32);
read_int(file, entry.compressedSize);
read_int(file, entry.uncompressedSize);
auto fileNameLength = read_int<uint16_t>(file);
auto extraFieldLength = read_int<uint16_t>(file);
auto fileCommentLength = read_int<uint16_t>(file);
auto filename_len = read_int<uint16_t>(file);
auto extra_field_len = read_int<uint16_t>(file);
auto file_comment_len = read_int<uint16_t>(file);
read_int(file, entry.diskNumberStart);
read_int(file, entry.internalAttributes);
read_int(file, entry.externalAttributes);
read_int(file, entry.localHeaderOffset);
entry.fileName.resize(fileNameLength, '\0');
file->read(entry.fileName.data(), fileNameLength);
entry.fileName.resize(filename_len, '\0');
file->read(entry.fileName.data(), filename_len);
// Skip extra field and file comment
file->seekg(extraFieldLength + fileCommentLength, std::ios::cur);
file->seekg(extra_field_len + file_comment_len, std::ios::cur);
if (entry.diskNumberStart == 0xFF) {
throw std::runtime_error("zip64 is not supported");
@ -124,11 +124,11 @@ void ZipFileDevice::findBlob(Entry& entry) {
read_int<uint32_t>(file); // crc32
read_int<uint32_t>(file); // compressed size
read_int<uint32_t>(file); // uncompressed size
auto nameLength = read_int<uint16_t>(file);
auto extraFieldLength = read_int<uint16_t>(file);
auto name_len = read_int<uint16_t>(file);
auto extra_field_len = read_int<uint16_t>(file);
// Skip extra field and file comment
file->seekg(nameLength + extraFieldLength, std::ios::cur);
file->seekg(name_len + extra_field_len, std::ios::cur);
entry.blobOffset = file->tellg();
}
@ -138,10 +138,10 @@ ZipFileDevice::ZipFileDevice(
: file(std::move(filePtr)), separateFunc(std::move(separateFunc)) {
// Searching for EOCD
file->seekg(0, std::ios::end);
std::streampos fileSize = file->tellg();
std::streampos file_size = file->tellg();
bool foundEOCD = false;
for (int pos = static_cast<int>(fileSize)-4; pos >= 0; --pos) {
for (int pos = static_cast<int>(file_size)-4; pos >= 0; --pos) {
file->seekg(pos);
if (read_int<uint32_t>(file) == EOCD_SIGNATURE) {
foundEOCD = true;
@ -156,14 +156,14 @@ ZipFileDevice::ZipFileDevice(
read_int<uint16_t>(file); // diskNumber
read_int<uint16_t>(file); // centralDirDisk
read_int<uint16_t>(file); // numEntriesThisDisk
auto totalEntries = read_int<uint16_t>(file);
auto total_entries = read_int<uint16_t>(file);
read_int<uint32_t>(file); // centralDirSize
auto centralDirOffset = read_int<uint32_t>(file);
auto central_dir_offset = read_int<uint32_t>(file);
read_int<uint16_t>(file); // commentLength
file->seekg(centralDirOffset);
file->seekg(central_dir_offset);
for (uint16_t i = 0; i < totalEntries; i++) {
for (uint16_t i = 0; i < total_entries; i++) {
if (read_int<uint32_t>(file) != CENTRAL_DIR_SIGNATURE) {
logger.error() << "invalid central directory entry";
break;
@ -198,22 +198,22 @@ std::unique_ptr<std::istream> ZipFileDevice::read(std::string_view path) {
if (entry.blobOffset == 0) {
findBlob(entry);
}
std::unique_ptr<std::istream> srcStream;
std::unique_ptr<std::istream> src_stream;
if (separateFunc) {
// Create new istream for concurrent data reading
srcStream = separateFunc();
srcStream->seekg(entry.blobOffset);
src_stream = separateFunc();
src_stream->seekg(entry.blobOffset);
} else {
// Read compressed data to memory if istream cannot be separated
file->seekg(entry.blobOffset);
util::Buffer<char> buffer(entry.compressedSize);
file->read(buffer.data(), buffer.size());
srcStream = std::make_unique<memory_istream>(std::move(buffer));
src_stream = std::make_unique<memory_istream>(std::move(buffer));
}
if (entry.compressionMethod == COMPRESSION_NONE) {
return srcStream;
return src_stream;
} else if (entry.compressionMethod == COMPRESSION_DEFLATE) {
return std::make_unique<deflate_istream>(std::move(srcStream));
return std::make_unique<deflate_istream>(std::move(src_stream));
} else {
throw std::runtime_error(
"unsupported compression method [" +
@ -301,17 +301,17 @@ std::unique_ptr<PathsGenerator> ZipFileDevice::list(std::string_view path) {
}
} else {
auto folder = std::string(path) + "/";
size_t folderLen = folder.length();
size_t folder_len = folder.length();
for (const auto& [name, entry] : entries) {
if (name.find(folder) != 0) {
continue;
}
size_t pos = name.find('/', folderLen);
size_t pos = name.find('/', folder_len);
if (pos == std::string::npos) {
names.push_back(name.substr(folderLen, pos - folderLen));
names.push_back(name.substr(folder_len, pos - folder_len));
}
if (pos == name.length() - 1) {
names.push_back(name.substr(folderLen, pos - folderLen));
names.push_back(name.substr(folder_len, pos - folder_len));
}
}
}
@ -324,60 +324,59 @@ std::unique_ptr<PathsGenerator> ZipFileDevice::list(std::string_view path) {
static void write_headers(
std::ostream& file,
const std::string& name,
size_t srcSize,
size_t compressedSize,
size_t source_Size,
size_t compressed_size,
uint32_t crc,
int compressionMethod,
const file_time_type& modificationTime,
ByteBuilder& centralDir
int compression_method,
const file_time_type& last_write_time,
ByteBuilder& central_dir
) {
auto timestamp = to_ms_dos_timestamp(modificationTime);
auto timestamp = to_ms_dos_timestamp(last_write_time);
ByteBuilder header;
header.putInt32(LOCAL_FILE_SIGNATURE);
header.putInt16(10); // version
header.putInt16(0); // flags
header.putInt16(compressionMethod); // compression method
header.putInt16(compression_method); // compression method
header.putInt32(timestamp); // last modification datetime
header.putInt32(crc); // crc32
header.putInt32(compressedSize);
header.putInt32(srcSize);
header.putInt32(compressed_size);
header.putInt32(source_Size);
header.putInt16(name.length());
header.putInt16(0); // extra field length
header.put(reinterpret_cast<const ubyte*>(name.data()), name.length());
size_t localHeaderOffset = file.tellp();
size_t local_header_offset = file.tellp();
file.write(reinterpret_cast<const char*>(header.data()), header.size());
centralDir.putInt32(CENTRAL_DIR_SIGNATURE);
centralDir.putInt16(10); // version
centralDir.putInt16(0); // version
centralDir.putInt16(0); // flags
centralDir.putInt16(compressionMethod); // compression method
centralDir.putInt32(timestamp); // last modification datetime
centralDir.putInt32(crc); // crc32
centralDir.putInt32(compressedSize);
centralDir.putInt32(srcSize);
centralDir.putInt16(name.length());
centralDir.putInt16(0); // extra field length
centralDir.putInt16(0); // file comment length
centralDir.putInt16(0); // disk number start
centralDir.putInt16(0); // internal attributes
centralDir.putInt32(0); // external attributes
centralDir.putInt32(localHeaderOffset); // local header offset
centralDir.put(reinterpret_cast<const ubyte*>(name.data()), name.length());
central_dir.putInt32(CENTRAL_DIR_SIGNATURE);
central_dir.putInt16(10); // version
central_dir.putInt16(0); // version
central_dir.putInt16(0); // flags
central_dir.putInt16(compression_method); // compression method
central_dir.putInt32(timestamp); // last modification datetime
central_dir.putInt32(crc); // crc32
central_dir.putInt32(compressed_size);
central_dir.putInt32(source_Size);
central_dir.putInt16(name.length());
central_dir.putInt16(0); // extra field length
central_dir.putInt16(0); // file comment length
central_dir.putInt16(0); // disk number start
central_dir.putInt16(0); // internal attributes
central_dir.putInt32(0); // external attributes
central_dir.putInt32(local_header_offset); // local header offset
central_dir.put(reinterpret_cast<const ubyte*>(name.data()), name.length());
}
static size_t write_zip(
const std::string& root,
const path& folder,
std::ostream& file,
ByteBuilder& centralDir
ByteBuilder& central_dir
) {
size_t entries = 0;
ByteBuilder localHeader;
for (const auto& entry : io::directory_iterator(folder)) {
auto name = entry.pathPart().substr(root.length() + 1);
auto modificationTime = io::last_write_time(entry);
auto last_write_time = io::last_write_time(entry);
if (io::is_directory(entry)) {
name = name + "/";
write_headers(
@ -387,35 +386,35 @@ static size_t write_zip(
0,
0,
COMPRESSION_NONE,
modificationTime,
centralDir
last_write_time,
central_dir
);
entries += write_zip(root, entry, file, centralDir) + 1;
entries += write_zip(root, entry, file, central_dir) + 1;
} else {
auto uncompressed = io::read_bytes_buffer(entry);
uint32_t crc = crc32(0, uncompressed.data(), uncompressed.size());
memory_ostream memoryStream;
memory_ostream memory_stream;
{
deflate_ostream deflateStream(memoryStream);
deflateStream.write(
deflate_ostream deflate_stream(memory_stream);
deflate_stream.write(
reinterpret_cast<char*>(uncompressed.data()),
uncompressed.size()
);
deflateStream.flush();
deflate_stream.flush();
}
auto data = memoryStream.release();
size_t dataSize = data.size();
auto data = memory_stream.release();
size_t data_size = data.size();
write_headers(
file,
name,
uncompressed.size(),
dataSize,
data_size,
crc,
COMPRESSION_DEFLATE,
modificationTime,
centralDir
last_write_time,
central_dir
);
file.write(reinterpret_cast<const char*>(data.data()), dataSize);
file.write(reinterpret_cast<const char*>(data.data()), data_size);
entries++;
}
}
@ -423,12 +422,12 @@ static size_t write_zip(
}
void io::write_zip(const path& folder, const path& file) {
ByteBuilder centralDir;
ByteBuilder central_dir;
auto out = io::write(file);
size_t entries = write_zip(folder.pathPart(), folder, *out, centralDir);
size_t entries = write_zip(folder.pathPart(), folder, *out, central_dir);
size_t centralDirOffset = out->tellp();
out->write(reinterpret_cast<const char*>(centralDir.data()), centralDir.size());
size_t central_dir_offset = out->tellp();
out->write(reinterpret_cast<const char*>(central_dir.data()), central_dir.size());
ByteBuilder eocd;
eocd.putInt32(EOCD_SIGNATURE);
@ -436,8 +435,8 @@ void io::write_zip(const path& folder, const path& file) {
eocd.putInt16(0); // central dir disk
eocd.putInt16(entries); // num entries
eocd.putInt16(entries); // total entries
eocd.putInt32(centralDir.size()); // central dir size
eocd.putInt32(centralDirOffset); // central dir offset
eocd.putInt32(central_dir.size()); // central dir size
eocd.putInt32(central_dir_offset); // central dir offset
eocd.putInt16(0); // comment length
out->write(reinterpret_cast<const char*>(eocd.data()), eocd.size());
}

2
src/io/memory_ostream.hpp
View File

@ -23,7 +23,7 @@ public:
}
size_t size() const {
return pptr()-pbase();
return pptr() - pbase();
}
protected:
int_type overflow(int_type c) override {