ScannerEngine Class Reference

#include <scanner_engine.hpp>

Public Types
using	ProgressCallback = std::function<void(const ScanProgress&)>

Public Member Functions
ScanReport	run_scan (const std::string &path, ProgressCallback progress_cb, std::function< bool()> cancel_cb)

Detailed Description

Definition at line 7 of file scanner_engine.hpp.

Member Typedef Documentation

ProgressCallback

using ScannerEngine::ProgressCallback = std::function<void(const ScanProgress&)>

Definition at line 9 of file scanner_engine.hpp.

Member Function Documentation

run_scan()

ScanReport ScannerEngine::run_scan	(	const std::string &	path,
		ProgressCallback	progress_cb,
		std::function< bool()>	cancel_cb )

Definition at line 40 of file scanner_engine.cpp.

{
    ScanReport report;
    report.input_path = input_path;
 
    DiskReader reader;
    std::string open_error;
 
    emit_progress(progress_cb,
                  trs("Open source"),
                  trs("Opening source in read-only mode"),
                  0, 0, 0.01);
 
    if (!reader.open_readonly(input_path, open_error)) {
        report.logs.push_back(trs("Error: could not open the source in read-only mode."));
 
        if (!open_error.empty())
            report.logs.push_back(trs("Open error:") + std::string(" ") + open_error);
 
        report.results.push_back({
            ResultKind::Error,
            0,
            0,
            trs("Open failed"),
                                 "DiskReader",
                                 trs("Unable to open source") + (open_error.empty() ? "" : std::string(": ") + open_error),
                                 1.0
        });
 
        emit_progress(progress_cb,
                      trs("Open source"),
                      trs("Open failed"),
                      0, 0, 1.0);
 
        return report;
    }
 
    report.input_size = reader.size();
 
    const auto health = DeviceHealthProbe::probe(input_path, cancel_cb);
    report.logs.push_back(trs("Source opened in read-only mode."));
    if (!health.summary.empty()) {
        report.logs.push_back(trs("Device health:") + std::string(" ") + health.summary);
    }
    if (health.state != DeviceHealthState::Healthy) {
        report.results.push_back({
            ResultKind::Warning,
            0,
            0,
            trs("Device health warning"),
            trs("Device health probe"),
            health.summary.empty() ? trs("Device may be unstable or partially readable") : health.summary,
            0.95
        });
    }
    report.logs.push_back(trs("Input path:") + std::string(" ") + report.input_path);
    report.logs.push_back(trs("Input size:") + std::string(" ") +
    std::to_string(report.input_size) + " bytes");
 
    if (check_cancel(cancel_cb)) {
        report.logs.push_back(trs("Scan cancelled by user."));
        return report;
    }
 
    emit_progress(progress_cb,
                  trs("Partition analysis"),
                  trs("Parsing MBR"),
                  0,
                  report.input_size,
                  0.08);
 
    auto mbr = PartitionParser::parse_mbr(reader, report.logs);
    report.results.insert(report.results.end(), mbr.begin(), mbr.end());
 
    if (check_cancel(cancel_cb)) {
        report.logs.push_back(trs("Scan cancelled during MBR parsing."));
        return report;
    }
 
    emit_progress(progress_cb,
                  trs("Partition analysis"),
                  trs("Parsing GPT"),
                  0,
                  report.input_size,
                  0.16);
 
    auto gpt = PartitionParser::parse_gpt(reader, report.logs);
    report.results.insert(report.results.end(), gpt.begin(), gpt.end());
 
    if (check_cancel(cancel_cb)) {
        report.logs.push_back(trs("Scan cancelled during GPT parsing."));
        return report;
    }
 
    emit_progress(progress_cb,
                  trs("Fast scan"),
                  trs("Searching filesystem signatures"),
                  report.input_size / 4,
                  report.input_size,
                  0.36);
 
    auto sig = SignatureScanner::scan(reader, report.logs);
    report.results.insert(report.results.end(), sig.begin(), sig.end());
 
    if (check_cancel(cancel_cb)) {
        report.logs.push_back(trs("Scan cancelled during signature scan."));
        return report;
    }
 
    emit_progress(progress_cb,
                  trs("Deep scan"),
                  trs("Looking for lost partitions"),
                  report.input_size / 2,
                  report.input_size,
                  0.62);
 
    auto lost = LostPartitionFinder::find(reader, report.results, report.logs);
    report.results.insert(report.results.end(), lost.begin(), lost.end());
 
    if (check_cancel(cancel_cb)) {
        report.logs.push_back(trs("Scan cancelled during lost partition search."));
        return report;
    }
 
    emit_progress(progress_cb,
                  trs("Filesystem probes"),
                  trs("Validating NTFS metadata"),
                  (report.input_size * 3) / 4,
                  report.input_size,
                  0.78);
 
    auto ntfs = NtfsProbe::analyze(reader, report.results, report.logs);
    report.results.insert(report.results.end(), ntfs.begin(), ntfs.end());
 
    if (check_cancel(cancel_cb)) {
        report.logs.push_back(trs("Scan cancelled during NTFS probe."));
        return report;
    }
 
    emit_progress(progress_cb,
                  trs("Filesystem probes"),
                  trs("Validating ext4, Btrfs, FAT32, exFAT"),
                  (report.input_size * 9) / 10,
                  report.input_size,
                  0.92);
 
    auto fs = FilesystemProbes::analyze(reader, report.results, report.logs);
    report.results.insert(report.results.end(), fs.begin(), fs.end());
 
    if (report.results.empty()) {
        report.logs.push_back(trs("No useful results found."));
    }
 
    emit_progress(progress_cb,
                  trs("Completed"),
                  trs("Scan finished"),
                  report.input_size,
                  report.input_size,
                  1.0);
 
    return report;
}

References FilesystemProbes::analyze(), NtfsProbe::analyze(), Error, LostPartitionFinder::find(), Healthy, ScanReport::input_path, ScanReport::input_size, ScanReport::logs, DiskReader::open_readonly(), PartitionParser::parse_gpt(), PartitionParser::parse_mbr(), DeviceHealthProbe::probe(), ScanReport::results, SignatureScanner::scan(), DiskReader::size(), trs(), and Warning.

Referenced by ScanWorker::start().

---

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

• BastionGuard/thirdparty/bastionguard-recovery-data/src/scanner_engine.hpp
• BastionGuard/thirdparty/bastionguard-recovery-data/src/scanner_engine.cpp