hfs::anonymous_namespace{hfs_fork_io.cpp} Namespace Reference

Functions
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)
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)

Function Documentation

collect_overflow_extents()

size_t hfs::anonymous_namespace{hfs_fork_io.cpp}::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 )

Definition at line 138 of file hfs_fork_io.cpp.

                                                             {
    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;
}

References hfs::be16(), hfs::be32(), hfs::ForkExtent::block_count, collect_overflow_extents(), hfs::HeaderRec::nodeSize, hfs::ForkExtent::start_block, and hfs::walk_btree().

Referenced by collect_overflow_extents().

read_one_extent()

bool hfs::anonymous_namespace{hfs_fork_io.cpp}::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 )

Definition at line 112 of file hfs_fork_io.cpp.

                                                     {
    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;
}

References hfs::ForkExtent::block_count, DiskReader::read_at(), read_one_extent(), and hfs::ForkExtent::start_block.

Referenced by read_one_extent().