feat(engine): Add feature flag for v4 spec

Have to explicitly turn it on since we're still in beta for the spec.

Author: qdot

crates/buttplug_server/src/server.rs

@@ -118,6 +118,10 @@ impl ButtplugServer {
     self.client_name.get().cloned()
   }
 
+  pub fn spec_version(&self) -> Option<ButtplugMessageSpecVersion> {
+    self.spec_version.get().cloned()
+  }
+
   /// Retreive an async stream of ButtplugServerMessages. This is how the server sends out
   /// non-query-related updates to the system, including information on devices being added/removed,
   /// client disconnection, etc...
@@ -215,6 +219,14 @@ impl ButtplugServer {
     let features = self.device_manager().feature_map();
     let msg_id = msg.id();
     trace!("Server received: {:?}", msg);
+    let v = msg.version();
+    let spec_version = *self.spec_version.get_or_init(|| {
+      info!(
+        "Setting Buttplug Server Message Spec version to {}",
+        v
+      );
+      v
+    });
     match msg {
       ButtplugClientMessageVariant::V4(msg) => {
         let internal_msg =
@@ -241,15 +253,7 @@ impl ButtplugServer {
         .boxed()
       }
       msg => {
-        let v = msg.version();
         let converter = ButtplugServerMessageConverter::new(Some(msg.clone()));
-        let spec_version = *self.spec_version.get_or_init(|| {
-          info!(
-            "Setting Buttplug Server Message Spec Downgrade version to {}",
-            v
-          );
-          v
-        });
         match ButtplugCheckedClientMessageV4::try_from_client_message(msg, &features) {
           Ok(converted_msg) => {
             trace!("Converted message: {:?}", converted_msg);

crates/intiface_engine/src/backdoor_server.rs

@@ -37,11 +37,12 @@ impl BackdoorServer {
     let (s_in, r_in) = mpsc::channel(255);
     let (s_stream, _) = broadcast::channel(255);
     tokio::spawn(async move {
+      // Backdoor server can always use latest spec.
       if let Err(e) = server
         .start(ButtplugRemoteServerConnector::<
           _,
           ButtplugServerJSONSerializer,
-        >::new(ButtplugStreamTransport::new(s_out, r_in)))
+        >::new(ButtplugStreamTransport::new(s_out, r_in)), true)
         .await
       {
         // We can't do much if the server fails, but we *can* yell into the logs!

crates/intiface_engine/src/bin/main.rs

@@ -168,6 +168,11 @@ pub struct IntifaceCLIArguments {
   #[argh(switch)]
   #[getset(get_copy = "pub")]
   crash_task_thread: bool,
+
+  /// allow usage of the beta v4 api spec
+  #[argh(switch)]
+  #[getset(get_copy = "pub")]
+  allow_v4_spec: bool,
 }
 
 pub fn setup_console_logging(log_level: Option<Level>) {
@@ -243,6 +248,7 @@ impl TryFrom<IntifaceCLIArguments> for EngineOptions {
       .use_device_websocket_server(args.use_device_websocket_server())
       .max_ping_time(args.max_ping_time())
       .server_name(args.server_name())
+      .allow_v4_spec(args.allow_v4_spec)
       .broadcast_server_mdns(args.broadcast_server_mdns());
 
     #[cfg(debug_assertions)]

crates/intiface_engine/src/buttplug_server.rs

@@ -161,7 +161,7 @@ pub async fn run_server(
           .port(port)
           .listen_on_all_interfaces(options.websocket_use_all_interfaces())
           .finish(),
-      ))
+      ), options.allow_v4_spec())
       .await
   } else if let Some(addr) = options.websocket_client_address() {
     server
@@ -170,7 +170,7 @@ pub async fn run_server(
         ButtplugServerJSONSerializer,
       >::new(
         ButtplugWebsocketClientTransport::new_insecure_connector(addr),
-      ))
+      ), options.allow_v4_spec())
       .await
   } else {
     panic!(

crates/intiface_engine/src/options.rs

@@ -56,6 +56,8 @@ pub struct EngineOptions {
   repeater_remote_address: Option<String>,
   #[getset(get_copy = "pub")]
   rest_api_port: Option<u16>,
+  #[getset(get_copy = "pub")]
+  allow_v4_spec: bool,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -87,6 +89,7 @@ pub struct EngineOptionsExternal {
   pub repeater_local_port: Option<u16>,
   pub repeater_remote_address: Option<String>,
   pub rest_api_port: Option<u16>,
+  pub allow_v4_spec: bool
 }
 
 impl From<EngineOptionsExternal> for EngineOptions {
@@ -119,6 +122,7 @@ impl From<EngineOptionsExternal> for EngineOptions {
       repeater_local_port: other.repeater_local_port,
       repeater_remote_address: other.repeater_remote_address,
       rest_api_port: other.rest_api_port,
+      allow_v4_spec: other.allow_v4_spec
     }
   }
 }
@@ -272,6 +276,11 @@ impl EngineOptionsBuilder {
     self
   }
 
+  pub fn allow_v4_spec(&mut self, allow: bool) -> &mut Self {
+    self.options.allow_v4_spec = allow;
+    self
+  }
+
   pub fn finish(&mut self) -> EngineOptions {
     self.options.clone()
   }

crates/intiface_engine/src/remote_server.rs

@@ -7,8 +7,8 @@
 
 use buttplug_core::{
   connector::ButtplugConnector,
-  errors::ButtplugError,
-  message::ButtplugServerMessageV4,
+  errors::{ButtplugError, ButtplugHandshakeError, ButtplugMessageError},
+  message::{ButtplugMessageSpecVersion, ButtplugServerMessageV4},
   util::{async_manager, stream::convert_broadcast_receiver_to_stream},
 };
 use buttplug_server::{
@@ -123,6 +123,7 @@ async fn run_server<ConnectorType>(
   connector: ConnectorType,
   mut connector_receiver: mpsc::Receiver<ButtplugClientMessageVariant>,
   disconnect_notifier: Arc<Notify>,
+  allow_v4_spec: bool
 ) where
   ConnectorType:
     ButtplugConnector<ButtplugServerMessageVariant, ButtplugClientMessageVariant> + 'static,
@@ -149,15 +150,26 @@ async fn run_server<ConnectorType>(
           let connected = server_clone.connected();
           let connector_clone = shared_connector.clone();
           let remote_event_sender_clone = remote_event_sender.clone();
+          let disconnect_notifier = disconnect_notifier.clone();
           async_manager::spawn(async move {
             match server_clone.parse_message(client_message.clone()).await {
               Ok(ret_msg) => {
                 // Only send event if we just connected. Sucks to check it on every message but the boolean check should be quick.
-                if !connected && server_clone.connected()
-                  && remote_event_sender_clone.receiver_count() > 0
+                if !connected && server_clone.connected() {
+                  // Check to see what message version was requested. If we're not allowing v4, kill the connection.
+                  info!("CHECKING SPEC: {} {:?}", allow_v4_spec, server_clone.spec_version());
+                  if !allow_v4_spec && server_clone.spec_version() == Some(ButtplugMessageSpecVersion::Version4) {
+                    error!("Cannot connect v4 client with this server (Allow v4 spec is off).");
+                    connector_clone.send(ButtplugServerMessageVariant::V4(ButtplugServerMessageV4::Error(ButtplugError::from(ButtplugHandshakeError::UnhandledMessageSpecVersionRequested(ButtplugMessageSpecVersion::Version4)).into()))).await;
+                    disconnect_notifier.notify_waiters();
+                    return;
+                  }
+
+                  if remote_event_sender_clone.receiver_count() > 0
                     && remote_event_sender_clone.send(ButtplugRemoteServerEvent::ClientConnected(server_clone.client_name().unwrap_or("Buttplug Client (No name specified)".to_owned()).clone())).is_err() {
                       error!("Cannot send event to owner, dropping and assuming local server thread has exited.");
-                    }
+                  }
+                }
                 if connector_clone.send(ret_msg).await.is_err() {
                   error!("Cannot send reply to server, dropping and assuming remote server thread has exited.");
                 }
@@ -273,6 +285,7 @@ impl ButtplugRemoteServer {
   pub fn start<ConnectorType>(
     &self,
     mut connector: ConnectorType,
+    allow_v4_spec: bool
   ) -> impl Future<Output = Result<(), ButtplugServerConnectorError>> + use<ConnectorType>
   where
     ConnectorType:
@@ -296,6 +309,7 @@ impl ButtplugRemoteServer {
         connector,
         connector_receiver,
         disconnect_notifier,
+        allow_v4_spec
       )
       .await;
       Ok(())