mirror of
https://github.com/google/fuse-archive.git
synced 2026-11-20 16:41:43 +00:00
218 lines
7.0 KiB
C++
218 lines
7.0 KiB
C++
// Copyright 2021 The Fuse-Archive Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef LIB_READER_H
|
|
#define LIB_READER_H
|
|
|
|
#include <archive.h>
|
|
#include <archive_entry.h>
|
|
|
|
#include <memory>
|
|
#include <span>
|
|
#include <string_view>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
|
|
#include <boost/intrusive/list.hpp>
|
|
|
|
#include "common.h"
|
|
#include "util.h"
|
|
|
|
namespace fuse_archive {
|
|
|
|
namespace bi = boost::intrusive;
|
|
|
|
struct Node;
|
|
class Tree;
|
|
|
|
#ifdef NDEBUG
|
|
using LinkMode = bi::link_mode<bi::normal_link>;
|
|
#else
|
|
using LinkMode = bi::link_mode<bi::safe_link>;
|
|
#endif
|
|
|
|
// A Reader bundles libarchive concepts (an archive and an archive entry) and
|
|
// other state to point to a particular offset (in decompressed space) of a
|
|
// particular archive entry (identified by its index) in an archive.
|
|
//
|
|
// A Reader is backed by its own archive_read_open call so each can be
|
|
// positioned independently.
|
|
struct Reader : bi::list_base_hook<LinkMode> {
|
|
// Global count of Reader instances created.
|
|
static int count;
|
|
|
|
// Unique identifier for this Reader instance.
|
|
int const id = ++count;
|
|
|
|
// The descriptor of the archive this reader is operating on.
|
|
ArchiveDescriptor* const descriptor;
|
|
|
|
// The virtual file system tree this reader belongs to.
|
|
Tree& tree;
|
|
|
|
// libarchive handle for reading the archive.
|
|
ArchivePtr archive = ArchivePtr(archive_read_new());
|
|
|
|
// Current entry being processed by libarchive.
|
|
Entry* entry = nullptr;
|
|
|
|
// Index of the current entry within the archive (1-based).
|
|
i64 index_within_archive = 0;
|
|
|
|
// Current offset within the decompressed entry content.
|
|
i64 offset_within_entry = 0;
|
|
|
|
// Whether to log loading progress for this archive.
|
|
bool should_print_progress = false;
|
|
|
|
// Current position within the raw compressed archive file.
|
|
i64 raw_pos = 0;
|
|
|
|
// Buffer for reading raw data from the archive file.
|
|
char raw_bytes[16 * 1024];
|
|
|
|
// Rolling buffer of uncompressed bytes to handle out-of-order kernel reads.
|
|
//
|
|
// See (https://crbug.com/1245925#c18).
|
|
//
|
|
// Even when libfuse is single-threaded, we have seen kernel readahead
|
|
// causing the offset arguments in a sequence of read calls to sometimes
|
|
// arrive out-of-order, where conceptually consecutive reads are swapped. With
|
|
// a rolling buffer, we can serve the second-to-arrive request by a cheap
|
|
// memcpy instead of an expensive "re-do decompression from the start".
|
|
static ssize_t const rolling_buffer_size = 256 * 1024;
|
|
static ssize_t const rolling_buffer_mask = rolling_buffer_size - 1;
|
|
char rolling_buffer[rolling_buffer_size];
|
|
|
|
// Destroys the reader and its internal libarchive state.
|
|
~Reader();
|
|
|
|
// Initializes a reader for the given archive and tree.
|
|
Reader(ArchiveDescriptor* descriptor, Tree& tree);
|
|
|
|
// Formats the reader for logging (e.g. "Reader #5").
|
|
friend std::ostream& operator<<(std::ostream& out, const Reader& r);
|
|
|
|
// Advances to the next entry in the archive. Returns the entry or nullptr if
|
|
// EOF.
|
|
Entry* NextEntry();
|
|
|
|
// Gets the offset within the current entry of the beginning of the rolling
|
|
// buffer.
|
|
i64 GetBufferOffset() const {
|
|
return std::max<i64>(offset_within_entry - rolling_buffer_size, 0);
|
|
}
|
|
|
|
// Advances the reader to the specified entry index within the archive.
|
|
void AdvanceIndex(i64 want);
|
|
|
|
// Advances the reader to the specified decompressed offset within the current
|
|
// entry.
|
|
void AdvanceOffset(i64 want);
|
|
|
|
// Returns the total decompressed size of the current entry.
|
|
// May perform full decompression if the archive header does not provide it.
|
|
i64 GetEntrySize();
|
|
|
|
// Checks if the archive requires a password and prompts the user if
|
|
// necessary.
|
|
void CheckPassword();
|
|
|
|
// Reads decompressed data from the current entry into the provided buffer.
|
|
// Updates offset_within_entry and the rolling buffer.
|
|
i64 Read(char* dst_ptr, i64 dst_len);
|
|
|
|
// Reads decompressed data into a span.
|
|
ssize_t Read(std::span<char> dst);
|
|
|
|
// Reads decompressed data from a specific offset into a span.
|
|
// Precondition: offset >= GetBufferOffset() and offset <=
|
|
// offset_within_entry.
|
|
ssize_t Read(i64 from_offset, std::span<char> dst);
|
|
|
|
// Reads data from the current entry of archive |a| and writes it into
|
|
// |dest_fd| starting at offset |file_start_offset|. Returns the new total
|
|
// size of the cache file.
|
|
//
|
|
// If |node| is non null, it also discovers and remembers "holes" (sparse
|
|
// regions) in the file and updates the node's block count.
|
|
//
|
|
// Preconditions:
|
|
// - |a| must point to a valid entry.
|
|
//
|
|
// Throws ExitCode::CANNOT_WRITE_CACHE in case of an I/O error.
|
|
// Throws ExitCode::INVALID_ARCHIVE_CONTENTS in case of integer overflow or
|
|
// unexpected data format.
|
|
i64 CacheEntryData(const FileDescriptor& dest_fd,
|
|
i64 file_start_offset,
|
|
Node* node = nullptr);
|
|
|
|
// Deleter for unique_ptr that puts the reader into the recycle bin instead of
|
|
// deleting it.
|
|
struct Recycler {
|
|
void operator()(Reader* r) const;
|
|
};
|
|
|
|
using Ptr = std::unique_ptr<Reader, Recycler>;
|
|
|
|
private:
|
|
friend class ReaderTest;
|
|
friend class Tree;
|
|
|
|
// Read a password from the standard input if necessary.
|
|
static const char* ReadPassword(Archive* a, void* client_data);
|
|
|
|
// Internal helper to check libarchive status codes and throw on failure.
|
|
void Check(int status) const;
|
|
|
|
// Configures libarchive to handle TAR formats.
|
|
void SetTarFormat();
|
|
|
|
// Configures libarchive to handle RAR formats.
|
|
void SetRarFormat();
|
|
|
|
// Configures libarchive to handle RPM formats.
|
|
void SetRpmFormat();
|
|
|
|
// Configures filters based on filename extension.
|
|
bool SetFilter(std::string_view ext);
|
|
|
|
// Configures compressed TAR formats (e.g. .tar.gz).
|
|
bool SetCompressedTarFormat(std::string_view ext);
|
|
|
|
// Format configuration helpers used during filename-based detection.
|
|
bool SetFormatBeforeExtraFilter(std::string_view ext);
|
|
bool SetFormatAfterExtraFilter(std::string_view ext);
|
|
|
|
// High-level method to detect and set the archive format based on its
|
|
// filename.
|
|
void SetFormat();
|
|
|
|
// libarchive callbacks for reading from the underlying ArchiveDescriptor's
|
|
// file descriptor.
|
|
static ssize_t ReadRaw(Archive* a, void* p, const void** out);
|
|
static i64 SeekRaw(Archive*, void* p, i64 offset, int whence);
|
|
static i64 SkipRaw(Archive*, void* p, i64 delta);
|
|
|
|
// Throttler for loading progress log messages.
|
|
Beat g_progress_beat;
|
|
|
|
// Logs the current loading progress (0-100%).
|
|
void PrintProgress() const;
|
|
};
|
|
|
|
} // namespace fuse_archive
|
|
|
|
#endif // LIB_READER_H
|