anonymous_namespace{recovery_exporter.cpp} Namespace Reference

Functions
bool	export_range (DiskReader &reader, uint64_t offset, uint64_t size, const fs::path &out_path, std::string &error, std::function< bool()> cancel_cb)
bool	should_export (const ScanResult &r)
std::string	sanitize (const std::string &s)
void	write_recovery_manifest (const fs::path &output_dir, const ScanReport &report, const std::unordered_set< size_t > &selected_indices, bool filter_results, const RecoverySummary &summary, const std::vector< RecoveredFileRecord > &fs_recovered, const std::vector< CarvedFile > &carved, std::string &error)
std::vector< std::pair< uint64_t, uint64_t > >	selected_carve_ranges (const ScanReport &report, const std::unordered_set< size_t > &selected_indices, bool filter_results, uint64_t source_size)

Function Documentation

export_range()

bool anonymous_namespace{recovery_exporter.cpp}::export_range	(	DiskReader &	reader,
		uint64_t	offset,
		uint64_t	size,
		const fs::path &	out_path,
		std::string &	error,
		std::function< bool()>	cancel_cb )

Definition at line 20 of file recovery_exporter.cpp.

    {
        std::ofstream out(out_path, std::ios::binary);
        if (!out) {
            error = trs("Unable to create output file") + std::string(": ") + out_path.string();
            return false;
        }
 
        std::vector<unsigned char> buffer(1024 * 1024);
 
        uint64_t remaining = size;
        uint64_t cursor = offset;
 
        while (remaining > 0)
        {
            if (cancel_cb && cancel_cb())
            {
                error = trs("Recovery cancelled by user");
                return false;
            }
 
            const size_t chunk = static_cast<size_t>(
                std::min<uint64_t>(buffer.size(), remaining));
 
            if (!reader.read_at(cursor, buffer.data(), chunk))
            {
                error = trs("Read error while exporting partition image");
                return false;
            }
 
            out.write(reinterpret_cast<const char*>(buffer.data()),
                      static_cast<std::streamsize>(chunk));
 
            if (!out)
            {
                error = trs("Write error while exporting partition image");
                return false;
            }
 
            cursor += chunk;
            remaining -= chunk;
        }
 
        return true;
    }

References export_range(), DiskReader::read_at(), and trs().

Referenced by export_range().

sanitize()

std::string anonymous_namespace{recovery_exporter.cpp}::sanitize

(

const std::string &

s

)

Definition at line 79 of file recovery_exporter.cpp.

    {
        std::string out;
 
        for (char c : s)
        {
            if (isalnum(static_cast<unsigned char>(c)))
                out.push_back(c);
            else if (c == ' ' || c == '-' || c == '_')
                out.push_back('_');
        }
 
        if (out.empty())
            out = "item";
 
        return out;
    }

References sanitize().

Referenced by sanitize().

selected_carve_ranges()

std::vector< std::pair< uint64_t, uint64_t > > anonymous_namespace{recovery_exporter.cpp}::selected_carve_ranges	(	const ScanReport &	report,
		const std::unordered_set< size_t > &	selected_indices,
		bool	filter_results,
		uint64_t	source_size )

Definition at line 148 of file recovery_exporter.cpp.

    {
        std::vector<std::pair<uint64_t, uint64_t>> ranges;
 
        auto add_range = [&](uint64_t offset, uint64_t size)
        {
            if (size == 0 || offset >= source_size)
                return;
 
            size = std::min<uint64_t>(size, source_size - offset);
 
            if (ranges.empty())
            {
                ranges.emplace_back(offset, size);
                return;
            }
 
            auto& last = ranges.back();
 
            const uint64_t last_end = last.first + last.second;
 
            if (offset <= last_end)
            {
                const uint64_t new_end = std::max<uint64_t>(last_end, offset + size);
                last.second = new_end - last.first;
            }
            else
            {
                ranges.emplace_back(offset, size);
            }
        };
 
        if (!filter_results)
        {
            ranges.emplace_back(0, source_size);
            return ranges;
        }
 
        std::vector<std::pair<uint64_t, uint64_t>> temp;
 
        for (size_t idx = 0; idx < report.results.size(); ++idx)
        {
            if (!selected_indices.count(idx))
                continue;
 
            const auto& r = report.results[idx];
 
            if (r.offset_bytes == 0 && r.size_bytes == 0)
                continue;
 
            switch (r.kind)
            {
                case ResultKind::Partition:
                case ResultKind::LostPartitionCandidate:
                case ResultKind::FilesystemCandidate:
                case ResultKind::FilesystemVolume:
                case ResultKind::NtfsVolume:
                case ResultKind::NtfsMetadata:
                    temp.emplace_back(r.offset_bytes, r.size_bytes);
                    break;
                default:
                    break;
            }
        }
 
        if (temp.empty())
            return ranges;
 
        std::sort(temp.begin(), temp.end(),
                  [](const auto& a, const auto& b)
                  {
                      return a.first < b.first;
                  });
 
        for (const auto& r : temp)
            add_range(r.first, r.second);
 
        return ranges;
    }

References FilesystemCandidate, FilesystemVolume, LostPartitionCandidate, NtfsMetadata, NtfsVolume, Partition, ScanReport::results, and selected_carve_ranges().

Referenced by selected_carve_ranges().

should_export()

bool anonymous_namespace{recovery_exporter.cpp}::should_export

(

const ScanResult &

r

)

Definition at line 71 of file recovery_exporter.cpp.

    {
        return r.kind == ResultKind::Partition ||
        r.kind == ResultKind::LostPartitionCandidate ||
        r.kind == ResultKind::FilesystemVolume ||
        r.kind == ResultKind::NtfsVolume;
    }

References FilesystemVolume, LostPartitionCandidate, NtfsVolume, Partition, and should_export().

Referenced by should_export().

write_recovery_manifest()

void anonymous_namespace{recovery_exporter.cpp}::write_recovery_manifest	(	const fs::path &	output_dir,
		const ScanReport &	report,
		const std::unordered_set< size_t > &	selected_indices,
		bool	filter_results,
		const RecoverySummary &	summary,
		const std::vector< RecoveredFileRecord > &	fs_recovered,
		const std::vector< CarvedFile > &	carved,
		std::string &	error )

Definition at line 97 of file recovery_exporter.cpp.

    {
        std::ofstream out(output_dir / "recovery_manifest.txt", std::ios::binary);
 
        if (!out)
        {
            error = trs("Unable to create output file") + std::string(": ") +
            (output_dir / "recovery_manifest.txt").string();
            return;
        }
 
        out << "input=" << report.input_path << "\n";
        out << "selected_filter=" << (filter_results ? 1 : 0) << "\n";
        out << "selected_results=" << selected_indices.size() << "\n";
        out << "exported_images=" << summary.exported_images.size() << "\n";
        out << "recovered_files=" << summary.recovered_files.size() << "\n\n";
 
        out << "[filesystem_recovery]\n";
 
        for (const auto& rf : fs_recovered)
        {
            out << rf.filesystem << '\t'
            << rf.integrity << '\t'
            << rf.size_bytes << '\t'
            << rf.original_path << '\t'
            << rf.output_path;
 
            if (!rf.note.empty())
                out << '\t' << rf.note;
 
            out << '\n';
        }
 
        out << "\n[carved]\n";
 
        for (const auto& cf : carved)
        {
            out << cf.type << '\t'
            << cf.size << '\t'
            << cf.output_path << '\n';
        }
    }

References RecoverySummary::exported_images, ScanReport::input_path, RecoverySummary::recovered_files, trs(), and write_recovery_manifest().

Referenced by write_recovery_manifest().