Classes
struct	StreamInfo

Public Member Functions
	ExfatRecovery (DiskReader &reader)
bool	recover (uint64_t volume_offset, const fs::path &out_root, std::vector< RecoveredFileRecord > &recovered, std::vector< std::string > &logs, std::string &error)

Private Member Functions
bool	load_vbr (uint64_t volume_offset)
bool	cluster_allocated (uint32_t cluster) const
bool	load_allocation_bitmap ()
uint64_t	cluster_to_offset (uint32_t cluster) const
bool	next_cluster (uint32_t current, uint32_t &next)
std::vector< uint32_t >	cluster_chain (uint32_t start, bool no_fat_chain, uint64_t data_length, size_t hard_limit=1<< 20)
bool	read_cluster (uint32_t cluster, std::vector< unsigned char > &out)
bool	export_stream (const StreamInfo &info, const fs::path &out_dir, std::vector< RecoveredFileRecord > &recovered, std::vector< std::string > &logs, std::string &error)
bool	export_stream_deleted (const StreamInfo &info, const fs::path &out_dir, std::vector< RecoveredFileRecord > &recovered, std::vector< std::string > &logs, std::string &error)
bool	recover_directory (uint32_t start_cluster, const fs::path &out_dir, std::vector< RecoveredFileRecord > &recovered, std::vector< std::string > &logs, std::string &error, std::set< uint32_t > &dir_guard, int depth)

Static Private Member Functions
static std::string	decode_utf16_name (const std::vector< unsigned char > &bytes)

Private Attributes
DiskReader &	reader_
uint64_t	volume_offset_ {0}
uint64_t	partition_offset_sectors_ {0}
uint64_t	volume_length_sectors_ {0}
uint32_t	fat_offset_sectors_ {0}
uint32_t	fat_length_sectors_ {0}
uint32_t	cluster_heap_offset_sectors_ {0}
uint32_t	cluster_count_ {0}
uint32_t	root_dir_cluster_ {2}
uint32_t	serial_number_ {0}
uint8_t	bytes_per_sector_shift_ {0}
uint8_t	sectors_per_cluster_shift_ {0}
uint64_t	bytes_per_sector_ {0}
uint64_t	sectors_per_cluster_ {0}
uint64_t	cluster_size_ {0}
uint64_t	fat_offset_bytes_ {0}
uint64_t	cluster_heap_offset_bytes_ {0}
uint32_t	allocation_bitmap_cluster_ {0}
uint64_t	allocation_bitmap_length_ {0}
std::vector< unsigned char >	allocation_bitmap_

Detailed Description

Definition at line 460 of file filesystem_recovery.cpp.

Constructor & Destructor Documentation

◆ ExfatRecovery()

anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::ExfatRecovery ( DiskReader & reader )

inlineexplicit

Definition at line 462 of file filesystem_recovery.cpp.

462: reader_(reader) {}

anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::reader_

DiskReader & reader_

Definition filesystem_recovery.cpp:494

References reader_.

Member Function Documentation

◆ cluster_allocated()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_allocated ( uint32_t cluster ) const

inlineprivate

Definition at line 541 of file filesystem_recovery.cpp.

                                                   {
        if (cluster < 2 || cluster >= cluster_count_ + 2) return false;
        if (allocation_bitmap_.empty()) return true;
        const uint64_t idx = static_cast<uint64_t>(cluster - 2);
        const uint64_t byte_index = idx / 8;
        const uint8_t bit = static_cast<uint8_t>(idx % 8);
        if (byte_index >= allocation_bitmap_.size()) return false;
        return (allocation_bitmap_[static_cast<size_t>(byte_index)] & (1u << bit)) != 0;
    }

References allocation_bitmap_, and cluster_count_.

Referenced by cluster_chain().

◆ cluster_chain()

std::vector< uint32_t > anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_chain	(	uint32_t	start,
		bool	no_fat_chain,
		uint64_t	data_length,
		size_t	hard_limit = 1 << 20 )

inlineprivate

Definition at line 596 of file filesystem_recovery.cpp.

                                                                                                                          {
        std::vector<uint32_t> chain;
        if (start < 2) return chain;
        if (no_fat_chain) {
            const uint64_t clusters_needed = data_length == 0 ? 1 : (data_length + cluster_size_ - 1) / cluster_size_;
            for (uint64_t i = 0; i < clusters_needed; ++i) {
                const uint32_t cluster = start + static_cast<uint32_t>(i);
                if (cluster < 2 || cluster >= cluster_count_ + 2) break;
                if (!cluster_allocated(cluster)) {
                    chain.clear();
                    break;
                }
                chain.push_back(cluster);
            }
            return chain;
        }
        std::set<uint32_t> seen;
        uint32_t current = start;
        while (current >= 2 && current < 0x0FFFFFF8 && chain.size() < hard_limit && seen.insert(current).second) {
            chain.push_back(current);
            uint32_t next = 0x0FFFFFFF;
            if (!next_cluster(current, next)) break;
            if (next == 0x0FFFFFF7 || next == 0) break;
            current = next;
        }
        return chain;
    }

References cluster_allocated(), cluster_count_, cluster_size_, and next_cluster().

Referenced by export_stream(), load_allocation_bitmap(), and recover_directory().

◆ cluster_to_offset()

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_to_offset ( uint32_t cluster ) const

inlineprivate

Definition at line 584 of file filesystem_recovery.cpp.

                                                       {
        return cluster_heap_offset_bytes_ + static_cast<uint64_t>(cluster - 2) * cluster_size_;
    }

References cluster_heap_offset_bytes_, and cluster_size_.

Referenced by export_stream(), export_stream_deleted(), load_allocation_bitmap(), and read_cluster().

◆ decode_utf16_name()

std::string anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::decode_utf16_name ( const std::vector< unsigned char > & bytes )

inlinestaticprivate

Definition at line 629 of file filesystem_recovery.cpp.

                                                                              {
        // Bug #14 fix: exFAT filenames are UTF-16LE; decode as proper UTF-8
        // instead of replacing non-ASCII with '_'.
        return text_utils::utf16le_to_utf8(bytes.data(), bytes.size());
    }

References text_utils::utf16le_to_utf8().

Referenced by recover_directory().

◆ export_stream()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::export_stream	(	const StreamInfo &	info,
		const fs::path &	out_dir,
		std::vector< RecoveredFileRecord > &	recovered,
		std::vector< std::string > &	logs,
		std::string &	error )

inlineprivate

Definition at line 635 of file filesystem_recovery.cpp.

                                         {
        if (!info.valid || info.is_directory) return true;
        fs::create_directories(out_dir);
        const auto chain = cluster_chain(info.first_cluster, info.no_fat_chain, info.data_length);
        if (chain.empty() && info.data_length > 0) {
            logs.push_back(trs("Skipped exFAT file with invalid cluster chain") + std::string(": ") + info.name);
            return true;
        }
        std::vector<std::pair<uint64_t, uint64_t>> ranges;
        for (uint32_t cluster : chain) {
            ranges.push_back({cluster_to_offset(cluster), cluster_size_});
        }
        fs::path out_path = out_dir / sanitize_path_component(info.name);
        std::string unique = out_path.string();
        int suffix = 1;
        while (fs::exists(unique)) {
            unique = (out_dir / (sanitize_path_component(info.name) + "_" + std::to_string(suffix++))).string();
        }
        out_path = unique;
        if (!write_data_to_file(reader_, ranges, out_path, info.data_length, error)) return false;
        recovered.push_back({out_path.string(), "exFAT", info.name, info.data_length, "full", info.no_fat_chain ? "bitmap-validated contiguous export" : "filesystem export"});
        logs.push_back(trs("Recovered exFAT file:") + std::string(" ") + out_path.string());
        return true;
    }

Referenced by recover_directory().

◆ export_stream_deleted()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::export_stream_deleted	(	const StreamInfo &	info,
		const fs::path &	out_dir,
		std::vector< RecoveredFileRecord > &	recovered,
		std::vector< std::string > &	logs,
		std::string &	error )

inlineprivate

Definition at line 671 of file filesystem_recovery.cpp.

                                                  {
        if (!info.valid || info.is_directory) return true;
        if (info.first_cluster < 2 || info.data_length == 0) {
            // Empty file -- still create a placeholder
            const fs::path out_path = out_dir / sanitize_path_component(info.name);
            std::ofstream(out_path, std::ios::binary);
            recovered.push_back({out_path.string(), "exFAT",
                ("deleted/" + info.name), 0, "partial",
                "deleted-empty"});
            return true;
        }
        // Build a contiguous "guess" range
        const uint64_t need_clusters =
            (info.data_length + cluster_size_ - 1) / cluster_size_;
        std::vector<std::pair<uint64_t, uint64_t>> ranges;
        ranges.reserve(static_cast<size_t>(need_clusters));
        for (uint64_t i = 0; i < need_clusters; ++i) {
            const uint32_t cl = info.first_cluster + static_cast<uint32_t>(i);
            // Bound check
            if (cl < 2 || cl >= cluster_count_ + 2) break;
            ranges.push_back({cluster_to_offset(cl), cluster_size_});
        }
        if (ranges.empty()) return true;
 
        fs::path out_path = out_dir / sanitize_path_component(info.name);
        std::string unique = out_path.string();
        int suffix = 1;
        while (fs::exists(unique)) {
            unique = (out_dir / (sanitize_path_component(info.name) + "_"
                                  + std::to_string(suffix++))).string();
        }
        out_path = unique;
        if (!write_data_to_file(reader_, ranges, out_path,
                                 info.data_length, error)) return false;
        recovered.push_back({out_path.string(), "exFAT",
            ("deleted/" + info.name), info.data_length, "partial",
            "deleted-contiguous-guess"});
        logs.push_back(trs("Recovered exFAT deleted file (best-effort, "
                           "assumes contiguous):") +
                       std::string(" ") + out_path.string());
        return true;
    }

References cluster_count_, cluster_size_, cluster_to_offset(), anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::data_length, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::first_cluster, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::is_directory, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::name, reader_, anonymous_namespace{filesystem_recovery.cpp}::sanitize_path_component(), trs(), anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::valid, and anonymous_namespace{filesystem_recovery.cpp}::write_data_to_file().

Referenced by recover_directory().

◆ load_allocation_bitmap()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::load_allocation_bitmap ( )

inlineprivate

Definition at line 551 of file filesystem_recovery.cpp.

                                  {
        if (root_dir_cluster_ < 2) return false;
        const auto chain = cluster_chain(root_dir_cluster_, true, cluster_size_ * 64, 4096);
        std::vector<unsigned char> cluster_buf;
        for (uint32_t cluster : chain) {
            if (!read_cluster(cluster, cluster_buf)) continue;
            for (size_t off = 0; off + 32 <= cluster_buf.size(); off += 32) {
                const unsigned char* e = cluster_buf.data() + off;
                const uint8_t type = e[0];
                if (type == 0x00) break;
                if (type == 0x81) {
                    allocation_bitmap_cluster_ = le32(e + 20);
                    allocation_bitmap_length_ = le64(e + 24);
                    break;
                }
            }
            if (allocation_bitmap_cluster_ != 0) break;
        }
        if (allocation_bitmap_cluster_ < 2 || allocation_bitmap_length_ == 0) return false;
        const auto bitmap_chain = cluster_chain(allocation_bitmap_cluster_, true, allocation_bitmap_length_, 4096);
        if (bitmap_chain.empty()) return false;
        std::vector<std::pair<uint64_t, uint64_t>> ranges;
        for (uint32_t cluster : bitmap_chain) ranges.push_back({cluster_to_offset(cluster), cluster_size_});
        fs::path tmp = fs::temp_directory_path() / ("exfat_bitmap_" + std::to_string(serial_number_) + ".bin");
        std::string local_error;
        if (!write_data_to_file(reader_, ranges, tmp, allocation_bitmap_length_, local_error)) return false;
        std::ifstream in(tmp, std::ios::binary);
        allocation_bitmap_.assign(std::istreambuf_iterator<char>(in), std::istreambuf_iterator<char>());
        std::error_code ec;
        fs::remove(tmp, ec);
        return !allocation_bitmap_.empty();
    }

References allocation_bitmap_, allocation_bitmap_cluster_, allocation_bitmap_length_, cluster_chain(), cluster_size_, cluster_to_offset(), anonymous_namespace{filesystem_recovery.cpp}::le32(), anonymous_namespace{filesystem_recovery.cpp}::le64(), read_cluster(), reader_, root_dir_cluster_, serial_number_, and anonymous_namespace{filesystem_recovery.cpp}::write_data_to_file().

Referenced by recover().

◆ load_vbr()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::load_vbr ( uint64_t volume_offset )

inlineprivate

Definition at line 515 of file filesystem_recovery.cpp.

                                          {
        std::array<unsigned char, 512> b{};
        if (!reader_.read_at(volume_offset, b.data(), b.size())) return false;
        if (std::string(reinterpret_cast<const char*>(b.data() + 3), 8) != "EXFAT   ") return false;
        volume_offset_ = volume_offset;
        partition_offset_sectors_ = le64(b.data() + 64);
        volume_length_sectors_ = le64(b.data() + 72);
        fat_offset_sectors_ = le32(b.data() + 80);
        fat_length_sectors_ = le32(b.data() + 84);
        cluster_heap_offset_sectors_ = le32(b.data() + 88);
        cluster_count_ = le32(b.data() + 92);
        root_dir_cluster_ = le32(b.data() + 96);
        serial_number_ = le32(b.data() + 100);
        bytes_per_sector_shift_ = b[108];
        sectors_per_cluster_shift_ = b[109];
        bytes_per_sector_ = 1ull << bytes_per_sector_shift_;
        sectors_per_cluster_ = 1ull << sectors_per_cluster_shift_;
        cluster_size_ = bytes_per_sector_ * sectors_per_cluster_;
        fat_offset_bytes_ = volume_offset_ + static_cast<uint64_t>(fat_offset_sectors_) * bytes_per_sector_;
        cluster_heap_offset_bytes_ = volume_offset_ + static_cast<uint64_t>(cluster_heap_offset_sectors_) * bytes_per_sector_;
        allocation_bitmap_cluster_ = 0;
        allocation_bitmap_length_ = 0;
        allocation_bitmap_.clear();
        return bytes_per_sector_ >= 512 && cluster_size_ > 0 && cluster_count_ > 0;
    }

References allocation_bitmap_, allocation_bitmap_cluster_, allocation_bitmap_length_, bytes_per_sector_, bytes_per_sector_shift_, cluster_count_, cluster_heap_offset_bytes_, cluster_heap_offset_sectors_, cluster_size_, fat_length_sectors_, fat_offset_bytes_, fat_offset_sectors_, anonymous_namespace{filesystem_recovery.cpp}::le32(), anonymous_namespace{filesystem_recovery.cpp}::le64(), partition_offset_sectors_, DiskReader::read_at(), reader_, root_dir_cluster_, sectors_per_cluster_, sectors_per_cluster_shift_, serial_number_, volume_length_sectors_, and volume_offset_.

Referenced by recover().

◆ next_cluster()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::next_cluster	(	uint32_t	current,
		uint32_t &	next )

inlineprivate

Definition at line 588 of file filesystem_recovery.cpp.

                                                        {
        const uint64_t fat_entry_offset = fat_offset_bytes_ + static_cast<uint64_t>(current) * 4;
        std::array<unsigned char, 4> entry{};
        if (!reader_.read_at(fat_entry_offset, entry.data(), entry.size())) return false;
        next = le32(entry.data()) & 0x0FFFFFFF;
        return true;
    }

References fat_offset_bytes_, anonymous_namespace{filesystem_recovery.cpp}::le32(), DiskReader::read_at(), and reader_.

Referenced by cluster_chain().

◆ read_cluster()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::read_cluster	(	uint32_t	cluster,
		std::vector< unsigned char > &	out )

inlineprivate

Definition at line 624 of file filesystem_recovery.cpp.

                                                                       {
        out.resize(static_cast<size_t>(cluster_size_));
        return reader_.read_at(cluster_to_offset(cluster), out.data(), out.size());
    }

References cluster_size_, cluster_to_offset(), DiskReader::read_at(), and reader_.

Referenced by load_allocation_bitmap(), and recover_directory().

◆ recover()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::recover	(	uint64_t	volume_offset,
		const fs::path &	out_root,
		std::vector< RecoveredFileRecord > &	recovered,
		std::vector< std::string > &	logs,
		std::string &	error )

inline

Definition at line 464 of file filesystem_recovery.cpp.

                                   {
        if (!load_vbr(volume_offset)) return false;
        fs::create_directories(out_root);
        logs.push_back(trs("exFAT recovery started at offset") + std::string(" ") + std::to_string(volume_offset));
        if (load_allocation_bitmap()) {
            logs.push_back(trs("exFAT allocation bitmap loaded") + std::string(": ") + std::to_string(allocation_bitmap_length_) + " bytes");
        }
        std::set<uint32_t> dir_guard;
        if (!recover_directory(root_dir_cluster_, out_root, recovered, logs, error, dir_guard, 0)) {
            return false;
        }
        logs.push_back(trs("exFAT recovery completed."));
        return true;
    }

References allocation_bitmap_length_, load_allocation_bitmap(), load_vbr(), recover_directory(), root_dir_cluster_, and trs().

◆ recover_directory()

bool anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::recover_directory	(	uint32_t	start_cluster,
		const fs::path &	out_dir,
		std::vector< RecoveredFileRecord > &	recovered,
		std::vector< std::string > &	logs,
		std::string &	error,
		std::set< uint32_t > &	dir_guard,
		int	depth )

inlineprivate

Definition at line 718 of file filesystem_recovery.cpp.

                                      {
        if (depth > 32) return true;
        if (!dir_guard.insert(start_cluster).second) return true;
 
        const auto chain = cluster_chain(start_cluster, true, cluster_size_ * 16, 4096);
        std::vector<unsigned char> cluster_buf;
        StreamInfo current;
        int remaining_secondary = 0;
        std::vector<unsigned char> name_bytes;
 
        auto finalize = [&](bool force_dir_recurse) -> bool {
            if (!current.valid) return true;
            current.name = sanitize_path_component(current.name.empty() ? "unnamed" : current.name);
            // Deleted entries: route to "deleted/" subdir, never recurse
            // into them (the directory's children entries are likely
            // already overwritten or pointing into reused clusters).
            if (current.is_deleted) {
                if (current.is_directory) return true;  // skip deleted dirs
                const fs::path deleted_dir = out_dir / "deleted";
                std::error_code ec;
                fs::create_directories(deleted_dir, ec);
                return export_stream_deleted(current, deleted_dir, recovered, logs, error);
            }
            if (current.is_directory) {
                if (current.first_cluster >= 2) {
                    const fs::path subdir = out_dir / current.name;
                    fs::create_directories(subdir);
                    return recover_directory(current.first_cluster, subdir, recovered, logs, error, dir_guard, depth + 1);
                }
            } else {
                return export_stream(current, out_dir, recovered, logs, error);
            }
            (void)force_dir_recurse;
            return true;
        };
 
        for (uint32_t cluster : chain) {
            if (!read_cluster(cluster, cluster_buf)) continue;
            for (size_t off = 0; off + 32 <= cluster_buf.size(); off += 32) {
                const unsigned char* e = cluster_buf.data() + off;
                const uint8_t type = e[0];
                if (type == 0x00) {
                    return finalize(false);
                }
                // ---- exFAT entry types ----
                //
                // Bit 7 of the type byte = "InUse". When clear, the
                // entry is DELETED but otherwise intact. The 3 entry
                // types we care about have these (in-use, deleted)
                // pairs:
                //   File Directory Entry:  0x85  /  0x05
                //   Stream Extension:      0xC0  /  0x40
                //   Filename:              0xC1  /  0x41
                //
                // We accept BOTH variants. We track is_deleted on the
                // current pseudo-entry so finalize() can route the
                // file to a "deleted/" subdirectory.
                const bool is_file_de   = (type == 0x85 || type == 0x05);
                const bool is_stream_de = (type == 0xC0 || type == 0x40);
                const bool is_name_de   = (type == 0xC1 || type == 0x41);
                const bool entry_deleted = (type == 0x05 || type == 0x40 ||
                                            type == 0x41);
 
                if (is_file_de) {
                    if (!finalize(false)) return false;
                    current = {};
                    current.valid = true;
                    current.is_directory = (e[4] & 0x10) != 0;
                    current.is_deleted = entry_deleted;
                    remaining_secondary = e[1];
                    name_bytes.clear();
                } else if (current.valid && is_stream_de) {
                    current.no_fat_chain = (e[1] & 0x02) != 0;
                    current.name = std::string();
                    const uint8_t name_len = e[3];
                    current.first_cluster = le32(e + 20);
                    current.data_length = le64(e + 24);
                    name_bytes.reserve(static_cast<size_t>(name_len) * 2);
                    if (entry_deleted) current.is_deleted = true;
                    --remaining_secondary;
                } else if (current.valid && is_name_de) {
                    name_bytes.insert(name_bytes.end(), e + 2, e + 32);
                    current.name = decode_utf16_name(name_bytes);
                    if (entry_deleted) current.is_deleted = true;
                    --remaining_secondary;
                    if (remaining_secondary <= 0) {
                        if (!finalize(true)) return false;
                        current = {};
                    }
                } else if (current.valid && remaining_secondary > 0) {
                    --remaining_secondary;
                    if (remaining_secondary <= 0) {
                        if (!finalize(false)) return false;
                        current = {};
                    }
                } else {
                    if (!finalize(false)) return false;
                    current = {};
                }
            }
        }
        return finalize(false);
    }

References cluster_chain(), cluster_size_, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::data_length, decode_utf16_name(), export_stream(), export_stream_deleted(), anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::first_cluster, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::is_deleted, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::is_directory, anonymous_namespace{filesystem_recovery.cpp}::le32(), anonymous_namespace{filesystem_recovery.cpp}::le64(), anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::name, anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::no_fat_chain, read_cluster(), recover_directory(), anonymous_namespace{filesystem_recovery.cpp}::sanitize_path_component(), and anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::StreamInfo::valid.

Referenced by recover(), and recover_directory().

Member Data Documentation

◆ allocation_bitmap_

std::vector<unsigned char> anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::allocation_bitmap_

private

Definition at line 513 of file filesystem_recovery.cpp.

Referenced by cluster_allocated(), load_allocation_bitmap(), and load_vbr().

◆ allocation_bitmap_cluster_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::allocation_bitmap_cluster_ {0}

private

Definition at line 511 of file filesystem_recovery.cpp.

Referenced by load_allocation_bitmap(), and load_vbr().

◆ allocation_bitmap_length_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::allocation_bitmap_length_ {0}

private

Definition at line 512 of file filesystem_recovery.cpp.

Referenced by load_allocation_bitmap(), load_vbr(), and recover().

◆ bytes_per_sector_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::bytes_per_sector_ {0}

private

Definition at line 506 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ bytes_per_sector_shift_

uint8_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::bytes_per_sector_shift_ {0}

private

Definition at line 504 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ cluster_count_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_count_ {0}

private

Definition at line 501 of file filesystem_recovery.cpp.

Referenced by cluster_allocated(), cluster_chain(), export_stream_deleted(), and load_vbr().

◆ cluster_heap_offset_bytes_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_heap_offset_bytes_ {0}

private

Definition at line 510 of file filesystem_recovery.cpp.

Referenced by cluster_to_offset(), and load_vbr().

◆ cluster_heap_offset_sectors_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_heap_offset_sectors_ {0}

private

Definition at line 500 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ cluster_size_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::cluster_size_ {0}

private

Definition at line 508 of file filesystem_recovery.cpp.

Referenced by cluster_chain(), cluster_to_offset(), export_stream(), export_stream_deleted(), load_allocation_bitmap(), load_vbr(), read_cluster(), and recover_directory().

◆ fat_length_sectors_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::fat_length_sectors_ {0}

private

Definition at line 499 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ fat_offset_bytes_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::fat_offset_bytes_ {0}

private

Definition at line 509 of file filesystem_recovery.cpp.

Referenced by load_vbr(), and next_cluster().

◆ fat_offset_sectors_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::fat_offset_sectors_ {0}

private

Definition at line 498 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ partition_offset_sectors_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::partition_offset_sectors_ {0}

private

Definition at line 496 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ reader_

DiskReader& anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::reader_

private

Definition at line 494 of file filesystem_recovery.cpp.

Referenced by ExfatRecovery(), export_stream(), export_stream_deleted(), load_allocation_bitmap(), load_vbr(), next_cluster(), and read_cluster().

◆ root_dir_cluster_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::root_dir_cluster_ {2}

private

Definition at line 502 of file filesystem_recovery.cpp.

Referenced by load_allocation_bitmap(), load_vbr(), and recover().

◆ sectors_per_cluster_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::sectors_per_cluster_ {0}

private

Definition at line 507 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ sectors_per_cluster_shift_

uint8_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::sectors_per_cluster_shift_ {0}

private

Definition at line 505 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ serial_number_

uint32_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::serial_number_ {0}

private

Definition at line 503 of file filesystem_recovery.cpp.

Referenced by load_allocation_bitmap(), and load_vbr().

◆ volume_length_sectors_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::volume_length_sectors_ {0}

private

Definition at line 497 of file filesystem_recovery.cpp.

Referenced by load_vbr().

◆ volume_offset_

uint64_t anonymous_namespace{filesystem_recovery.cpp}::ExfatRecovery::volume_offset_ {0}

private

Definition at line 495 of file filesystem_recovery.cpp.

Referenced by load_vbr().

The documentation for this class was generated from the following file:

BastionGuard/thirdparty/bastionguard-recovery-data/src/filesystem_recovery.cpp

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ExfatRecovery()

Member Function Documentation

◆ cluster_allocated()

◆ cluster_chain()

◆ cluster_to_offset()

◆ decode_utf16_name()

◆ export_stream()

◆ export_stream_deleted()

◆ load_allocation_bitmap()

◆ load_vbr()

◆ next_cluster()

◆ read_cluster()

◆ recover()

◆ recover_directory()

Member Data Documentation

◆ allocation_bitmap_

◆ allocation_bitmap_cluster_

◆ allocation_bitmap_length_

◆ bytes_per_sector_

◆ bytes_per_sector_shift_

◆ cluster_count_

◆ cluster_heap_offset_bytes_

◆ cluster_heap_offset_sectors_

◆ cluster_size_

◆ fat_length_sectors_

◆ fat_offset_bytes_

◆ fat_offset_sectors_

◆ partition_offset_sectors_

◆ reader_

◆ root_dir_cluster_

◆ sectors_per_cluster_

◆ sectors_per_cluster_shift_

◆ serial_number_

◆ volume_length_sectors_

◆ volume_offset_