net: add app version to VerackMessage message for version protocol

src/net/message.rs

@@ -43,21 +43,12 @@ pub struct VersionMessage {
     pub node_id: String,
 }
 
-/// Requests app information of outbound connection.
-#[derive(SerialEncodable, SerialDecodable)]
-pub struct AppMessage {
-    pub version: String,
-}
-
-/// Sends app information to inbound connection. Response to AppMessage.
-#[derive(SerialEncodable, SerialDecodable)]
-pub struct AppAckMessage {
-    pub version: String,
-}
-
 /// Sends version information to inbound connection. Response to VersionMessage.
 #[derive(SerialEncodable, SerialDecodable)]
-pub struct VerackMessage {}
+pub struct VerackMessage {
+    // app version
+    pub app: String,
+}
 
 impl Message for PingMessage {
     fn name() -> &'static str {
@@ -89,18 +80,6 @@ impl Message for VersionMessage {
     }
 }
 
-impl Message for AppMessage {
-    fn name() -> &'static str {
-        "app"
-    }
-}
-
-impl Message for AppAckMessage {
-    fn name() -> &'static str {
-        "appack"
-    }
-}
-
 impl Message for VerackMessage {
     fn name() -> &'static str {
         "verack"

src/net/protocol/protocol_version.rs

@@ -47,17 +47,18 @@ impl ProtocolVersion {
         // Send version, wait for verack
         // Wait for version, send verack
         // Fin.
-        let result = match timeout(
+        let result = timeout(
             Duration::from_secs(self.settings.channel_handshake_seconds.into()),
             self.clone().exchange_versions(executor),
         )
-        .await
-        {
-            Ok(t) => t,
-            Err(_) => Err(Error::ChannelTimeout),
-        };
+        .await;
+
+        if let Err(_e) = result {
+            return Err(Error::ChannelTimeout)
+        }
+
         debug!(target: "net", "ProtocolVersion::run() [END]");
-        result
+        Ok(())
     }
     /// Send and recieve version information.
     async fn exchange_versions(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
@@ -72,30 +73,42 @@ impl ProtocolVersion {
         debug!(target: "net", "ProtocolVersion::exchange_versions() [END]");
         Ok(())
     }
-    /// Send version info and wait for version acknowledgement.
+    /// Send version info and wait for version acknowledgement
+    /// and insures the app version is the same
     async fn send_version(self: Arc<Self>) -> Result<()> {
         debug!(target: "net", "ProtocolVersion::send_version() [START]");
+
         let version = message::VersionMessage { node_id: self.settings.node_id.clone() };
+
         self.channel.clone().send(version).await?;
 
         // Wait for version acknowledgement
-        let _verack_msg = self.verack_sub.receive().await?;
+        let verack_msg = self.verack_sub.receive().await?;
+
+        let app_version = self.settings.app_version.clone();
+
+        if app_version != verack_msg.app {
+            error!(
+                "Wrong app version from [{:?}]. Disconnecting from channel.",
+                self.channel.address()
+            );
+            self.channel.stop().await;
+            return Err(Error::ChannelStopped)
+        }
 
         debug!(target: "net", "ProtocolVersion::send_version() [END]");
         Ok(())
     }
     /// Recieve version info, check the message is okay and send version
-    /// acknowledgement.
+    /// acknowledgement with app version attached.
     async fn recv_version(self: Arc<Self>) -> Result<()> {
         debug!(target: "net", "ProtocolVersion::recv_version() [START]");
         // Receive version message
         let version = self.version_sub.receive().await?;
         self.channel.set_remote_node_id(version.node_id.clone()).await;
 
-        // Check the message is OK
-
         // Send version acknowledgement
-        let verack = message::VerackMessage {};
+        let verack = message::VerackMessage { app: self.settings.app_version.clone() };
         self.channel.clone().send(verack).await?;
 
         debug!(target: "net", "ProtocolVersion::recv_version() [END]");

src/net/settings.rs

@@ -25,6 +25,7 @@ pub struct Settings {
     pub peers: Vec<Url>,
     pub seeds: Vec<Url>,
     pub node_id: String,
+    pub app_version: String,
     pub outbound_transports: Vec<TransportName>,
 }
 
@@ -43,6 +44,7 @@ impl Default for Settings {
             peers: Vec::new(),
             seeds: Vec::new(),
             node_id: String::new(),
+            app_version: String::new(),
             outbound_transports: get_outbound_transports(vec![]),
         }
     }
@@ -93,6 +95,10 @@ pub struct SettingsOpt {
     #[structopt(skip)]
     pub node_id: String,
 
+    #[serde(default)]
+    #[structopt(skip)]
+    pub app_version: String,
+
     /// Prefered transports for outbound connections
     #[serde(default)]
     #[structopt(long = "transports")]
@@ -114,6 +120,7 @@ impl From<SettingsOpt> for Settings {
             peers: settings_opt.peers,
             seeds: settings_opt.seeds,
             node_id: settings_opt.node_id,
+            app_version: settings_opt.app_version,
             outbound_transports: get_outbound_transports(settings_opt.outbound_transports),
         }
     }