Implement Rust Repository

Author: rbran

rust/src/lib.rs

@@ -70,6 +70,7 @@ pub mod references;
 pub mod relocation;
 pub mod render_layer;
 pub mod secrets_provider;
+pub mod repository;
 pub mod section;
 pub mod segment;
 pub mod settings;
@@ -95,6 +96,7 @@ use binaryninjacore_sys::*;
 use metadata::Metadata;
 use metadata::MetadataType;
 use rc::Ref;
+use std::cmp;
 use std::collections::HashMap;
 use std::ffi::{c_char, c_void, CStr};
 use std::path::{Path, PathBuf};
@@ -103,6 +105,7 @@ use string::BnString;
 use string::IntoJson;
 
 use crate::progress::{NoProgressCallback, ProgressCallback};
+use crate::string::raw_to_string;
 pub use binaryninjacore_sys::BNBranchType as BranchType;
 pub use binaryninjacore_sys::BNDataFlowQueryOption as DataFlowQueryOption;
 pub use binaryninjacore_sys::BNEndianness as Endianness;
@@ -436,7 +439,7 @@ pub fn build_id() -> u32 {
     unsafe { BNGetBuildId() }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(Clone, PartialEq, Eq, Hash, Debug)]
 pub struct VersionInfo {
     pub major: u32,
     pub minor: u32,
@@ -445,12 +448,59 @@ pub struct VersionInfo {
 }
 
 impl VersionInfo {
-    pub(crate) fn from_owned_raw(value: BNVersionInfo) -> Self {
+    pub(crate) fn from_raw(value: &BNVersionInfo) -> Self {
         Self {
             major: value.major,
             minor: value.minor,
             build: value.build,
-            channel: unsafe { BnString::from_raw(value.channel) }.to_string(),
+            // NOTE: Because of plugin manager the channel might not be filled.
+            channel: raw_to_string(value.channel).unwrap_or_default(),
+        }
+    }
+
+    pub(crate) fn from_owned_raw(value: BNVersionInfo) -> Self {
+        let owned = Self::from_raw(&value);
+        Self::free_raw(value);
+        owned
+    }
+
+    pub(crate) fn into_owned_raw(value: &Self) -> BNVersionInfo {
+        BNVersionInfo {
+            major: value.major,
+            minor: value.minor,
+            build: value.build,
+            channel: value.channel.as_ptr() as *mut c_char,
+        }
+    }
+
+    pub(crate) fn free_raw(value: BNVersionInfo) {
+        let _ = unsafe { BnString::from_raw(value.channel) };
+    }
+
+    pub fn from_string<S: BnStrCompatible>(string: S) -> Self {
+        let string = string.into_bytes_with_nul();
+        let result = unsafe { BNParseVersionString(string.as_ref().as_ptr() as *const c_char) };
+        Self::from_owned_raw(result)
+    }
+}
+
+impl PartialOrd for VersionInfo {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VersionInfo {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        if self == other {
+            return cmp::Ordering::Equal;
+        }
+        let bn_version_0 = VersionInfo::into_owned_raw(self);
+        let bn_version_1 = VersionInfo::into_owned_raw(other);
+        if unsafe { BNVersionLessThan(bn_version_0, bn_version_1) } {
+            cmp::Ordering::Less
+        } else {
+            cmp::Ordering::Greater
         }
     }
 }

rust/src/repository.rs

@@ -0,0 +1,134 @@
+mod manager;
+mod plugin;
+
+use std::ffi::c_char;
+use std::fmt::Debug;
+use std::ptr::NonNull;
+
+use binaryninjacore_sys::*;
+
+use crate::rc::{Array, CoreArrayProvider, CoreArrayProviderInner, Guard, Ref, RefCountable};
+use crate::repository::plugin::RepositoryPlugin;
+use crate::string::{BnStrCompatible, BnString};
+
+pub use manager::RepositoryManager;
+
+pub type PluginType = BNPluginType;
+pub type PluginStatus = BNPluginStatus;
+
+#[repr(transparent)]
+pub struct Repository {
+    handle: NonNull<BNRepository>,
+}
+
+impl Repository {
+    pub(crate) unsafe fn from_raw(handle: NonNull<BNRepository>) -> Self {
+        Self { handle }
+    }
+
+    pub(crate) unsafe fn ref_from_raw(handle: NonNull<BNRepository>) -> Ref<Self> {
+        Ref::new(Self { handle })
+    }
+
+    /// String URL of the git repository where the plugin repository's are stored
+    pub fn url(&self) -> BnString {
+        let result = unsafe { BNRepositoryGetUrl(self.handle.as_ptr()) };
+        assert!(!result.is_null());
+        unsafe { BnString::from_raw(result as *mut c_char) }
+    }
+
+    /// String local path to store the given plugin repository
+    pub fn path(&self) -> BnString {
+        let result = unsafe { BNRepositoryGetRepoPath(self.handle.as_ptr()) };
+        assert!(!result.is_null());
+        unsafe { BnString::from_raw(result as *mut c_char) }
+    }
+
+    /// List of RepoPlugin objects contained within this repository
+    pub fn plugins(&self) -> Array<RepositoryPlugin> {
+        let mut count = 0;
+        let result = unsafe { BNRepositoryGetPlugins(self.handle.as_ptr(), &mut count) };
+        assert!(!result.is_null());
+        unsafe { Array::new(result, count, ()) }
+    }
+
+    pub fn plugin_by_path<S: BnStrCompatible>(&self, path: S) -> Option<Ref<RepositoryPlugin>> {
+        let path = path.into_bytes_with_nul();
+        let result = unsafe {
+            BNRepositoryGetPluginByPath(
+                self.handle.as_ptr(),
+                path.as_ref().as_ptr() as *const c_char,
+            )
+        };
+        NonNull::new(result).map(|h| unsafe { RepositoryPlugin::ref_from_raw(h) })
+    }
+
+    // TODO: Make this a PathBuf?
+    /// String full path the repository
+    pub fn full_path(&self) -> BnString {
+        let result = unsafe { BNRepositoryGetPluginsPath(self.handle.as_ptr()) };
+        assert!(!result.is_null());
+        unsafe { BnString::from_raw(result as *mut c_char) }
+    }
+}
+
+impl Debug for Repository {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Repository")
+            .field("url", &self.url())
+            .field("path", &self.path())
+            .field("full_path", &self.full_path())
+            .field("plugins", &self.plugins().to_vec())
+            .finish()
+    }
+}
+
+impl ToOwned for Repository {
+    type Owned = Ref<Self>;
+
+    fn to_owned(&self) -> Self::Owned {
+        unsafe { <Self as RefCountable>::inc_ref(self) }
+    }
+}
+
+unsafe impl RefCountable for Repository {
+    unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
+        Self::ref_from_raw(NonNull::new(BNNewRepositoryReference(handle.handle.as_ptr())).unwrap())
+    }
+
+    unsafe fn dec_ref(handle: &Self) {
+        BNFreeRepository(handle.handle.as_ptr())
+    }
+}
+
+impl CoreArrayProvider for Repository {
+    type Raw = *mut BNRepository;
+    type Context = ();
+    type Wrapped<'a> = Guard<'a, Self>;
+}
+
+unsafe impl CoreArrayProviderInner for Repository {
+    unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
+        BNFreeRepositoryManagerRepositoriesList(raw)
+    }
+
+    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, context: &'a Self::Context) -> Self::Wrapped<'a> {
+        Guard::new(Self::from_raw(NonNull::new(*raw).unwrap()), context)
+    }
+}
+
+impl CoreArrayProvider for PluginType {
+    type Raw = BNPluginType;
+    type Context = ();
+    type Wrapped<'a> = Self;
+}
+
+unsafe impl CoreArrayProviderInner for PluginType {
+    unsafe fn free(raw: *mut Self::Raw, _count: usize, _context: &Self::Context) {
+        BNFreePluginTypes(raw)
+    }
+
+    unsafe fn wrap_raw<'a>(raw: &'a Self::Raw, _context: &'a Self::Context) -> Self::Wrapped<'a> {
+        *raw
+    }
+}

rust/src/repository/manager.rs

@@ -0,0 +1,125 @@
+use crate::rc::{Array, Ref, RefCountable};
+use crate::repository::Repository;
+use crate::string::BnStrCompatible;
+use binaryninjacore_sys::{
+    BNCreateRepositoryManager, BNFreeRepositoryManager, BNGetRepositoryManager,
+    BNNewRepositoryManagerReference, BNRepositoryGetRepositoryByPath, BNRepositoryManager,
+    BNRepositoryManagerAddRepository, BNRepositoryManagerCheckForUpdates,
+    BNRepositoryManagerGetDefaultRepository, BNRepositoryManagerGetRepositories,
+};
+use std::ffi::c_char;
+use std::fmt::Debug;
+use std::ptr::NonNull;
+
+/// Keeps track of all the repositories and keeps the `enabled_plugins.json`
+/// file coherent with the plugins that are installed/uninstalled enabled/disabled
+#[repr(transparent)]
+pub struct RepositoryManager {
+    handle: NonNull<BNRepositoryManager>,
+}
+
+impl RepositoryManager {
+    #[allow(clippy::should_implement_trait)]
+    pub fn default() -> Ref<Self> {
+        let result = unsafe { BNGetRepositoryManager() };
+        unsafe { Self::ref_from_raw(NonNull::new(result).unwrap()) }
+    }
+
+    pub(crate) unsafe fn ref_from_raw(handle: NonNull<BNRepositoryManager>) -> Ref<Self> {
+        Ref::new(Self { handle })
+    }
+
+    pub fn new<S: BnStrCompatible>(plugins_path: S) -> Ref<Self> {
+        let plugins_path = plugins_path.into_bytes_with_nul();
+        let result =
+            unsafe { BNCreateRepositoryManager(plugins_path.as_ref().as_ptr() as *const c_char) };
+        unsafe { Self::ref_from_raw(NonNull::new(result).unwrap()) }
+    }
+
+    /// Check for updates for all managed [`Repository`] objects
+    pub fn check_for_updates(&self) -> bool {
+        unsafe { BNRepositoryManagerCheckForUpdates(self.handle.as_ptr()) }
+    }
+
+    /// List of [`Repository`] objects being managed
+    pub fn repositories(&self) -> Array<Repository> {
+        let mut count = 0;
+        let result =
+            unsafe { BNRepositoryManagerGetRepositories(self.handle.as_ptr(), &mut count) };
+        assert!(!result.is_null());
+        unsafe { Array::new(result, count, ()) }
+    }
+
+    /// Adds a new plugin repository for the manager to track.
+    ///
+    /// To remove a repository, restart Binary Ninja (and don't re-add the repository!).
+    /// File artifacts will remain on disk under repositories/ file in the User Folder.
+    ///
+    /// Before you can query plugin metadata from a repository, you need to call [`RepositoryManager::check_for_updates`].
+    ///
+    /// * `url` - URL to the plugins.json containing the records for this repository
+    /// * `repository_path` - path to where the repository will be stored on disk locally
+    ///
+    /// Returns true if the repository was successfully added, false otherwise.
+    pub fn add_repository<U: BnStrCompatible, P: BnStrCompatible>(
+        &self,
+        url: U,
+        repository_path: P,
+    ) -> bool {
+        let url = url.into_bytes_with_nul();
+        let repo_path = repository_path.into_bytes_with_nul();
+        unsafe {
+            BNRepositoryManagerAddRepository(
+                self.handle.as_ptr(),
+                url.as_ref().as_ptr() as *const c_char,
+                repo_path.as_ref().as_ptr() as *const c_char,
+            )
+        }
+    }
+
+    pub fn repository_by_path<P: BnStrCompatible>(&self, path: P) -> Option<Repository> {
+        let path = path.into_bytes_with_nul();
+        let result = unsafe {
+            BNRepositoryGetRepositoryByPath(
+                self.handle.as_ptr(),
+                path.as_ref().as_ptr() as *const c_char,
+            )
+        };
+        NonNull::new(result).map(|raw| unsafe { Repository::from_raw(raw) })
+    }
+
+    /// Gets the default [`Repository`]
+    pub fn default_repository(&self) -> Ref<Repository> {
+        let result = unsafe { BNRepositoryManagerGetDefaultRepository(self.handle.as_ptr()) };
+        assert!(!result.is_null());
+        unsafe { Repository::ref_from_raw(NonNull::new(result).unwrap()) }
+    }
+}
+
+impl Debug for RepositoryManager {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("RepositoryManager")
+            .field("repositories", &self.repositories().to_vec())
+            .finish()
+    }
+}
+
+impl ToOwned for RepositoryManager {
+    type Owned = Ref<Self>;
+
+    fn to_owned(&self) -> Self::Owned {
+        unsafe { RefCountable::inc_ref(self) }
+    }
+}
+
+unsafe impl RefCountable for RepositoryManager {
+    unsafe fn inc_ref(handle: &Self) -> Ref<Self> {
+        Self::ref_from_raw(
+            NonNull::new(BNNewRepositoryManagerReference(handle.handle.as_ptr())).unwrap(),
+        )
+    }
+
+    unsafe fn dec_ref(handle: &Self) {
+        BNFreeRepositoryManager(handle.handle.as_ptr())
+    }
+}