add idb_import plugin til dependencies prompts

Author: rbran

plugins/idb_import/src/lib.rs

@@ -1,7 +1,9 @@
 mod types;
-use std::path::Path;
+use std::fs::File;
+use std::io::BufReader;
 
 use binaryninja::command::Command;
+use binaryninja::string::BnStrCompatible;
 use binaryninja::type_library::TypeLibrary;
 use binaryninja::types::QualifiedName;
 use types::*;
@@ -41,7 +43,7 @@ impl CustomDebugInfoParser for IDBDebugInfoParser {
         debug_file: &BinaryView,
         progress: Box<dyn Fn(usize, usize) -> Result<(), ()>>,
     ) -> bool {
-        match parse_idb_info(debug_info, bv, debug_file, progress) {
+        match import_idb_info(debug_info, bv, debug_file, progress) {
             Ok(()) => true,
             Err(error) => {
                 error!("Unable to parse IDB file: {error}");
@@ -68,7 +70,7 @@ impl CustomDebugInfoParser for TILDebugInfoParser {
         debug_file: &BinaryView,
         progress: Box<dyn Fn(usize, usize) -> Result<(), ()>>,
     ) -> bool {
-        match parse_til_info(debug_info, bv, debug_file, progress) {
+        match import_til_info_from_debug_file(debug_info, bv, debug_file, progress) {
             Ok(()) => true,
             Err(error) => {
                 error!("Unable to parse TIL file: {error}");
@@ -124,79 +126,59 @@ impl std::io::Seek for BinaryViewReader<'_> {
     }
 }
 
-fn parse_idb_info(
+fn dummy_progress(_: usize, _: usize) -> Result<(), ()> {
+    Ok(())
+}
+
+fn import_idb_info<P: Fn(usize, usize) -> Result<(), ()>>(
     debug_info: &mut DebugInfo,
     bv: &BinaryView,
     debug_file: &BinaryView,
-    progress: Box<dyn Fn(usize, usize) -> Result<(), ()>>,
+    progress: P,
 ) -> Result<()> {
     trace!("Opening a IDB file");
-    let file = BinaryViewReader {
+    let file = BufReader::new(BinaryViewReader {
         bv: debug_file,
         offset: 0,
-    };
+    });
     trace!("Parsing a IDB file");
-    let file = std::io::BufReader::new(file);
     let mut parser = idb_rs::IDBParser::new(file)?;
 
-    let default_arch = bv
-        .default_arch()
-        .ok_or_else(|| anyhow!("Unable to get the default arch"))?;
-    let filename = debug_file.file().filename();
-    let mut type_lib = TypeLibrary::new(default_arch, filename);
-
     if let Some(til_section) = parser.til_section_offset() {
         // TODO handle dependency, create a function for that with closures
         trace!("Parsing the TIL section");
         let til = parser.read_til_section(til_section)?;
-        // progress 0%-50%
-        import_til_section(&mut type_lib, debug_file, &til, progress)?;
+        let filename = debug_file.file().filename();
+        // TODO progress 0%-50%
+        import_til_to_type_library(til, filename, bv, progress)?;
     }
 
-    if !type_lib.finalize() {
-        return Err(anyhow!("Unable to finalize TypeLibrary"));
-    };
-    bv.add_type_library(&type_lib);
-
     if let Some(id0_section) = parser.id0_section_offset() {
         trace!("Parsing the ID0 section");
         let id0 = parser.read_id0_section(id0_section)?;
-        // progress 50%-100%
+        // TODO progress 50%-100%
         parse_id0_section_info(debug_info, bv, debug_file, &id0)?;
     }
 
     Ok(())
 }
 
-fn parse_til_info(
+fn import_til_info_from_debug_file<P: Fn(usize, usize) -> Result<(), ()>>(
     _debug_info: &mut DebugInfo,
     bv: &BinaryView,
     debug_file: &BinaryView,
-    progress: Box<dyn Fn(usize, usize) -> Result<(), ()>>,
+    progress: P,
 ) -> Result<()> {
     trace!("Opening a TIL file");
     let file = BinaryViewReader {
         bv: debug_file,
         offset: 0,
     };
-    let mut file = std::io::BufReader::new(file);
-
-    let default_arch = bv
-        .default_arch()
-        .ok_or_else(|| anyhow!("Unable to get the default arch"))?;
     let filename = debug_file.file().filename();
-    let mut type_lib = TypeLibrary::new(default_arch, filename);
-
-    trace!("Parsing the TIL section");
+    let mut file = std::io::BufReader::new(file);
     let til = TILSection::read(&mut file, idb_rs::IDBSectionCompression::None)?;
-    // TODO handle dependency, create a function for that with closures
-    import_til_section(&mut type_lib, debug_file, &til, progress)?;
 
-    if !type_lib.finalize() {
-        return Err(anyhow!("Unable to finalize TypeLibrary"));
-    };
-    bv.add_type_library(&type_lib);
-    Ok(())
+    import_til_to_type_library(til, filename, bv, progress)
 }
 
 fn interactive_import_til(view: &BinaryView) -> Result<()> {
@@ -206,83 +188,115 @@ fn interactive_import_til(view: &BinaryView) -> Result<()> {
         return Ok(());
     };
 
+    let filename = file.file_name().unwrap().to_string_lossy();
+    let mut file = BufReader::new(File::open(&file)?);
+    let til = TILSection::read(&mut file, idb_rs::IDBSectionCompression::None)?;
+
+    // TODO remove the extension?
+    import_til_to_type_library(til, filename, view, dummy_progress)
+}
+
+fn import_til_to_type_library<S, P>(
+    til: TILSection,
+    type_lib_name: S,
+    view: &BinaryView,
+    progress: P,
+) -> Result<()>
+where
+    S: BnStrCompatible,
+    P: Fn(usize, usize) -> Result<(), ()>,
+{
     let default_arch = view
         .default_arch()
         .ok_or_else(|| anyhow!("Unable to get the default arch"))?;
-    let filename = file.file_name().unwrap().to_string_lossy();
-    let mut type_lib = TypeLibrary::new(default_arch, filename);
+    let mut type_lib = TypeLibrary::new(default_arch, type_lib_name);
 
-    interactive_import_til_file(file.as_path(), view, &mut type_lib)?;
+    // TODO create a background task to not freeze bn, also create a progress
+    // user interface feedback
+    import_til_file(til, view, &mut type_lib, progress)?;
     if !type_lib.finalize() {
         return Err(anyhow!("Unable to finalize TypeLibrary"));
     };
     view.add_type_library(&type_lib);
     Ok(())
 }
 
-fn interactive_import_til_file(
-    file: &Path,
+fn import_til_file<P: Fn(usize, usize) -> Result<(), ()>>(
+    til: TILSection,
     view: &BinaryView,
     type_library: &mut TypeLibrary,
+    progress: P,
 ) -> Result<()> {
-    // TODO create a background task to not freeze bn, also create a progress
-    // user interface feedback
-    let file = std::fs::File::open(file)?;
-    let mut file = std::io::BufReader::new(file);
-    let til = TILSection::read(&mut file, idb_rs::IDBSectionCompression::None)?;
-    for dep in &til.header.dependencies {
-        let name = dep.as_utf8_lossy();
+    trace!("Parsing the TIL section");
+    // TODO
+    let mut tils = vec![til];
+    import_til_dependency(&mut tils, 0, &progress)?;
+    import_til_section(type_library, view, &tils, progress)
+}
+
+fn import_til_dependency<P: Fn(usize, usize) -> Result<(), ()>>(
+    tils: &mut Vec<TILSection>,
+    til_idx: usize,
+    _progress: &P,
+) -> Result<()> {
+    let names: Vec<_> = tils[til_idx].header.dependencies.to_vec();
+    for name in names {
+        let name = name.as_utf8_lossy();
         let message = format!("Select the dependency \"{name}.til\"",);
         let Some(dep_file) = binaryninja::interaction::get_open_filename_input(&message, "*.til")
         else {
             return Err(anyhow!("Unable to get the dependency {name}"));
         };
 
-        interactive_import_til_file(dep_file.as_path(), view, type_library)
-            .context("While importing dependency {name}")?;
+        let mut dep_file = BufReader::new(File::open(&dep_file)?);
+        let dep_til = TILSection::read(&mut dep_file, idb_rs::IDBSectionCompression::None)?;
+        tils.push(dep_til);
     }
-
-    fn dummy_progress(_: usize, _: usize) -> Result<(), ()> {
-        Ok(())
+    if tils.len() > til_idx + 1 {
+        // add dependencies of dependencies
+        // TODO handle progress
+        // TODO identify ciclycal dependencies
+        import_til_dependency(tils, til_idx + 1, _progress)
+            .context("While importing dependency {name}")?;
     }
-    import_til_section(type_library, view, &til, dummy_progress)
+    Ok(())
 }
 
-fn import_til_section(
+fn import_til_section<P: Fn(usize, usize) -> Result<(), ()>>(
     type_library: &mut TypeLibrary,
     view: &BinaryView,
-    til: &TILSection,
-    progress: impl Fn(usize, usize) -> Result<(), ()>,
+    tils: &[TILSection],
+    progress: P,
 ) -> Result<()> {
     let default_arch = view
         .default_arch()
         .ok_or_else(|| anyhow!("Unable to get the default arch"))?;
-    let types = types::translate_til_types(default_arch, til, progress)?;
+    let types = types::translate_tils_types(default_arch, tils, progress)?;
 
     // print any errors
-    print_til_convertsion_errors(&types);
+    print_til_convertsion_errors(&types)?;
 
     // add all type to the type library
     for ty in &types {
         if let TranslateTypeResult::Translated(bn_ty)
         | TranslateTypeResult::PartiallyTranslated(bn_ty, _) = &ty.ty
         {
             let name = QualifiedName::new(vec![ty.name.as_utf8_lossy().to_string()]);
-            type_library.add_named_type(name, &bn_ty);
+            type_library.add_named_type(name, bn_ty);
         }
     }
 
     Ok(())
 }
 
-fn print_til_convertsion_errors(types: &[TranslatesIDBType]) {
+fn print_til_convertsion_errors(types: &[TranslatesIDBType]) -> Result<()> {
     for ty in types {
         match &ty.ty {
             TranslateTypeResult::NotYet => {
-                panic!(
-                    "type could not be processed `{}`: {:#?}",
+                // NOTE this should be unreachable
+                error!(
+                    "Unable to finish parsing type `{}`",
                     ty.name.as_utf8_lossy(),
-                    &ty.og_ty
                 );
             }
             TranslateTypeResult::Error(error) => {
@@ -307,6 +321,7 @@ fn print_til_convertsion_errors(types: &[TranslatesIDBType]) {
             TranslateTypeResult::Translated(_) => {}
         };
     }
+    Ok(())
 }
 
 fn parse_id0_section_info(