Complete first release candidate audit (#107)

crates/libremetaverse-voice-vivox/src/callbacks.rs

@@ -0,0 +1,206 @@
+//! Safe native replacements for the CLR delegate types in the Vivox API.
+
+use crate::Error;
+use libremetaverse_types::compat::{Object, SocketException};
+use std::any::Any;
+use std::fmt;
+use std::sync::Arc;
+
+type AsyncCallback = Box<dyn Fn(&dyn Any) + Send + Sync>;
+type AsyncResult = Box<dyn Any + Send + Sync>;
+
+macro_rules! callback_type {
+    ($name:ident ( $($argument:ident : $type:ty),* $(,)? )) => {
+        #[derive(Clone)]
+        pub struct $name {
+            handler: Arc<dyn Fn($($type),*) -> Result<(), Error> + Send + Sync>,
+        }
+
+        impl fmt::Debug for $name {
+            fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter
+                    .debug_struct(stringify!($name))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        impl $name {
+            /// Creates a native callback without exposing CLR method pointers.
+            pub fn from_handler<F>(handler: F) -> Self
+            where
+                F: Fn($($type),*) -> Result<(), Error> + Send + Sync + 'static,
+            {
+                Self { handler: Arc::new(handler) }
+            }
+
+            /// Rehydrates a callback previously stored in a mapped `Object`.
+            /// A non-zero CLR method pointer cannot be invoked safely in native
+            /// Rust and is therefore rejected explicitly.
+            pub fn new(object: Object, method: isize) -> Result<Self, Error> {
+                if method != 0 {
+                    return Err(Error::Argument);
+                }
+                object.downcast_ref::<Self>().cloned().ok_or(Error::Argument)
+            }
+
+            pub fn invoke(&self, $($argument: $type),*) -> Result<(), Error> {
+                (self.handler)($($argument),*)
+            }
+
+            pub fn begin_invoke(
+                &self,
+                $($argument: $type,)*
+                callback: AsyncCallback,
+                object: Object,
+            ) -> Result<AsyncResult, Error> {
+                self.invoke($($argument),*)?;
+                callback(&object);
+                Ok(Box::new(()))
+            }
+
+            pub fn end_invoke(&self, result: AsyncResult) -> Result<(), Error> {
+                result.downcast::<()>().map(|_| ()).map_err(|_| Error::Argument)
+            }
+        }
+    };
+}
+
+callback_type!(TCPPipeOnDisconnectedCallback(se: SocketException));
+callback_type!(TCPPipeOnReceiveLineCallback(line: String));
+callback_type!(VoiceGatewayDaemonConnectedCallback());
+callback_type!(VoiceGatewayDaemonCouldntConnectCallback());
+callback_type!(VoiceGatewayDaemonCouldntRunCallback());
+callback_type!(VoiceGatewayDaemonDisconnectedCallback());
+callback_type!(VoiceGatewayDaemonExitedCallback());
+callback_type!(VoiceGatewayDaemonRunningCallback());
+callback_type!(VoiceGatewayVoiceConnectionChangeCallback(
+    state: crate::VoiceGatewayConnectionState,
+));
+callback_type!(VoiceGatewayVoiceMicTestCallback(level: f32));
+callback_type!(VoiceManagerAuxAudioPropertiesCallback(cookie: i32, energy: f32));
+callback_type!(VoiceManagerBasicActionCallback(
+    cookie: i32,
+    status_code: i32,
+    status_string: String,
+));
+callback_type!(VoiceManagerConnectorCreatedCallback(
+    cookie: i32,
+    status_code: i32,
+    status_string: String,
+    connector_handle: String,
+));
+callback_type!(VoiceManagerDevicesCallback(
+    cookie: i32,
+    status_code: i32,
+    status_string: String,
+    current_device: String,
+));
+callback_type!(VoiceManagerLoginCallback(
+    cookie: i32,
+    status_code: i32,
+    status_string: String,
+    account_handle: String,
+));
+callback_type!(VoiceManagerLoginStateChangeCallback(
+    cookie: i32,
+    account_handle: String,
+    status_code: i32,
+    status_string: String,
+    state: i32,
+));
+callback_type!(VoiceManagerNewSessionCallback(
+    cookie: i32,
+    account_handle: String,
+    event_session_handle: String,
+    state: i32,
+    name_string: String,
+    uri_string: String,
+));
+callback_type!(VoiceManagerParcelVoiceInfoCallback(
+    region_name: String,
+    local_id: i32,
+    channel_uri: Option<String>,
+));
+callback_type!(VoiceManagerParticipantPropertiesCallback(
+    cookie: i32,
+    uri_string: String,
+    status_code: i32,
+    status_string: String,
+    is_locally_muted: bool,
+    is_moderator_muted: bool,
+    is_speaking: bool,
+    volume: i32,
+    energy: f32,
+));
+callback_type!(VoiceManagerParticipantStateChangeCallback(
+    cookie: i32,
+    uri_string: String,
+    status_code: i32,
+    status_string: String,
+    state: i32,
+    name_string: String,
+    display_name_string: String,
+    participant_type: i32,
+));
+callback_type!(VoiceManagerProvisionAccountCallback(
+    username: String,
+    password: String,
+));
+callback_type!(VoiceManagerSessionCreatedCallback(
+    cookie: i32,
+    status_code: i32,
+    status_string: String,
+    session_handle: String,
+));
+callback_type!(VoiceManagerSessionStateChangeCallback(
+    cookie: i32,
+    uri_string: String,
+    status_code: i32,
+    status_string: String,
+    event_session_handle: String,
+    state: i32,
+    is_channel: bool,
+    name_string: String,
+));
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicI32, Ordering};
+
+    #[test]
+    fn callback_invocation_and_apm_completion_execute_once() {
+        let total = Arc::new(AtomicI32::new(0));
+        let observed = Arc::clone(&total);
+        let callback =
+            VoiceManagerAuxAudioPropertiesCallback::from_handler(move |cookie, energy| {
+                observed.fetch_add(cookie + energy as i32, Ordering::SeqCst);
+                Ok(())
+            });
+        callback.invoke(2, 3.0).unwrap();
+        let completion_count = Arc::new(AtomicI32::new(0));
+        let completed = Arc::clone(&completion_count);
+        let result = callback
+            .begin_invoke(
+                4,
+                5.0,
+                Box::new(move |_| {
+                    completed.fetch_add(1, Ordering::SeqCst);
+                }),
+                Object::Undefined,
+            )
+            .unwrap();
+        callback.end_invoke(result).unwrap();
+        assert_eq!(total.load(Ordering::SeqCst), 14);
+        assert_eq!(completion_count.load(Ordering::SeqCst), 1);
+    }
+
+    #[test]
+    fn callback_round_trips_through_mapped_object_without_raw_pointer() {
+        let callback = TCPPipeOnReceiveLineCallback::from_handler(|_| Ok(()));
+        let restored = TCPPipeOnReceiveLineCallback::new(Object::opaque(callback), 0).unwrap();
+        restored.invoke("line".into()).unwrap();
+        assert!(TCPPipeOnReceiveLineCallback::new(Object::Undefined, 0).is_err());
+        assert!(TCPPipeOnReceiveLineCallback::new(Object::Undefined, 1).is_err());
+    }
+}