payload_dumper 0.8.3

A fast and efficient Android OTA payload dumper library and CLI
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2025 rhythmcache
// https://github.com/rhythmcache/payload-dumper-rust

use crate::cli::args::args_def::Args;
use crate::cli::ui::cli_reporter::CliExtractionReporter;
use crate::cli::ui::ui_print::UiOutput;
use anyhow::Result;
use payload_dumper::payload::payload_dumper::{AsyncPayloadRead, dump_partition};
use payload_dumper::structs::PartitionUpdate;
use std::sync::Arc;
use tokio::sync::Semaphore;

/// extracts partitions using parallel or sequential processing
/// returns a list of failed partition names
pub async fn extract_partitions(
    args: &Args,
    partitions: &[PartitionUpdate],
    data_offset: u64,
    block_size: u64,
    payload_reader: Arc<dyn AsyncPayloadRead>,
    ui: &UiOutput,
) -> Result<Vec<String>> {
    if args.no_parallel {
        extract_sequential(
            args,
            partitions,
            data_offset,
            block_size,
            payload_reader,
            ui,
        )
        .await
    } else {
        let thread_count = args
            .threads
            .unwrap_or_else(|| (num_cpus::get() * 2).min(32));
        extract_parallel(
            args,
            partitions,
            data_offset,
            block_size,
            payload_reader,
            thread_count,
            ui,
        )
        .await
    }
}

/// sequential extraction
async fn extract_sequential(
    args: &Args,
    partitions: &[PartitionUpdate],
    data_offset: u64,
    block_size: u64,
    payload_reader: Arc<dyn AsyncPayloadRead>,
    ui: &UiOutput,
) -> Result<Vec<String>> {
    let mut failed_partitions = Vec::new();

    for partition in partitions {
        // Create progress through UI layer - no indicatif imports needed!
        let progress = ui.create_extraction_progress(&partition.partition_name);
        let reporter = CliExtractionReporter::new(progress);
        let output_path = args.out.join(format!("{}.img", &partition.partition_name));

        if let Err(e) = dump_partition(
            partition,
            data_offset,
            block_size,
            output_path,
            &payload_reader,
            &reporter,
            Some(args.source_dir.clone()),
        )
        .await
        {
            ui.error(format!(
                "Failed to process partition {}: {}",
                partition.partition_name, e
            ));
            failed_partitions.push(partition.partition_name.clone());
        }
    }

    Ok(failed_partitions)
}

/// parallel extraction with thread limiting
async fn extract_parallel(
    args: &Args,
    partitions: &[PartitionUpdate],
    data_offset: u64,
    block_size: u64,
    payload_reader: Arc<dyn AsyncPayloadRead>,
    thread_count: usize,
    ui: &UiOutput,
) -> Result<Vec<String>> {
    let semaphore = Arc::new(Semaphore::new(thread_count));
    let mut tasks = Vec::new();
    let out_dir = args.out.clone();
    let source_dir = args.source_dir.clone();

    for partition in partitions {
        let partition = partition.clone();
        let payload_reader = Arc::clone(&payload_reader);
        let out_dir = out_dir.clone();
        let source_dir = source_dir.clone();
        let semaphore = Arc::clone(&semaphore);
        let progress = ui.create_extraction_progress(&partition.partition_name);

        let task = tokio::spawn(async move {
            let _permit = semaphore.acquire().await.unwrap();

            let partition_name = partition.partition_name.clone();
            let output_path = out_dir.join(format!("{}.img", partition_name));
            let reporter = CliExtractionReporter::new(progress);

            match dump_partition(
                &partition,
                data_offset,
                block_size,
                output_path,
                &payload_reader,
                &reporter,
                Some(source_dir),
            )
            .await
            {
                Ok(()) => Ok(()),
                Err(e) => Err((partition_name, e)),
            }
        });

        tasks.push(task);
    }

    // wait for all tasks to complete
    let results = futures::future::join_all(tasks).await;
    let mut failed_partitions = Vec::new();

    for result in results {
        match result {
            Ok(Ok(())) => {}
            Ok(Err((partition_name, error))) => {
                ui.error(format!(
                    "Failed to process partition {}: {}",
                    partition_name, error
                ));
                failed_partitions.push(partition_name);
            }
            Err(e) => {
                ui.error(format!("Task panicked: {}", e));
            }
        }
    }

    Ok(failed_partitions)
}