Method action

plugins/warp/src/plugin/create.rs:19–93

(&self, view: &BinaryView)

impl Command for CreateSignatureFile {
    fn action(&self, view: &BinaryView) {
        let is_function_named = |f: &Guard<Function>| {
            !f.symbol().short_name().as_str().contains("sub_") || f.has_user_annotations()
        };
        let mut signature_dir = user_signature_dir();
        if let Some(default_plat) = view.default_platform() {
            // If there is a default platform, put the signature in there.
            // TODO: We should instead use the platform of the function.
            signature_dir.push(default_plat.name().to_string());
        }
        let view = view.to_owned();
        thread::spawn(move || {
            let total_functions = view.functions().len();
            let done_functions = AtomicUsize::default();
            let background_task = binaryninja::background_task::BackgroundTask::new(
                format!("Generating signatures... ({}/{})", 0, total_functions),
                true,
            );

            let start = Instant::now();

            let mut data = warp::signature::Data::default();
            data.functions.par_extend(
                view.functions()
                    .par_iter()
                    .inspect(|_| {
                        done_functions.fetch_add(1, Relaxed);
                        background_task.set_progress_text(format!(
                            "Generating signatures... ({}/{})",
                            done_functions.load(Relaxed),
                            total_functions
                        ))
                    })
                    .filter(is_function_named)
                    .filter(|f| !f.analysis_skipped())
                    .filter_map(|func| {
                        let llil = func.low_level_il().ok()?;
                        Some(cached_function(&func, &llil))
                    }),
            );

            if let Some(ref_ty_cache) = cached_type_references(&view) {
                let referenced_types = ref_ty_cache
                    .cache
                    .iter()
                    .filter_map(|t| t.to_owned())
                    .collect::<Vec<_>>();

                data.types.extend(referenced_types);
            }

            log::info!("Signature generation took {:?}", start.elapsed());
            background_task.finish();

            // NOTE: Because we only can consume signatures from a specific directory, we don't need to use the interaction API.
            // If we did need to save signature files to a project than this would need to change.
            let Some(save_file) = rfd::FileDialog::new()
                .add_filter("Signature Files", &["sbin"])