RecoveryExporter Class Reference

#include <recovery_exporter.hpp>

Public Types
using	CancelCallback = std::function<bool()>

Static Public Member Functions
static bool	create_rescue_image (const std::string &input_path, const std::string &output_image_path, RecoverySummary &summary, std::vector< std::string > &logs, std::string &error, CancelCallback cancel_cb)
static bool	export_results_and_carve (const ScanReport &report, const std::string &output_dir, const std::vector< size_t > &selected_result_indices, RecoverySummary &summary, std::vector< std::string > &logs, std::string &error, CancelCallback cancel_cb)

Detailed Description

Definition at line 16 of file recovery_exporter.hpp.

Member Typedef Documentation

CancelCallback

using RecoveryExporter::CancelCallback = std::function<bool()>

Definition at line 20 of file recovery_exporter.hpp.

Member Function Documentation

create_rescue_image()

bool RecoveryExporter::create_rescue_image ( const std::string & input_path, const std::string & output_image_path, RecoverySummary & summary, std::vector< std::string > & logs, std::string & error, CancelCallback cancel_cb )

static

Definition at line 236 of file recovery_exporter.cpp.

{
    RescueImageReport report;
    if (!RescueImager::create_image(input_path, output_image_path, report, error, {}, cancel_cb))
    {
        return false;
    }
 
    summary.rescue_image_path = report.image_path;
    summary.rescue_map_path = report.map_path;
    logs.insert(logs.end(), report.logs.begin(), report.logs.end());
    return true;
}

References RescueImager::create_image(), RescueImageReport::image_path, RescueImageReport::logs, RescueImageReport::map_path, RecoverySummary::rescue_image_path, and RecoverySummary::rescue_map_path.

export_results_and_carve()

bool RecoveryExporter::export_results_and_carve ( const ScanReport & report, const std::string & output_dir, const std::vector< size_t > & selected_result_indices, RecoverySummary & summary, std::vector< std::string > & logs, std::string & error, CancelCallback cancel_cb )

static

Definition at line 257 of file recovery_exporter.cpp.

{
    summary = {};
 
    try
    {
        fs::create_directories(output_dir);
        fs::create_directories(fs::path(output_dir) / "images");
        fs::create_directories(fs::path(output_dir) / "carved");
    }
    catch (const std::exception& ex)
    {
        error = ex.what();
        return false;
    }
 
    if (cancel_cb && cancel_cb())
    {
        logs.push_back(trs("Recovery cancelled by user."));
        return false;
    }
 
    DiskReader reader;
 
    std::string open_error;
 
    if (!reader.open_readonly(report.input_path, open_error))
    {
        error = trs("Unable to open source");
 
        if (!open_error.empty())
            error += std::string(": ") + open_error;
 
        logs.push_back(trs("Recovery open error:") + std::string(" ") + error);
 
        return false;
    }
 
    std::unordered_set<size_t> selected_indices(
        selected_result_indices.begin(),
                                                selected_result_indices.end());
 
    const bool filter_results = !selected_indices.empty();
 
    size_t index = 0;
 
    for (size_t result_index = 0;
         result_index < report.results.size();
    ++result_index)
         {
             if (cancel_cb && cancel_cb())
             {
                 logs.push_back(trs("Recovery cancelled during image export."));
                 return false;
             }
 
             const auto& r = report.results[result_index];
 
             if (filter_results && !selected_indices.count(result_index))
                 continue;
 
             if (!should_export(r) || r.size_bytes == 0)
                 continue;
 
             if (r.offset_bytes + r.size_bytes > reader.size())
                 continue;
 
             std::ostringstream name;
 
             name << std::setw(3)
             << std::setfill('0')
             << index++
             << '_'
             << sanitize(r.type)
             << '_'
             << r.offset_bytes
             << ".img";
 
             fs::path out_path =
             fs::path(output_dir) / "images" / name.str();
 
             if (!export_range(
                 reader,
                 r.offset_bytes,
                 r.size_bytes,
                 out_path,
                 error,
                 cancel_cb))
             {
                 return false;
             }
 
             summary.exported_images.push_back(out_path.string());
 
             logs.push_back(
                 trs("Exported volume image:") +
                 std::string(" ") +
                 out_path.string());
         }
 
         if (cancel_cb && cancel_cb())
         {
             logs.push_back(trs("Recovery cancelled before filesystem recovery."));
             return false;
         }
 
         ScanReport filtered_report = report;
 
         if (filter_results)
         {
             filtered_report.results.clear();
 
             for (size_t idx = 0; idx < report.results.size(); ++idx)
             {
                 if (selected_indices.count(idx))
                     filtered_report.results.push_back(report.results[idx]);
             }
         }
 
         std::vector<RecoveredFileRecord> fs_recovered;
 
         if (!FilesystemRecovery::recover_supported_filesystems(
             reader,
             filtered_report,
             output_dir,
             fs_recovered,
             logs,
             error))
         {
             return false;
         }
 
         for (const auto& rf : fs_recovered)
             summary.recovered_files.push_back(rf.output_path);
 
    if (cancel_cb && cancel_cb())
    {
        logs.push_back(trs("Recovery cancelled during filesystem recovery."));
        return false;
    }
 
    const auto carve_ranges =
    selected_carve_ranges(
        report,
        selected_indices,
        filter_results,
        reader.size());
 
    std::vector<CarvedFile> carved;
 
    if (!carve_ranges.empty())
    {
        if (!FileCarver::carve_ranges_to_directory(
            reader,
            carve_ranges,
            (fs::path(output_dir) / "carved").string(),
                                                   carved,
                                                   logs,
                                                   error))
        {
            return false;
        }
    }
 
    for (const auto& cf : carved)
        summary.recovered_files.push_back(cf.output_path);
 
    if (cancel_cb && cancel_cb())
    {
        logs.push_back(trs("Recovery cancelled during carving."));
        return false;
    }
 
    write_recovery_manifest(
        fs::path(output_dir),
                            report,
                            selected_indices,
                            filter_results,
                            summary,
                            fs_recovered,
                            carved,
                            error);
 
    if (!error.empty())
        return false;
 
    logs.push_back(trs("Recovery export completed."));
 
    return true;
}

References FileCarver::carve_ranges_to_directory(), RecoverySummary::exported_images, ScanReport::input_path, DiskReader::open_readonly(), FilesystemRecovery::recover_supported_filesystems(), RecoverySummary::recovered_files, ScanReport::results, DiskReader::size(), and trs().

Referenced by RecoveryWorker::start().

---

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

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