Change Group to use User objects

Author: negasora

binaryninjaapi.h

@@ -22462,7 +22462,7 @@ namespace BinaryNinja::Collaboration
 		uint64_t GetId();
 		std::string GetName();
 		void SetName(const std::string& name);
-		void SetUsernames(const std::vector<std::string>& usernames);
+		void SetUsers(const std::vector<Ref<CollabUser>>& users);
 		bool ContainsUser(Ref<CollabUser> user);
 
 	};
@@ -22645,10 +22645,11 @@ namespace BinaryNinja::Collaboration
 		/*!
 			Create a new group on the remote (and pull it)
 			\param name Group name
+			\param users List of users in group
 			\return Reference to the created group
 			\throws RemoteException If there is an error in any request or if the remote is not connected
 		*/
-		Ref<CollabGroup> CreateGroup(const std::string& name, const std::vector<std::string>& usernames);
+		Ref<CollabGroup> CreateGroup(const std::string& name, const std::vector<Ref<CollabUser>>& users = {});
 
 
 		/*!

binaryninjacore.h

@@ -8590,7 +8590,7 @@ extern "C"
 	BINARYNINJACOREAPI BNCollaborationGroup* BNRemoteGetGroupByName(BNRemote* remote, const char* name);
 	BINARYNINJACOREAPI bool BNRemoteSearchGroups(BNRemote* remote, const char* prefix, uint64_t** groupIds, char*** groupNames, size_t* count);
 	BINARYNINJACOREAPI bool BNRemotePullGroups(BNRemote* remote, BNProgressFunction progress, void* progressContext);
-	BINARYNINJACOREAPI BNCollaborationGroup* BNRemoteCreateGroup(BNRemote* remote, const char* name, const char** usernames, size_t usernameCount);
+	BINARYNINJACOREAPI BNCollaborationGroup* BNRemoteCreateGroup(BNRemote* remote, const char* name, BNCollaborationUser** users, size_t userCount);
 	BINARYNINJACOREAPI bool BNRemotePushGroup(BNRemote* remote, BNCollaborationGroup* group, const char** extraFieldKeys, const char** extraFieldValues, size_t extraFieldCount);
 	BINARYNINJACOREAPI bool BNRemoteDeleteGroup(BNRemote* remote, BNCollaborationGroup* group);
 	BINARYNINJACOREAPI BNCollaborationUser** BNRemoteGetUsers(BNRemote* remote, size_t* count);
@@ -8614,8 +8614,8 @@ extern "C"
 	BINARYNINJACOREAPI uint64_t BNCollaborationGroupGetId(BNCollaborationGroup* group);
 	BINARYNINJACOREAPI char* BNCollaborationGroupGetName(BNCollaborationGroup* group);
 	BINARYNINJACOREAPI void BNCollaborationGroupSetName(BNCollaborationGroup* group, const char* name);
-	BINARYNINJACOREAPI bool BNCollaborationGroupGetUsers(BNCollaborationGroup* group, char*** userIds, char*** usernames, size_t* count);
-	BINARYNINJACOREAPI bool BNCollaborationGroupSetUsernames(BNCollaborationGroup* group, const char** names, size_t count);
+	BINARYNINJACOREAPI BNCollaborationUser** BNCollaborationGroupGetUsers(BNCollaborationGroup* group, size_t* count);
+	BINARYNINJACOREAPI bool BNCollaborationGroupSetUsers(BNCollaborationGroup* group, BNCollaborationUser** users, size_t count);
 	BINARYNINJACOREAPI bool BNCollaborationGroupContainsUser(BNCollaborationGroup* group, BNCollaborationUser* user);
 
 	// CollabUser

collaboration.cpp

@@ -878,16 +878,16 @@ void Remote::PullGroups(ProgressFunction progress)
 }
 
 
-Ref<CollabGroup> Remote::CreateGroup(const std::string& name, const std::vector<std::string>& usernames)
+Ref<CollabGroup> Remote::CreateGroup(const std::string& name, const std::vector<Ref<CollabUser>>& users)
 {
-	const char** cstrNames = new const char*[usernames.size()];
-	for (size_t i = 0; i < usernames.size(); i++)
+	BNCollaborationUser** cUsers = new BNCollaborationUser*[users.size()];
+	for (size_t i = 0; i < users.size(); i++)
 	{
-		cstrNames[i] = usernames[i].c_str();
+		cUsers[i] = users[i]->m_object;
 	}
 
-	BNCollaborationGroup* group = BNRemoteCreateGroup(m_object, name.c_str(), cstrNames, usernames.size());
-	delete[] cstrNames;
+	BNCollaborationGroup* group = BNRemoteCreateGroup(m_object, name.c_str(), cUsers, users.size());
+	delete[] cUsers;
 	if (!group)
 		return nullptr;
 	return new CollabGroup(group);
@@ -1076,16 +1076,17 @@ void CollabGroup::SetName(const std::string& name)
 }
 
 
-void CollabGroup::SetUsernames(const std::vector<std::string>& usernames)
+void CollabGroup::SetUsers(const std::vector<Ref<CollabUser>>& users)
 {
-	const char** cNames = new const char*[usernames.size()];
-	for (size_t i = 0; i < usernames.size(); i++)
+	size_t count = users.size();
+	BNCollaborationUser** cUsers = new BNCollaborationUser*[count];
+	for (size_t i = 0; i < count; i++)
 	{
-		cNames[i] = usernames[i].c_str();
+		cUsers[i] = users[i]->m_object;
 	}
 
-	BNCollaborationGroupSetUsernames(m_object, cNames, usernames.size());
-	delete[] cNames;
+	BNCollaborationGroupSetUsers(m_object, cUsers, count);
+	delete[] cUsers;
 }
 
 

python/collaboration/group.py

@@ -70,36 +70,33 @@ def name(self, name: str):
 		core.BNCollaborationGroupSetName(self._handle, name)
 
 	@property
-	def users(self) -> List[Tuple[str, str]]:
+	def users(self) -> List[user.User]:
 		"""
 		Get list of users in the group
 
-		:return: List of (userid, username) pairs
+		:return: List of users
 		"""
 		count = ctypes.c_size_t()
-		user_ids = ctypes.POINTER(ctypes.c_char_p)()
-		usernames = ctypes.POINTER(ctypes.c_char_p)()
-		if not core.BNCollaborationGroupGetUsers(self._handle, user_ids, usernames, count):
+		result = core.BNCollaborationGroupGetUsers(self._handle, count)
+		if not result:
 			raise RuntimeError(util._last_error())
-		result = []
+		out = []
 		for i in range(count.value):
-			result.append((core.pyNativeStr(user_ids[i]), core.pyNativeStr(usernames[i])))
-		core.BNFreeStringList(user_ids, count.value)
-		core.BNFreeStringList(usernames, count.value)
-		return result
+			out.append(user.User(result[i]))
+		return out
 
 	@users.setter
-	def users(self, usernames: List[str]):
+	def users(self, users: List[user.User]):
 		"""
-		Set the list of users in a group by their usernames.
+		Set the list of users in a group.
 		You will need to push the group to update the Remote.
 
-		:param usernames: Usernames of new group members
+		:param users: New group members
 		"""
-		array = (ctypes.c_char_p * len(usernames))()
-		for i in range(len(usernames)):
-			array[i] = core.cstr(usernames[i])
-		if not core.BNCollaborationGroupSetUsernames(self._handle, array, len(usernames)):
+		array = ctypes.POINTER(core.BNCollaborationUserHandle)()
+		for i in range(len(users)):
+			array[i] = users[i]._handle
+		if not core.BNCollaborationGroupSetUsers(self._handle, array, len(users)):
 			raise RuntimeError(util._last_error())
 
 	def contains_user(self, user: user.User) -> bool:

python/collaboration/remote.py

@@ -520,22 +520,22 @@ def pull_groups(self, progress: 'util.ProgressFuncType' = util.nop):
 		if not core.BNRemotePullGroups(self._handle, util.wrap_progress(progress), None):
 			raise RuntimeError(util._last_error())
 
-	def create_group(self, name: str, usernames: List[str]) -> 'group.Group':
+	def create_group(self, name: str, users: List[user.User]) -> 'group.Group':
 		"""
 		Create a new group on the remote (and pull it)
 
 		.. note:: This function is only available to accounts with admin status on the Remote
 
 		:param name: Group name
-		:param usernames: List of usernames of users in the group
+		:param users: List of users in the group
 		:return: Reference to the created group
 		:raises: RuntimeError if there was an error
 		"""
-		c_usernames = (ctypes.c_char_p * len(usernames))()
-		for (i, username) in enumerate(usernames):
-			c_usernames[i] = core.cstr(username)
+		c_users = (core.BNCollaborationUserHandle * len(users))()
+		for (i, member) in enumerate(users):
+			c_users[i] = member._handle
 
-		value = core.BNRemoteCreateGroup(self._handle, name, c_usernames, len(usernames))
+		value = core.BNRemoteCreateGroup(self._handle, name, c_users, len(users))
 		if value is None:
 			raise RuntimeError(util._last_error())
 		return group.Group(value)

rust/src/collaboration/group.rs

@@ -56,46 +56,32 @@ impl RemoteGroup {
     }
 
     /// Get list of users in the group
-    pub fn users(&self) -> Result<(Array<BnString>, Array<BnString>), ()> {
-        let mut usernames = std::ptr::null_mut();
-        let mut user_ids = std::ptr::null_mut();
+    pub fn users(&self) -> Result<Array<RemoteUser>, ()> {
         let mut count = 0;
         // TODO: This should only fail if collaboration is not supported.
         // TODO: Because you should not have a RemoteGroup at that point we can ignore?
-        let success = unsafe {
-            BNCollaborationGroupGetUsers(
-                self.handle.as_ptr(),
-                &mut user_ids,
-                &mut usernames,
-                &mut count,
-            )
-        };
-        success
-            .then(|| unsafe {
-                let ids = Array::new(user_ids, count, ());
-                let users = Array::new(usernames, count, ());
-                (ids, users)
-            })
+        let result = unsafe { BNCollaborationGroupGetUsers(self.handle.as_ptr(), &mut count) };
+        (!result.is_null())
+            .then(|| unsafe { Array::new(result, count, ()) })
             .ok_or(())
     }
 
     // TODO: Are any permissions required to the set the remote group users?
-    /// Set the list of users in a group by their usernames.
+    /// Set the list of users in a group.
     /// You will need to push the group to update the Remote.
-    pub fn set_users<I>(&self, usernames: I) -> Result<(), ()>
+    pub fn set_users<I>(&self, users: I) -> Result<(), ()>
     where
-        I: IntoIterator<Item = String>,
+        I: IntoIterator<Item = Ref<RemoteUser>>,
     {
-        let usernames: Vec<_> = usernames.into_iter().map(|u| u.to_cstr()).collect();
-        let mut usernames_raw: Vec<_> = usernames.iter().map(|s| s.as_ptr()).collect();
+        let mut users_raw: Vec<_> = users.into_iter().map(|s| s.handle.as_ptr()).collect();
         // TODO: This should only fail if collaboration is not supported.
         // TODO: Because you should not have a RemoteGroup at that point we can ignore?
         // TODO: Do you need any permissions to do this?
         let success = unsafe {
-            BNCollaborationGroupSetUsernames(
+            BNCollaborationGroupSetUsers(
                 self.handle.as_ptr(),
-                usernames_raw.as_mut_ptr(),
-                usernames_raw.len(),
+                users_raw.as_mut_ptr(),
+                users_raw.len(),
             )
         };
         success.then_some(()).ok_or(())

rust/src/collaboration/remote.rs

@@ -515,21 +515,20 @@ impl Remote {
     /// # Arguments
     ///
     /// * `name` - Group name
-    /// * `usernames` - List of usernames of users in the group
-    pub fn create_group<I>(&self, name: &str, usernames: I) -> Result<Ref<RemoteGroup>, ()>
+    /// * `users` - List of users in the group
+    pub fn create_group<I>(&self, name: &str, users: I) -> Result<Ref<RemoteGroup>, ()>
     where
-        I: IntoIterator<Item = String>,
+        I: IntoIterator<Item = Ref<RemoteUser>>,
     {
         let name = name.to_cstr();
-        let usernames: Vec<_> = usernames.into_iter().map(|s| s.to_cstr()).collect();
-        let mut username_ptrs: Vec<_> = usernames.iter().map(|s| s.as_ptr()).collect();
+        let mut user_ptrs: Vec<_> = users.into_iter().map(|s| s.handle.as_ptr()).collect();
 
         let value = unsafe {
             BNRemoteCreateGroup(
                 self.handle.as_ptr(),
                 name.as_ptr(),
-                username_ptrs.as_mut_ptr(),
-                username_ptrs.len(),
+                user_ptrs.as_mut_ptr(),
+                user_ptrs.len(),
             )
         };
         NonNull::new(value)