Refactor RepositoryManager; No longer ref counted object (one global plugin manager going forward); Move user plugin/repo plugin logic to core under single streamlined function

0cyn · 0cyn · commit 4c419bbac6c9 · 2025-09-26T11:26:42.000-04:00
diff --git a/binaryninjaapi.cpp b/binaryninjaapi.cpp
@@ -49,24 +49,6 @@ bool BinaryNinja::InitPlugins(bool allowUserPlugins)
 }
 
 
-void BinaryNinja::InitCorePlugins()
-{
-	BNInitCorePlugins();
-}
-
-
-void BinaryNinja::InitUserPlugins()
-{
-	BNInitUserPlugins();
-}
-
-
-void BinaryNinja::InitRepoPlugins()
-{
-	BNInitRepoPlugins();
-}
-
-
 string BinaryNinja::GetBundledPluginDirectory()
 {
 	char* path = BNGetBundledPluginDirectory();
diff --git a/binaryninjaapi.h b/binaryninjaapi.h
@@ -18211,17 +18211,13 @@ namespace BinaryNinja {
 	/*!
 		\ingroup pluginmanager
 	*/
-	class RepositoryManager :
-	    public CoreRefCountObject<BNRepositoryManager, BNNewRepositoryManagerReference, BNFreeRepositoryManager>
+	class RepositoryManager
 	{
 	  public:
-		RepositoryManager(const std::string& enabledPluginsPath);
-		RepositoryManager(BNRepositoryManager* repoManager);
-		RepositoryManager();
-		bool CheckForUpdates();
-		std::vector<Ref<Repository>> GetRepositories();
-		Ref<Repository> GetRepositoryByPath(const std::string& repoName);
-		bool AddRepository(const std::string& url,  // URL to raw plugins.json file
+		static bool CheckForUpdates();
+		static std::vector<Ref<Repository>> GetRepositories();
+		static Ref<Repository> GetRepositoryByPath(const std::string& repoName);
+		static bool AddRepository(const std::string& url,  // URL to raw plugins.json file
 		    const std::string& repoPath);           // Relative path within the repositories directory
 		Ref<Repository> GetDefaultRepository();
 	};
diff --git a/binaryninjacore.h b/binaryninjacore.h
@@ -255,7 +255,6 @@ extern "C"
 	typedef struct BNBackgroundTask BNBackgroundTask;
 	typedef struct BNRepository BNRepository;
 	typedef struct BNRepoPlugin BNRepoPlugin;
-	typedef struct BNRepositoryManager BNRepositoryManager;
 	typedef struct BNComponent BNComponent;
 	typedef struct BNSettings BNSettings;
 	typedef struct BNMetadata BNMetadata;
@@ -3839,11 +3838,8 @@ extern "C"
 
 	// Plugin initialization
 	BINARYNINJACOREAPI bool BNInitPlugins(bool allowUserPlugins);
-	BINARYNINJACOREAPI bool BNInitCorePlugins(void);  // Deprecated, use BNInitPlugins
 	BINARYNINJACOREAPI void BNDisablePlugins(void);
 	BINARYNINJACOREAPI bool BNIsPluginsEnabled(void);
-	BINARYNINJACOREAPI void BNInitUserPlugins(void);  // Deprecated, use BNInitPlugins
-	BINARYNINJACOREAPI void BNInitRepoPlugins(void);
 
 	BINARYNINJACOREAPI char* BNGetInstallDirectory(void);
 	BINARYNINJACOREAPI char* BNGetBundledPluginDirectory(void);
@@ -7551,18 +7547,13 @@ extern "C"
 	BINARYNINJACOREAPI BNRepoPlugin* BNRepositoryGetPluginByPath(BNRepository* r, const char* pluginPath);
 	BINARYNINJACOREAPI const char* BNRepositoryGetPluginsPath(BNRepository* r);
 
-	BINARYNINJACOREAPI BNRepositoryManager* BNCreateRepositoryManager(const char* enabledPluginsPath);
-	BINARYNINJACOREAPI BNRepositoryManager* BNNewRepositoryManagerReference(BNRepositoryManager* r);
-	BINARYNINJACOREAPI void BNFreeRepositoryManager(BNRepositoryManager* r);
-	BINARYNINJACOREAPI bool BNRepositoryManagerCheckForUpdates(BNRepositoryManager* r);
-	BINARYNINJACOREAPI BNRepository** BNRepositoryManagerGetRepositories(BNRepositoryManager* r, size_t* count);
+	BINARYNINJACOREAPI bool BNRepositoryManagerCheckForUpdates();
+	BINARYNINJACOREAPI BNRepository** BNRepositoryManagerGetRepositories(size_t* count);
 	BINARYNINJACOREAPI void BNFreeRepositoryManagerRepositoriesList(BNRepository** r);
-	BINARYNINJACOREAPI bool BNRepositoryManagerAddRepository(
-	    BNRepositoryManager* r, const char* url, const char* repoPath);
-	BINARYNINJACOREAPI BNRepository* BNRepositoryGetRepositoryByPath(BNRepositoryManager* r, const char* repoPath);
-	BINARYNINJACOREAPI BNRepositoryManager* BNGetRepositoryManager(void);
+	BINARYNINJACOREAPI bool BNRepositoryManagerAddRepository(const char* url, const char* repoPath);
+	BINARYNINJACOREAPI BNRepository* BNRepositoryGetRepositoryByPath(const char* repoPath);
 
-	BINARYNINJACOREAPI BNRepository* BNRepositoryManagerGetDefaultRepository(BNRepositoryManager* r);
+	BINARYNINJACOREAPI BNRepository* BNRepositoryManagerGetDefaultRepository();
 
 	// Components
 
diff --git a/pluginmanager.cpp b/pluginmanager.cpp
@@ -310,31 +310,16 @@ string Repository::GetFullPath() const
 	RETURN_STRING(BNRepositoryGetPluginsPath(m_object));
 }
 
-RepositoryManager::RepositoryManager(const string& enabledPluginsPath)
-{
-	m_object = BNCreateRepositoryManager(enabledPluginsPath.c_str());
-}
-
-RepositoryManager::RepositoryManager(BNRepositoryManager* mgr)
-{
-	m_object = mgr;
-}
-
-RepositoryManager::RepositoryManager()
-{
-	m_object = BNGetRepositoryManager();
-}
-
 bool RepositoryManager::CheckForUpdates()
 {
-	return BNRepositoryManagerCheckForUpdates(m_object);
+	return BNRepositoryManagerCheckForUpdates();
 }
 
 vector<Ref<Repository>> RepositoryManager::GetRepositories()
 {
 	vector<Ref<Repository>> repos;
 	size_t count = 0;
-	BNRepository** reposPtr = BNRepositoryManagerGetRepositories(m_object, &count);
+	BNRepository** reposPtr = BNRepositoryManagerGetRepositories(&count);
 	for (size_t i = 0; i < count; i++)
 		repos.push_back(new Repository(BNNewRepositoryReference(reposPtr[i])));
 	BNFreeRepositoryManagerRepositoriesList(reposPtr);
@@ -344,15 +329,15 @@ vector<Ref<Repository>> RepositoryManager::GetRepositories()
 bool RepositoryManager::AddRepository(const std::string& url,
     const std::string& repoPath)  // Relative path within the repositories directory
 {
-	return BNRepositoryManagerAddRepository(m_object, url.c_str(), repoPath.c_str());
+	return BNRepositoryManagerAddRepository(url.c_str(), repoPath.c_str());
 }
 
 Ref<Repository> RepositoryManager::GetRepositoryByPath(const std::string& repoPath)
 {
-	return new Repository(BNRepositoryGetRepositoryByPath(m_object, repoPath.c_str()));
+	return new Repository(BNRepositoryGetRepositoryByPath(repoPath.c_str()));
 }
 
 Ref<Repository> RepositoryManager::GetDefaultRepository()
 {
-	return new Repository(BNRepositoryManagerGetDefaultRepository(m_object));
+	return new Repository(BNRepositoryManagerGetDefaultRepository());
 }
diff --git a/python/__init__.py b/python/__init__.py
@@ -248,7 +248,6 @@ def _init_plugins():
 		if _enable_default_log and is_headless_init_once and min_level in LogLevel.__members__ and not core_ui_enabled(
 		) and sys.stderr.isatty():
 			log_to_stderr(LogLevel[min_level])
-		core.BNInitRepoPlugins()
 	if core.BNIsLicenseValidated():
 		_plugin_init = True
 	else:
diff --git a/python/pluginmanager.py b/python/pluginmanager.py
@@ -337,7 +337,6 @@ class RepositoryManager:
 	"""
 	def __init__(self):
 		binaryninja._init_plugins()
-		self.handle = core.BNGetRepositoryManager()
 
 	def __getitem__(self, repo_path: str) -> Repository:
 		for repo in self.repositories:
@@ -347,14 +346,14 @@ def __getitem__(self, repo_path: str) -> Repository:
 
 	def check_for_updates(self) -> bool:
 		"""Check for updates for all managed Repository objects"""
-		return core.BNRepositoryManagerCheckForUpdates(self.handle)
+		return core.BNRepositoryManagerCheckForUpdates()
 
 	@property
 	def repositories(self) -> List[Repository]:
 		"""List of Repository objects being managed"""
 		result = []
 		count = ctypes.c_ulonglong(0)
-		repos = core.BNRepositoryManagerGetRepositories(self.handle, count)
+		repos = core.BNRepositoryManagerGetRepositories(count)
 		assert repos is not None, "core.BNRepositoryManagerGetRepositories returned None"
 		try:
 			for i in range(count.value):
@@ -376,7 +375,7 @@ def plugins(self) -> Dict[str, List[RepoPlugin]]:
 	@property
 	def default_repository(self) -> Repository:
 		"""Gets the default Repository"""
-		repo_handle = core.BNRepositoryManagerGetDefaultRepository(self.handle)
+		repo_handle = core.BNRepositoryManagerGetDefaultRepository()
 		assert repo_handle is not None, "core.BNRepositoryManagerGetDefaultRepository returned None"
 		repo_handle_ref = core.BNNewRepositoryReference(repo_handle)
 		assert repo_handle_ref is not None, "core.BNNewRepositoryReference returned None"
@@ -406,4 +405,4 @@ def add_repository(self, url: Optional[str] = None, repopath: Optional[str] = No
 		if not isinstance(url, str) or not isinstance(repopath, str):
 			raise ValueError("Expected url or repopath to be of type str.")
 
-		return core.BNRepositoryManagerAddRepository(self.handle, url, repopath)
+		return core.BNRepositoryManagerAddRepository(url, repopath)
diff --git a/rust/src/headless.rs b/rust/src/headless.rs
@@ -26,7 +26,7 @@ use crate::enterprise::EnterpriseCheckoutStatus;
 use crate::main_thread::{MainThreadAction, MainThreadHandler};
 use crate::progress::ProgressCallback;
 use crate::rc::Ref;
-use binaryninjacore_sys::{BNInitPlugins, BNInitRepoPlugins};
+use binaryninjacore_sys::{BNInitPlugins};
 use std::sync::mpsc::Sender;
 use std::sync::Mutex;
 use std::thread::JoinHandle;
@@ -221,10 +221,6 @@ pub fn init_with_opts(options: InitializationOptions) -> Result<(), Initializati
 
     unsafe {
         BNInitPlugins(options.user_plugins);
-        if options.repo_plugins {
-            // We are allowed to initialize repo plugins, so do it!
-            BNInitRepoPlugins();
-        }
     }
 
     if !is_license_validated() {
diff --git a/rust/src/repository/manager.rs b/rust/src/repository/manager.rs
@@ -1,9 +1,7 @@
-use crate::rc::{Array, Ref, RefCountable};
+use crate::rc::{Array, Ref};
 use crate::repository::Repository;
 use crate::string::IntoCStr;
-use binaryninjacore_sys::{
-    BNCreateRepositoryManager, BNFreeRepositoryManager, BNGetRepositoryManager,
-    BNNewRepositoryManagerReference, BNRepositoryGetRepositoryByPath, BNRepositoryManager,
+use binaryninjacore_sys::{BNRepositoryGetRepositoryByPath,
     BNRepositoryManagerAddRepository, BNRepositoryManagerCheckForUpdates,
     BNRepositoryManagerGetDefaultRepository, BNRepositoryManagerGetRepositories,
 };
@@ -13,38 +11,24 @@ 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(plugins_path: &str) -> Ref<Self> {
-        let plugins_path = plugins_path.to_cstr();
-        let result = unsafe { BNCreateRepositoryManager(plugins_path.as_ptr()) };
-        unsafe { Self::ref_from_raw(NonNull::new(result).unwrap()) }
+    pub fn new() -> Self {
+        Self {}
     }
 
     /// Check for updates for all managed [`Repository`] objects
     pub fn check_for_updates(&self) -> bool {
-        unsafe { BNRepositoryManagerCheckForUpdates(self.handle.as_ptr()) }
+        unsafe { BNRepositoryManagerCheckForUpdates() }
     }
 
     /// 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) };
+            unsafe { BNRepositoryManagerGetRepositories(&mut count) };
         assert!(!result.is_null());
         unsafe { Array::new(result, count, ()) }
     }
@@ -64,20 +48,20 @@ impl RepositoryManager {
         let url = url.to_cstr();
         let repo_path = repository_path.to_cstr();
         unsafe {
-            BNRepositoryManagerAddRepository(self.handle.as_ptr(), url.as_ptr(), repo_path.as_ptr())
+            BNRepositoryManagerAddRepository(url.as_ptr(), repo_path.as_ptr())
         }
     }
 
     pub fn repository_by_path(&self, path: &Path) -> Option<Repository> {
         let path = path.to_cstr();
         let result =
-            unsafe { BNRepositoryGetRepositoryByPath(self.handle.as_ptr(), path.as_ptr()) };
+            unsafe { BNRepositoryGetRepositoryByPath(path.as_ptr()) };
         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()) };
+        let result = unsafe { BNRepositoryManagerGetDefaultRepository() };
         assert!(!result.is_null());
         unsafe { Repository::ref_from_raw(NonNull::new(result).unwrap()) }
     }
@@ -90,23 +74,3 @@ impl Debug for RepositoryManager {
             .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())
-    }
-}

Original file line number	Diff line number	Diff line change
`@@ -310,31 +310,16 @@ string Repository::GetFullPath() const`
`310`	`310`	`RETURN_STRING(BNRepositoryGetPluginsPath(m_object));`
`311`	`311`	`}`
`312`	`312`
`313`		`-RepositoryManager::RepositoryManager(const string& enabledPluginsPath)`
`314`		`-{`
`315`		`- m_object = BNCreateRepositoryManager(enabledPluginsPath.c_str());`
`316`		`-}`
`317`		`-`
`318`		`-RepositoryManager::RepositoryManager(BNRepositoryManager* mgr)`
`319`		`-{`
`320`		`- m_object = mgr;`
`321`		`-}`
`322`		`-`
`323`		`-RepositoryManager::RepositoryManager()`
`324`		`-{`
`325`		`- m_object = BNGetRepositoryManager();`
`326`		`-}`
`327`		`-`
`328`	`313`	`bool RepositoryManager::CheckForUpdates()`
`329`	`314`	`{`
`330`		`- return BNRepositoryManagerCheckForUpdates(m_object);`
	`315`	`+ return BNRepositoryManagerCheckForUpdates();`
`331`	`316`	`}`
`332`	`317`
`333`	`318`	`vector<Ref<Repository>> RepositoryManager::GetRepositories()`
`334`	`319`	`{`
`335`	`320`	`vector<Ref<Repository>> repos;`
`336`	`321`	`size_t count = 0;`
`337`		`- BNRepository** reposPtr = BNRepositoryManagerGetRepositories(m_object, &count);`
	`322`	`+ BNRepository** reposPtr = BNRepositoryManagerGetRepositories(&count);`
`338`	`323`	`for (size_t i = 0; i < count; i++)`
`339`	`324`	`repos.push_back(new Repository(BNNewRepositoryReference(reposPtr[i])));`
`340`	`325`	`BNFreeRepositoryManagerRepositoriesList(reposPtr);`
`@@ -344,15 +329,15 @@ vector<Ref<Repository>> RepositoryManager::GetRepositories()`
`344`	`329`	`bool RepositoryManager::AddRepository(const std::string& url,`
`345`	`330`	`const std::string& repoPath) // Relative path within the repositories directory`
`346`	`331`	`{`
`347`		`- return BNRepositoryManagerAddRepository(m_object, url.c_str(), repoPath.c_str());`
	`332`	`+ return BNRepositoryManagerAddRepository(url.c_str(), repoPath.c_str());`
`348`	`333`	`}`
`349`	`334`
`350`	`335`	`Ref<Repository> RepositoryManager::GetRepositoryByPath(const std::string& repoPath)`
`351`	`336`	`{`
`352`		`- return new Repository(BNRepositoryGetRepositoryByPath(m_object, repoPath.c_str()));`
	`337`	`+ return new Repository(BNRepositoryGetRepositoryByPath(repoPath.c_str()));`
`353`	`338`	`}`
`354`	`339`
`355`	`340`	`Ref<Repository> RepositoryManager::GetDefaultRepository()`
`356`	`341`	`{`
`357`		`- return new Repository(BNRepositoryManagerGetDefaultRepository(m_object));`
	`342`	`+ return new Repository(BNRepositoryManagerGetDefaultRepository());`
`358`	`343`	`}`