hfs_fork_io.cpp

Go to the documentation of this file.

// hfs_fork_io.cpp -- implementation of fork reading via inline extents.
 
#include "hfs_fork_io.hpp"
#include "hfs_btree.hpp"
 
#include <algorithm>
#include <cstring>
#include <sstream>
 
namespace hfs {
 
bool read_fork_inline(DiskReader& reader,
                      uint64_t volume_offset,
                      uint32_t block_size,
                      const ForkData& fork,
                      uint64_t max_bytes,
                      std::vector<unsigned char>& out,
                      std::vector<std::string>& logs) {
    if (block_size == 0) return false;
 
    // Total bytes we want to read: min of fork.logical_size, max_bytes,
    // and inline-coverage (sum of all extent lengths in bytes).
    uint64_t inline_bytes = 0;
    for (const auto& e : fork.extents) {
        inline_bytes += static_cast<uint64_t>(e.block_count) * block_size;
    }
 
    uint64_t want = std::min<uint64_t>(fork.logical_size, max_bytes);
    if (want > inline_bytes) {
        std::ostringstream m;
        m << "HFS+ fork: requested " << want
          << " bytes but only " << inline_bytes
          << " bytes covered by inline extents (file > 8 extents would "
             "need Extents Overflow file -- session 4)";
        logs.push_back(m.str());
        want = inline_bytes;  // soft truncate
    }
 
    out.clear();
    out.reserve(static_cast<size_t>(want));
 
    uint64_t produced = 0;
    for (const auto& e : fork.extents) {
        if (produced >= want) break;
        if (e.block_count == 0) continue;
 
        const uint64_t ext_disk_off =
            volume_offset
          + static_cast<uint64_t>(e.start_block) * block_size;
        const uint64_t ext_bytes =
            static_cast<uint64_t>(e.block_count) * block_size;
        const uint64_t copy = std::min<uint64_t>(ext_bytes, want - produced);
 
        const size_t before = out.size();
        out.resize(before + static_cast<size_t>(copy));
        if (!reader.read_at(ext_disk_off, out.data() + before, copy)) {
            std::ostringstream m;
            m << "HFS+ fork: read failed at disk offset " << ext_disk_off
              << " for " << copy << " bytes";
            logs.push_back(m.str());
            out.resize(before);
            return false;
        }
        produced += copy;
    }
    return true;
}
 
bool read_fork_block_inline(DiskReader& reader,
                             uint64_t volume_offset,
                             uint32_t block_size,
                             const ForkData& fork,
                             uint64_t fork_logical_offset,
                             unsigned char* block_buf) {
    if (block_size == 0 || block_buf == nullptr) return false;
 
    // The fork is a concatenation of its extents. We walk extents
    // accumulating their byte coverage; when we reach the extent that
    // contains fork_logical_offset, we compute the absolute disk offset
    // and issue a single read.
    uint64_t covered = 0;
    for (const auto& e : fork.extents) {
        if (e.block_count == 0) continue;
        const uint64_t ext_bytes =
            static_cast<uint64_t>(e.block_count) * block_size;
        if (fork_logical_offset < covered + ext_bytes) {
            // Hit. The byte we want is at:
            const uint64_t byte_within_ext = fork_logical_offset - covered;
            // Round to a block boundary (fork_logical_offset should be
            // block-aligned, but be defensive).
            const uint64_t blk_within_ext = byte_within_ext / block_size;
            const uint64_t disk_off =
                volume_offset
              + (static_cast<uint64_t>(e.start_block) + blk_within_ext)
                * block_size;
            return reader.read_at(disk_off, block_buf, block_size);
        }
        covered += ext_bytes;
    }
    // Offset beyond inline coverage -- needs Extents Overflow file.
    return false;
}
 
// =============================================================================
//  read_fork_full (session 4: combines inline + overflow extents)
// =============================================================================
 
namespace {
 
// Read all blocks covered by a single ForkExtent and append to `out`.
// Returns false on read failure; the caller logs/decides.
bool read_one_extent(DiskReader& reader, uint64_t volume_offset,
                      uint32_t block_size, const ForkExtent& e,
                      uint64_t want_bytes,
                      std::vector<unsigned char>& out) {
    if (e.block_count == 0 || want_bytes == 0) return true;
    const uint64_t off = volume_offset
                       + static_cast<uint64_t>(e.start_block) * block_size;
    const uint64_t ext_bytes =
        static_cast<uint64_t>(e.block_count) * block_size;
    const uint64_t copy = std::min<uint64_t>(ext_bytes, want_bytes);
    const size_t before = out.size();
    out.resize(before + static_cast<size_t>(copy));
    if (!reader.read_at(off, out.data() + before, copy)) {
        out.resize(before);
        return false;
    }
    return true;
}
 
// Helper: peek into the Extents Overflow B-tree to find all leaf records
// matching (forkType, fileID), accumulating their extents into `out`.
// Returns the total count of extents found (0 if none).
//
// This is a SCAN of the entire B-tree -- not optimal -- but it's
// straightforward and works for any volume. For really huge volumes a
// keyed descent would be better; we stay simple here.
size_t collect_overflow_extents(const std::vector<unsigned char>& btree_buf,
                                 const HeaderRec& hdr,
                                 uint8_t forkType,
                                 uint32_t fileID,
                                 std::vector<ForkExtent>& out,
                                 std::vector<std::string>& logs) {
    auto node_reader = [&](uint32_t node_index,
                           std::vector<unsigned char>& nodebuf) -> bool {
        const uint64_t off = static_cast<uint64_t>(node_index) * hdr.nodeSize;
        if (off + hdr.nodeSize > btree_buf.size()) return false;
        nodebuf.assign(btree_buf.begin() + off,
                       btree_buf.begin() + off + hdr.nodeSize);
        return true;
    };
 
    size_t found = 0;
    auto on_leaf = [&](const unsigned char* rec, uint16_t rec_len) -> bool {
        // Extents Overflow KEY layout:
        //   __be16 keyLength
        //   __u8   forkType
        //   __u8   pad
        //   __be32 fileID
        //   __be32 startBlock
        if (rec_len < 12) return true;
        const uint16_t keyLength = be16(rec + 0);
        if (keyLength < 10 || 2u + keyLength > rec_len) return true;
        const uint8_t  rec_forkType = rec[2];
        // pad at +3
        const uint32_t rec_fileID    = be32(rec + 4);
        // const uint32_t rec_startBlock = be32(rec + 8);  // not used here
        if (rec_forkType != forkType || rec_fileID != fileID) {
            return true;  // not for us, skip
        }
        // Body: 64 bytes of HFSPlusExtentRecord = 8 extents.
        // Body starts after the 2+keyLength key, aligned to 2 bytes.
        const uint32_t key_total = 2u + keyLength;
        const uint32_t body_off = (key_total + 1u) & ~1u;
        if (body_off + 64 > rec_len) return true;
        const unsigned char* body = rec + body_off;
        for (int i = 0; i < 8; ++i) {
            ForkExtent e;
            e.start_block = be32(body + i * 8 + 0);
            e.block_count = be32(body + i * 8 + 4);
            if (e.block_count == 0) break;  // first zero terminates the run
            out.push_back(e);
            ++found;
        }
        return true;
    };
 
    std::vector<std::string> walk_logs;
    std::string walk_err;
    walk_btree(hdr, node_reader, on_leaf, walk_logs, walk_err);
    for (auto& l : walk_logs) logs.push_back(std::move(l));
    if (!walk_err.empty()) {
        logs.push_back("HFS+ extents-overflow walk: " + walk_err);
    }
    return found;
}
 
} // anonymous namespace
 
bool read_fork_full(DiskReader& reader,
                    uint64_t volume_offset,
                    uint32_t block_size,
                    const ForkData& fork,
                    const ForkData& extents_file,
                    uint8_t forkType,
                    uint32_t fileID,
                    uint64_t max_bytes,
                    std::vector<unsigned char>& extents_btree_buffer,
                    std::vector<unsigned char>& out,
                    std::vector<std::string>& logs) {
    if (block_size == 0) return false;
 
    // Compute inline coverage.
    uint64_t inline_blocks = 0;
    int inline_extent_count = 0;
    for (const auto& e : fork.extents) {
        if (e.block_count == 0) break;  // run terminator
        inline_blocks += e.block_count;
        ++inline_extent_count;
    }
    const uint64_t inline_bytes = inline_blocks * block_size;
 
    const uint64_t want = std::min<uint64_t>(fork.logical_size, max_bytes);
 
    // Fast path: fork fits in inline extents.
    if (fork.total_blocks <= inline_blocks || inline_extent_count < 8) {
        return read_fork_inline(reader, volume_offset, block_size,
                                 fork, want, out, logs);
    }
 
    // Slow path: file has > 8 extents (overflow needed).
    // Step 1: load the Extents Overflow B-tree if not already cached.
    if (extents_btree_buffer.empty()) {
        std::vector<std::string> ld_logs;
        if (!read_fork_inline(reader, volume_offset, block_size,
                               extents_file, extents_file.logical_size,
                               extents_btree_buffer, ld_logs)) {
            logs.push_back("HFS+: cannot load Extents Overflow file content "
                            "(file with >8 extents will be soft-truncated)");
            for (auto& l : ld_logs) logs.push_back(std::move(l));
            extents_btree_buffer.clear();  // mark as "tried but failed"
            return read_fork_inline(reader, volume_offset, block_size,
                                     fork, want, out, logs);
        }
    }
    if (extents_btree_buffer.size() < 14) {
        logs.push_back("HFS+: Extents Overflow file too small for B-tree");
        return read_fork_inline(reader, volume_offset, block_size,
                                 fork, want, out, logs);
    }
 
    // Step 2: parse overflow B-tree header (node 0).
    NodeDescriptor n0;
    if (!parse_node_descriptor(extents_btree_buffer.data(), n0) ||
        n0.kind != kBTHeaderNode) {
        logs.push_back("HFS+: Extents Overflow node 0 not a header node");
        return read_fork_inline(reader, volume_offset, block_size,
                                 fork, want, out, logs);
    }
    HeaderRec ohdr;
    if (!parse_header_rec(extents_btree_buffer.data() + 14, ohdr)) {
        logs.push_back("HFS+: Extents Overflow B-tree header parse failed");
        return read_fork_inline(reader, volume_offset, block_size,
                                 fork, want, out, logs);
    }
 
    // Step 3: collect extra extents from overflow B-tree.
    std::vector<ForkExtent> overflow_extents;
    collect_overflow_extents(extents_btree_buffer, ohdr,
                              forkType, fileID, overflow_extents, logs);
 
    // Step 4: build a unified extent list (8 inline followed by overflow).
    std::vector<ForkExtent> all_extents;
    all_extents.reserve(8 + overflow_extents.size());
    for (const auto& e : fork.extents) {
        if (e.block_count == 0) break;
        all_extents.push_back(e);
    }
    for (const auto& e : overflow_extents) all_extents.push_back(e);
 
    // Step 5: read all blocks in order.
    out.clear();
    out.reserve(static_cast<size_t>(want));
    uint64_t produced = 0;
    for (const auto& e : all_extents) {
        if (produced >= want) break;
        const uint64_t ext_bytes =
            static_cast<uint64_t>(e.block_count) * block_size;
        const uint64_t copy = std::min<uint64_t>(ext_bytes, want - produced);
        if (!read_one_extent(reader, volume_offset, block_size, e, copy, out)) {
            std::ostringstream m;
            m << "HFS+: read failure on overflow extent (start_block="
              << e.start_block << ", count=" << e.block_count << ")";
            logs.push_back(m.str());
            return false;
        }
        produced += copy;
    }
 
    // If we have less than `want`, log it but don't fail (best-effort).
    if (produced < want) {
        std::ostringstream m;
        m << "HFS+: requested " << want << " bytes from fork (fileID="
          << fileID << "), got " << produced
          << " (file may be truncated or overflow records missing)";
        logs.push_back(m.str());
    }
 
    (void)inline_bytes;
    return true;
}
 
} // namespace hfs