More rust cleanup

- Improved binary view initialization (see init_with_opts)
- Allow floating license to free itself before initialization
- Add initialization unit test
- Add better Debug impls for some common types
- Use Path api for opening binary views, this is not breaking as it uses the AsRef impl
- Bump rayon dependency and constrain dependencies to x.x

Author: emesare

rust/Cargo.toml

@@ -9,13 +9,12 @@ rust-version = "1.83.0"
 # This is used when statically linking to prevent exporting CorePluginABIVersion and UiPluginABIVersion.
 no_exports = []
 
-
 [dependencies]
 log = { version = "0.4", features = ["std"] }
-rayon = { version = "1.8", optional = true }
+rayon = { version = "1.10", optional = true }
 binaryninjacore-sys = { path = "binaryninjacore-sys" }
 thiserror = "2.0"
 
 [dev-dependencies]
-rstest = "0.24.0"
-tempfile = "3"
+rstest = "0.24"
+tempfile = "3.15"

rust/src/binaryview.rs

@@ -39,28 +39,28 @@ use crate::function::{Function, NativeBlock};
 use crate::linearview::{LinearDisassemblyLine, LinearViewCursor};
 use crate::metadata::Metadata;
 use crate::platform::Platform;
+use crate::rc::*;
+use crate::references::{CodeReference, DataReference};
 use crate::relocation::Relocation;
 use crate::section::{Section, SectionBuilder};
 use crate::segment::{Segment, SegmentBuilder};
 use crate::settings::Settings;
+use crate::string::*;
 use crate::symbol::{Symbol, SymbolType};
 use crate::tags::{Tag, TagType};
+use crate::typecontainer::TypeContainer;
 use crate::typelibrary::TypeLibrary;
 use crate::types::{
     NamedTypeReference, QualifiedName, QualifiedNameAndType, QualifiedNameTypeAndId, Type,
 };
+use crate::variable::DataVariable;
 use crate::Endianness;
 use std::collections::HashMap;
 use std::ffi::{c_char, c_void};
 use std::ops::Range;
+use std::path::Path;
 use std::ptr::NonNull;
 use std::{ops, result, slice};
-
-use crate::rc::*;
-use crate::references::{CodeReference, DataReference};
-use crate::string::*;
-use crate::typecontainer::TypeContainer;
-use crate::variable::DataVariable;
 // TODO : general reorg of modules related to bv
 
 pub type Result<R> = result::Result<R, ()>;
@@ -190,7 +190,6 @@ pub trait BinaryViewExt: BinaryViewBase {
     fn file(&self) -> Ref<FileMetadata> {
         unsafe {
             let raw = BNGetFileForView(self.as_ref().handle);
-
             Ref::new(FileMetadata::from_raw(raw))
         }
     }
@@ -1774,15 +1773,10 @@ impl BinaryView {
         Ref::new(Self { handle })
     }
 
-    pub fn from_filename<S: BnStrCompatible>(
-        meta: &mut FileMetadata,
-        filename: S,
-    ) -> Result<Ref<Self>> {
-        let file = filename.into_bytes_with_nul();
-
-        let handle = unsafe {
-            BNCreateBinaryDataViewFromFilename(meta.handle, file.as_ref().as_ptr() as *mut _)
-        };
+    pub fn from_path(meta: &mut FileMetadata, file_path: impl AsRef<Path>) -> Result<Ref<Self>> {
+        let file = file_path.as_ref().into_bytes_with_nul();
+        let handle =
+            unsafe { BNCreateBinaryDataViewFromFilename(meta.handle, file.as_ptr() as *mut _) };
 
         if handle.is_null() {
             return Err(());
@@ -1920,13 +1914,25 @@ unsafe impl Sync for BinaryView {}
 
 impl std::fmt::Debug for BinaryView {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "BinaryView (type: `{}`): '{}', len {:#x}",
-            self.view_type(),
-            self.file().filename(),
-            self.len()
-        )
+        f.debug_struct("BinaryView")
+            .field("type_name", &self.type_name())
+            .field("file", &self.file())
+            .field("original_image_base", &self.original_image_base())
+            .field("start", &self.start())
+            .field("end", &self.end())
+            .field("len", &self.len())
+            .field("default_platform", &self.default_platform())
+            .field("default_arch", &self.default_arch())
+            .field("default_endianness", &self.default_endianness())
+            .field("entry_point", &self.entry_point())
+            .field(
+                "entry_point_functions",
+                &self.entry_point_functions().to_vec(),
+            )
+            .field("address_size", &self.address_size())
+            .field("sections", &self.sections().to_vec())
+            .field("segments", &self.segments().to_vec())
+            .finish()
     }
 }
 

rust/src/component.rs

@@ -10,8 +10,11 @@ use crate::variable::DataVariable;
 use binaryninjacore_sys::*;
 
 pub struct ComponentBuilder {
+    // TODO: This should be a ref
     bv: *mut BNBinaryView,
+    // TODO: Make owned string
     parent: Option<BnString>,
+    // TODO: Make owned string
     name: Option<BnString>,
 }
 
@@ -75,6 +78,7 @@ impl Component {
         Self { handle }
     }
 
+    // TODO: Ref<>
     pub(crate) unsafe fn ref_from_raw(handle: &*mut BNComponent) -> &Self {
         assert!(!handle.is_null());
         mem::transmute(handle)

rust/src/enterprise.rs

@@ -18,6 +18,7 @@ pub enum EnterpriseCheckoutError {
     RefreshExpiredLicenseFailed,
 }
 
+/// Initialize the enterprise server connection to check out a floating license.
 pub fn checkout_license(duration: Duration) -> Result<(), EnterpriseCheckoutError> {
     if crate::is_ui_enabled() {
         // We only need to check out a license if running headlessly.
@@ -70,6 +71,16 @@ pub fn checkout_license(duration: Duration) -> Result<(), EnterpriseCheckoutErro
 
 pub fn release_license() {
     if !crate::is_ui_enabled() {
+        // This might look dumb, why would we want to connect to the server, would that not just mean
+        // we don't need to release the license? Well no, you could have run a script, acquired a license for 10 hours
+        // then you WOULD want to call release license, and your expectation is that acquired license
+        // will now be released. To release that you must have an active connection which is what this does.
+        if !is_server_initialized() {
+            initialize_server();
+        }
+        if !is_server_connected() {
+            connect_server();
+        }
         // We should only release the license if we are running headlessly.
         release_server_license();
     }

rust/src/filemetadata.rs

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use crate::binaryview::BinaryView;
+use crate::database::Database;
+use crate::project::ProjectFile;
 use binaryninjacore_sys::{
     BNBeginUndoActions, BNCloseFile, BNCommitUndoActions, BNCreateDatabase, BNCreateFileMetadata,
     BNFileMetadata, BNFileMetadataGetSessionId, BNFreeFileMetadata, BNGetCurrentOffset,
@@ -23,10 +26,7 @@ use binaryninjacore_sys::{
 };
 use binaryninjacore_sys::{BNCreateDatabaseWithProgress, BNOpenExistingDatabaseWithProgress};
 use std::ffi::c_void;
-
-use crate::binaryview::BinaryView;
-use crate::database::Database;
-use crate::project::ProjectFile;
+use std::fmt::Debug;
 
 use crate::rc::*;
 use crate::string::*;
@@ -38,9 +38,6 @@ pub struct FileMetadata {
     pub(crate) handle: *mut BNFileMetadata,
 }
 
-unsafe impl Send for FileMetadata {}
-unsafe impl Sync for FileMetadata {}
-
 impl FileMetadata {
     pub(crate) fn from_raw(handle: *mut BNFileMetadata) -> Self {
         Self { handle }
@@ -285,6 +282,22 @@ impl FileMetadata {
     }
 }
 
+impl Debug for FileMetadata {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FileMetadata")
+            .field("filename", &self.filename())
+            .field("session_id", &self.session_id())
+            .field("modified", &self.modified())
+            .field("is_analysis_changed", &self.is_analysis_changed())
+            .field("current_view", &self.current_view())
+            .field("current_view", &self.current_offset())
+            .finish()
+    }
+}
+
+unsafe impl Send for FileMetadata {}
+unsafe impl Sync for FileMetadata {}
+
 impl ToOwned for FileMetadata {
     type Owned = Ref<Self>;