fix: Added client/server version checking. Clients with mismatched versions are disconnected with a link to upgrade instructions.

Author: mikemiles-dev

Cargo.lock

@@ -5,7 +5,7 @@ members = [ "server", "client", "shared"]
 [workspace.package]
 description = "Rust Chat Application using Tokio over TCP"
 edition = "2024"
-version = "0.1.8"
+version = "0.1.9"
 authors = ["michael.mileusnich@gmail.com"]
 readme = "README.md"
 

Cargo.toml

@@ -25,6 +25,7 @@ A modern, colorful terminal-based chat application written in Rust with async/aw
 - 🚀 **Production Ready** - Docker and native systemd deployment options
 - 👮 **Admin Commands** - Server-side `/kick`, `/ban`, `/rename` and user management
 - 📝 **User Status** - Set a custom status message visible to other users
+- 🔢 **Version Compatibility** - Client/server version checking with upgrade notifications
 
 ## Architecture
 
@@ -604,6 +605,20 @@ The application implements comprehensive security measures to protect against co
 
 **Note**: For production deployment, TLS encryption is built-in. Consider adding authentication and E2E encryption for enhanced security.
 
+### Version Compatibility
+
+The client and server perform version checking on connection:
+- **Automatic Check**: Client sends its version to the server on connect
+- **Mismatch Handling**: If versions don't match, server disconnects client with an error
+- **Upgrade Instructions**: Error message includes a link to the GitHub README for upgrade instructions
+- **Compile-time Version**: Version is automatically derived from `Cargo.toml`
+
+Example version mismatch error:
+```
+[ERROR] Version mismatch: client v0.1.8 != server v0.1.9
+[ERROR] Please upgrade your binary or Docker image. See: https://github.com/mikemiles-dev/rust_chat#readme
+```
+
 ### Message Protocol
 
 Messages are sent over TCP with a custom chunked protocol that supports:
@@ -615,6 +630,7 @@ Messages are sent over TCP with a custom chunked protocol that supports:
 - User list requests
 - User status updates
 - File transfers
+- Version checking
 - Error messages
 
 ## Building from Source

README.md

@@ -1,3 +1,6 @@
+# 0.1.9
+ * Added client/server version checking. Clients with mismatched versions are disconnected with a link to upgrade instructions.
+
 # 0.1.8
  * Status now persists across reconnections but is cleared on explicit `/quit`, kick, or ban.
 

RELEASES.md

@@ -6,6 +6,7 @@ use shared::commands::client as commands;
 use shared::logger;
 use shared::message::{ChatMessage, ChatMessageError, MessageTypes};
 use shared::network::{MAX_FILE_SIZE, TcpMessageHandler};
+use shared::version::VERSION;
 use std::collections::HashSet;
 use std::io;
 use std::net::AddrParseError;
@@ -177,6 +178,15 @@ impl ChatClient {
     }
 
     pub async fn join_server(&mut self) -> Result<(), ChatClientError> {
+        // First send version check
+        logger::log_info(&format!("Sending version check (v{})...", VERSION));
+        let version_message = ChatMessage::try_new(
+            MessageTypes::VersionCheck,
+            Some(VERSION.as_bytes().to_vec()),
+        )?;
+        self.send_message_chunked(version_message).await?;
+
+        // Send join message with username
         let chat_message =
             ChatMessage::try_new(MessageTypes::Join, Some(self.chat_name.as_bytes().to_vec()))?;
         self.send_message_chunked(chat_message).await?;
@@ -366,6 +376,31 @@ impl ChatClient {
             MessageTypes::Pong => {
                 // Ignore pong messages (we don't send pings from client)
             }
+            MessageTypes::VersionMismatch => {
+                if let Some(content) = self.get_message_content(&message, "version mismatch") {
+                    let parts: Vec<&str> = content.split('|').collect();
+                    if parts.len() >= 3 {
+                        logger::log_error(&format!(
+                            "Version mismatch: client v{} != server v{}",
+                            parts[0], parts[1]
+                        ));
+                        logger::log_error(&format!(
+                            "Please upgrade your binary or Docker image. See: {}",
+                            parts[2]
+                        ));
+                    } else {
+                        logger::log_error(
+                            "Version mismatch with server. Please upgrade your client.",
+                        );
+                    }
+                    // Mark as kicked so we don't try to reconnect
+                    self.was_kicked = true;
+                    return false;
+                }
+            }
+            MessageTypes::VersionCheck => {
+                // Server shouldn't send this to client, ignore
+            }
             _ => {
                 logger::log_warning(&format!("Unknown message type: {:?}", message.msg_type));
             }

client/src/client.rs

@@ -10,6 +10,7 @@ pub enum UserConnectionError {
     JoinError,
     InvalidMessage,
     ExplicitQuit,
+    VersionMismatch,
 }
 
 impl std::fmt::Display for UserConnectionError {
@@ -20,6 +21,7 @@ impl std::fmt::Display for UserConnectionError {
             UserConnectionError::JoinError => write!(f, "Join Error: Username already taken"),
             UserConnectionError::InvalidMessage => write!(f, "Invalid Message Error"),
             UserConnectionError::ExplicitQuit => write!(f, "User explicitly quit"),
+            UserConnectionError::VersionMismatch => write!(f, "Client/Server version mismatch"),
         }
     }
 }

server/src/user_connection/error.rs

@@ -2,6 +2,7 @@ use rand::Rng;
 use shared::logger;
 use shared::message::{ChatMessage, MessageTypes};
 use shared::network::TcpMessageHandler;
+use shared::version::{self, VERSION};
 use std::collections::{HashMap, HashSet};
 use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
@@ -67,6 +68,10 @@ impl<'a> MessageHandlers<'a> {
         }
 
         match message.msg_type {
+            MessageTypes::VersionCheck => {
+                self.process_version_check(message.content_as_string(), &mut tcp_handler)
+                    .await?;
+            }
             MessageTypes::Join => {
                 self.process_join(message.content_as_string(), &mut tcp_handler, chat_name)
                     .await?;
@@ -610,6 +615,46 @@ impl<'a> MessageHandlers<'a> {
 
         Ok(())
     }
+
+    async fn process_version_check<S: AsyncRead + AsyncWrite + Unpin>(
+        &self,
+        client_version: Option<String>,
+        tcp_handler: &mut StreamWrapper<'_, S>,
+    ) -> Result<(), UserConnectionError> {
+        let client_version = client_version.ok_or(UserConnectionError::InvalidMessage)?;
+
+        if !version::versions_compatible(&client_version, VERSION) {
+            logger::log_warning(&format!(
+                "Version mismatch from {}: client v{} != server v{}",
+                self.addr, client_version, VERSION
+            ));
+
+            // Send version mismatch error with details
+            let mismatch_content = format!(
+                "{}|{}|{}",
+                client_version,
+                VERSION,
+                version::GITHUB_README_URL
+            );
+            let mismatch_msg = ChatMessage::try_new(
+                MessageTypes::VersionMismatch,
+                Some(mismatch_content.into_bytes()),
+            )
+            .map_err(|_| UserConnectionError::InvalidMessage)?;
+            tcp_handler
+                .send_message_chunked(mismatch_msg)
+                .await
+                .map_err(UserConnectionError::IoError)?;
+
+            return Err(UserConnectionError::VersionMismatch);
+        }
+
+        logger::log_info(&format!(
+            "Version check passed for {}: v{}",
+            self.addr, client_version
+        ));
+        Ok(())
+    }
 }
 
 #[cfg(test)]

server/src/user_connection/handlers.rs

@@ -173,6 +173,11 @@ impl UserConnection {
                                     self.clear_status_on_disconnect = true;
                                     break;
                                 }
+                                Err(UserConnectionError::VersionMismatch) => {
+                                    // Version mismatch - disconnect client (error already sent)
+                                    logger::log_warning(&format!("Client {} disconnected due to version mismatch", self.addr));
+                                    break;
+                                }
                                 Err(e) => {
                                     logger::log_error(&format!("Error handling message from {}: {:?}", self.addr, e));
                                 }

server/src/user_connection/mod.rs

@@ -1,7 +1,7 @@
 [package]
 name = "shared"
-version = "0.1.0"
-edition = "2024"
+version.workspace = true
+edition.workspace = true
 
 [dependencies]
 tokio.workspace = true

shared/Cargo.toml

@@ -3,3 +3,4 @@ pub mod input;
 pub mod logger;
 pub mod message;
 pub mod network;
+pub mod version;