ios 0.2.1

Light-weight CLI tool to extract iOS backup
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#![allow(rustdoc::bare_urls)]
#![doc = include_str!("../README.md")]

/// Module to handle backup operations
pub mod backup;
/// Module to load the required structs
pub mod constant;
/// Module for database utilities
pub mod dbutil;
/// Module to handle database operations
pub mod fileio;
/// Module to construct a custom logger
pub mod logger;
/// Module to parse command line arguments
pub mod parser;
/// Module for helper functions
pub mod squire;

use rusqlite::Result;

/// Function to parse and extract iOS backup data
///
/// # Returns
///
/// * `Ok` - If the function completes successfully
/// * `Err` - If the function encounters an error
pub fn retriever() -> Result<String, String> {
    let metadata = constant::build_info();
    let arguments = parser::arguments(&metadata);
    let empty_serial = arguments.serial_numbers.is_empty();
    let no_filter = arguments.list || arguments.all;
    if empty_serial && !no_filter {
        return Err(
            "Please provide a serial number (--serial) or use all (--all) / list (--list) options."
                .into(),
        );
    }
    log::set_logger(&logger::SimpleLogger).unwrap();
    if arguments.debug {
        log::set_max_level(log::LevelFilter::Debug);
        log::debug!("Debug mode enabled!!")
    } else {
        log::set_max_level(log::LevelFilter::Info);
    }
    log::info!(
        "Searching for backup data in '{}'",
        &arguments.backup_dir.display()
    );
    let backups = backup::get_backups(&arguments.backup_dir, &arguments.serial_numbers, no_filter);
    if backups.is_empty() {
        let err = if empty_serial {
            format!("No backups found in '{}'", arguments.backup_dir.display())
        } else {
            format!(
                "No backups found for serial(s) '{:?}' in '{}'",
                arguments.serial_numbers,
                arguments.backup_dir.display()
            )
        };
        return Err(err);
    }
    if arguments.list {
        backup::list_backups(&backups);
        return Ok("".into());
    }

    let mut manifests = Vec::new();
    for backup in backups {
        let manifest_db_path = backup.path.join("Manifest.db");
        if manifest_db_path.exists() {
            manifests.push((backup, manifest_db_path));
        }
    }
    log::info!(
        "Number of manifests staged for extraction: {}",
        manifests.len()
    );
    log::info!("Number of workers assigned: {}", arguments.workers);
    for (backup, manifest) in manifests {
        let manifest_id = manifest
            .iter()
            .rev()
            .nth(1)
            .unwrap_or_default()
            .to_string_lossy()
            .to_string();
        log::info!("Extracting manifest: '{}'", &manifest_id);
        let start = squire::get_epoch();
        match fileio::parse_manifest_db(&manifest, &backup, &arguments) {
            Ok(_) => {
                log::info!("Extraction completed for manifest: {:?}", manifest_id);
                log::info!(
                    "Time taken: {}",
                    squire::convert_seconds((squire::get_epoch() - start) as i64, 1)
                );
            }
            Err(err) => {
                log::error!("{}", err);
                return Err("".into());
            }
        }
    }
    Ok("".into())
}