scanner_engine.cpp

Go to the documentation of this file.

#include "scanner_engine.hpp"
#include "disk_reader.hpp"
#include "i18n.hpp"
#include "partition_parser.hpp"
#include "signature_scanner.hpp"
#include "lost_partition_finder.hpp"
#include "ntfs_probe.hpp"
#include "filesystem_probes.hpp"
#include "device_health_probe.hpp"
 
namespace {
 
    void emit_progress(const ScannerEngine::ProgressCallback& cb,
                       const std::string& stage,
                       const std::string& detail,
                       uint64_t processed,
                       uint64_t total,
                       double fraction)
    {
        if (!cb) return;
 
        ScanProgress progress;
        progress.stage = stage;
        progress.detail = detail;
        progress.bytes_processed = processed;
        progress.bytes_total = total;
        progress.fraction = fraction;
 
        cb(progress);
    }
 
    bool check_cancel(const std::function<bool()>& cancel_cb)
    {
        if (!cancel_cb) return false;
        return cancel_cb();
    }
 
}
 
ScanReport ScannerEngine::run_scan(
    const std::string& input_path,
    ProgressCallback progress_cb,
    std::function<bool()> cancel_cb)
{
    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;
}