Implement DataNotification for rust

[rbran]

No description provided.

[emesare]

The solution for only registering the notifications is fine with me, I will be able to review this more once testing is done for the upcoming 5.0 release. Thank you!

[emesare]

When constructing the data notification it is very important that we not copy/clone the BNBinaryDataNotification otherwise when we go to unregister the notifications we will be keying off a different object. I understand this is more of an issue with the FFI layer keying off something such as the pointer value but we should still support unregistering it. In the branch below I just wrap the BNBinaryDataNotification constructed in register_data_notification with a Box and move the boxed value into the returned DataNotificationHandle.

binaryninja-api/rust/src/data_notification.rs

Lines 92 to 103 in ddad753

	let handle = BNBinaryDataNotification {
	context: leak_notify as *mut _ as *mut c_void,
	$($ffi_param_name: triggers.$fun_name.then_some($fun_name::<H>)),*
	};
	// Box it to prevent a copy being returned in `DataNotificationHandle`.
	let mut boxed_handle = Box::new(handle);
	unsafe { BNRegisterDataNotification(view.handle, boxed_handle.as_mut()) };
	DataNotificationHandle {
	bv: view.to_owned(),
	handle: boxed_handle,
	_life: std::marker::PhantomData,
	}

[greaka]

If I understand your comment correctly, then you are doing a pointer equality check during deregister? In that case a Box is not enough, you need a Pin:

- let mut boxed_handle = Box::new(handle); 
+ let mut boxed_handle = Box::pin(handle); 

register_data_notification already introduced the lifetime 'a and binds both H and the output to it. Why do you want to require owning self too in this case? By changing the function signature to something more like the following, you could allow to still use the original struct instance outside of notifications.

    fn register_data_notification<'a, H: CustomDataNotification + 'a>(
        view: &BinaryView,
        notify: &'a H,
        triggers: DataNotificationTriggers,
    ) -> DataNotificationHandle<'a, H> {}

    fn register<'a>(
        &'a self,
        view: &BinaryView,
        triggers: DataNotificationTriggers,
    ) -> DataNotificationHandle<'a, Self> where Self: 'a + Sized {
        register_data_notification(view, self, triggers)
    }

if you require Pin:

    fn register_data_notification<'a, H: CustomDataNotification + 'a>(
        view: &BinaryView,
        notify: Pin<&'a H>,
        triggers: DataNotificationTriggers,
    ) -> DataNotificationHandle<'a, H> {}

    fn register<'a>(
        self: Pin<&'a Self>,
        view: &BinaryView,
        triggers: DataNotificationTriggers,
    ) -> DataNotificationHandle<'a, Self> where Self: 'a + Sized {
        register_data_notification(view, self, triggers)
    }

With a few extra lines you could then also support ?Sized implementers. You need to support saving the original fat pointer to make that work.

One alternative would be to add support for fetching the original Self via a getter on DataNotificationHandle, I'm not sold on that idea yet though.