refactor rust code

Author: AmyrAhmady

src-tauri/src/background_thread.rs

@@ -0,0 +1,84 @@
+use crate::{constants::*, errors::*, validation};
+use gumdrop::Options;
+use std::process::exit;
+
+#[derive(Debug, Options)]
+pub struct CliArgs {
+    #[options(no_short, help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "target server IP address")]
+    pub host: Option<String>,
+
+    #[options(help = "target server port")]
+    pub port: Option<i32>,
+
+    #[options(help = "target server password")]
+    pub password: Option<String>,
+
+    #[options(help = "nickname to join server with")]
+    pub name: Option<String>,
+
+    #[options(help = "game path to use for both game executable and samp.dll")]
+    pub gamepath: Option<String>,
+}
+
+impl CliArgs {
+    pub fn validate(&self) -> Result<()> {
+        if let Some(ref host) = self.host {
+            validation::validate_hostname(host)?;
+        }
+
+        if let Some(port) = self.port {
+            validation::validate_port(port)?;
+        }
+
+        if let Some(ref name) = self.name {
+            validation::validate_player_name(name)?;
+        }
+
+        if let Some(ref gamepath) = self.gamepath {
+            validation::validate_file_path(gamepath)?;
+            
+            let gta_exe = format!("{}/{}", gamepath, GTA_SA_EXECUTABLE);
+            if !std::path::Path::new(&gta_exe).exists() {
+                return Err(LauncherError::NotFound(
+                    format!("GTA San Andreas executable not found at: {}", gta_exe)
+                ));
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn print_help_and_exit(program_name: &str) -> ! {
+        // Using println! here is appropriate for CLI help output
+        println!(
+            "Open Multiplayer Launcher
+
+Usage: {} [OPTIONS]
+
+Options:
+      --help
+  -h, --host <HOST>          Server IP
+  -p, --port <PORT>          Server port
+  -P, --password <PASSWORD>  Server password
+  -n, --name <NAME>          Nickname
+  -g, --gamepath <GAMEPATH>  Game path
+            ",
+            program_name
+        );
+        exit(0)
+    }
+
+    pub fn has_game_launch_args(&self) -> bool {
+        self.host.is_some() && self.name.is_some() && self.port.is_some() && self.gamepath.is_some()
+    }
+
+    pub fn get_password(&self) -> String {
+        match &self.password {
+            Some(pwd) => validation::sanitize_password(pwd),
+            None => String::new(),
+        }
+    }
+}

src-tauri/src/cli.rs

@@ -1,4 +1,4 @@
-use crate::{background_thread::check_for_new_instance_and_close, injector, samp};
+use crate::{injector, samp};
 use log::info;
 
 #[tauri::command]
@@ -11,8 +11,10 @@ pub async fn inject(
     omp_file: &str,
     password: &str,
     discord: bool,
-) -> Result<(), String> {
-    injector::run_samp(name, ip, port, exe, dll, omp_file, password, discord).await
+) -> std::result::Result<(), String> {
+    injector::run_samp(name, ip, port, exe, dll, omp_file, password, discord)
+        .await
+        .map_err(|e| e.to_string())
 }
 
 #[tauri::command]
@@ -26,17 +28,19 @@ pub fn get_nickname_from_samp() -> String {
 }
 
 #[tauri::command]
-pub fn rerun_as_admin() -> Result<String, String> {
-    let res = std::env::current_exe();
-    match res {
-        Ok(p) => {
-            let path = p.into_os_string().into_string().unwrap();
-            runas::Command::new(path).arg("").status().unwrap();
-            check_for_new_instance_and_close();
-            Ok("SUCCESS".to_string())
-        }
-        Err(_) => Err("FAILED".to_string()),
-    }
+pub fn rerun_as_admin() -> std::result::Result<String, String> {
+    let exe_path = std::env::current_exe()
+        .map_err(|_| "Failed to get current executable path".to_string())?
+        .into_os_string()
+        .into_string()
+        .map_err(|_| "Failed to convert path to string".to_string())?;
+
+    runas::Command::new(exe_path)
+        .arg("")
+        .status()
+        .map_err(|_| "Failed to restart as administrator".to_string())?;
+
+    Ok("SUCCESS".to_string())
 }
 
 #[tauri::command]
@@ -45,21 +49,25 @@ pub fn get_samp_favorite_list() -> String {
 }
 
 #[tauri::command]
-pub fn resolve_hostname(hostname: String) -> Result<String, String> {
+pub fn resolve_hostname(hostname: String) -> std::result::Result<String, String> {
     use std::net::{IpAddr, ToSocketAddrs};
 
+    if hostname.is_empty() {
+        return Err("Hostname cannot be empty".to_string());
+    }
+
     let addr = format!("{}:80", hostname);
-    match addr.to_socket_addrs() {
-        Ok(addrs) => {
-            for ip in addrs {
-                if let IpAddr::V4(ipv4) = ip.ip() {
-                    return Ok(ipv4.to_string());
-                }
-            }
-            Err("No IPv4 address found".to_string())
+    let addrs = addr
+        .to_socket_addrs()
+        .map_err(|e| format!("Failed to resolve hostname '{}': {}", hostname, e))?;
+
+    for ip in addrs {
+        if let IpAddr::V4(ipv4) = ip.ip() {
+            return Ok(ipv4.to_string());
         }
-        Err(e) => Err(format!("Failed to resolve: {}", e)),
     }
+
+    Err(format!("No IPv4 address found for hostname '{}'", hostname))
 }
 
 #[tauri::command]
@@ -80,7 +88,5 @@ pub fn is_process_alive(pid: u32) -> bool {
 
 #[tauri::command]
 pub fn log(msg: &str) -> () {
-    info!("{}", msg);
-    println!("{}", msg);
+    info!("Frontend log: {}", msg);
 }
-

src-tauri/src/commands.rs

@@ -0,0 +1,55 @@
+pub const IPC_PORT: u16 = 45791;
+pub const RPC_PORT: u16 = 46290;
+
+pub const MAX_HOSTNAME_LENGTH: u32 = 63;
+pub const MAX_GAMEMODE_LENGTH: u32 = 39;
+pub const MAX_LANGUAGE_LENGTH: u32 = 39;
+pub const MAX_DISCORD_LINK_LENGTH: u32 = 50;
+pub const MAX_BANNER_URL_LENGTH: u32 = 160;
+pub const MAX_LOGO_URL_LENGTH: u32 = 160;
+
+pub const MAX_PLAYER_COUNT: u16 = 1000;
+pub const MAX_RULE_COUNT: u16 = 1000;
+
+pub const QUERY_TIMEOUT_SECS: u64 = 2;
+pub const OMP_EXTRA_INFO_UPDATE_COOLDOWN_SECS: u64 = 3;
+
+pub const INJECTION_MAX_RETRIES: u32 = 5;
+pub const INJECTION_RETRY_DELAY_MS: u64 = 500;
+
+pub const UDP_BUFFER_SIZE: usize = 1500;
+pub const PROCESS_MODULE_BUFFER_SIZE: usize = 1024;
+
+pub const SAMP_PACKET_HEADER: &[u8] = b"SAMP";
+
+pub const QUERY_TYPE_INFO: char = 'i';
+pub const QUERY_TYPE_PLAYERS: char = 'c';
+pub const QUERY_TYPE_RULES: char = 'r';
+pub const QUERY_TYPE_EXTRA_INFO: char = 'o';
+pub const QUERY_TYPE_PING: char = 'p';
+
+pub const PING_TIMEOUT: u32 = 9999;
+
+pub const LOG_FILE_NAME: &str = "omp-launcher.log";
+pub const DATA_DIR_NAME: &str = "mp.open.launcher";
+
+pub const GTA_SA_EXECUTABLE: &str = "gta_sa.exe";
+pub const SAMP_DLL: &str = "samp.dll";
+pub const OMP_CLIENT_DLL: &str = "omp-client.dll";
+
+pub const DEEPLINK_SCHEME_OMP: &str = "omp";
+pub const DEEPLINK_SCHEME_SAMP: &str = "samp";
+pub const DEEPLINK_IDENTIFIER: &str = "mp.open.launcher";
+
+pub const WINDOW_MIN_WIDTH: u32 = 1000;
+pub const WINDOW_MIN_HEIGHT: u32 = 700;
+
+#[cfg(target_os = "windows")]
+pub const SAMP_REGISTRY_KEY: &str = r"Software\SAMP";
+
+#[cfg(target_os = "windows")]
+pub const SAMP_USERDATA_PATH: &str = r"\GTA San Andreas User Files\SAMP\USERDATA.DAT";
+
+pub const ERROR_DIRECTORY_EXISTS: i32 = 183;
+pub const ERROR_ACCESS_DENIED: i32 = 5;
+pub const ERROR_ELEVATION_REQUIRED: i32 = 740;

src-tauri/src/constants.rs

@@ -0,0 +1,85 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum LauncherError {
+    Io(std::io::Error),
+    SerdeJson(serde_json::Error),
+    SystemTime(std::time::SystemTimeError),
+    Parse(String),
+    Network(String),
+    Process(String),
+    Injection(String),
+    Registry(String),
+    Storage(String),
+    InvalidInput(String),
+    NotFound(String),
+    AccessDenied(String),
+    InternalError(String),
+}
+
+impl fmt::Display for LauncherError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LauncherError::Io(err) => write!(f, "IO error: {}", err),
+            LauncherError::SerdeJson(err) => write!(f, "JSON error: {}", err),
+            LauncherError::SystemTime(err) => write!(f, "System time error: {}", err),
+            LauncherError::Parse(msg) => write!(f, "Parse error: {}", msg),
+            LauncherError::Network(msg) => write!(f, "Network error: {}", msg),
+            LauncherError::Process(msg) => write!(f, "Process error: {}", msg),
+            LauncherError::Injection(msg) => write!(f, "Injection error: {}", msg),
+            LauncherError::Registry(msg) => write!(f, "Registry error: {}", msg),
+            LauncherError::Storage(msg) => write!(f, "Storage error: {}", msg),
+            LauncherError::InvalidInput(msg) => write!(f, "Invalid input: {}", msg),
+            LauncherError::NotFound(msg) => write!(f, "Not found: {}", msg),
+            LauncherError::AccessDenied(msg) => write!(f, "Access denied - administrator privileges required: {}", msg),
+            LauncherError::InternalError(msg) => write!(f, "Internal error: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for LauncherError {}
+
+impl From<std::io::Error> for LauncherError {
+    fn from(err: std::io::Error) -> Self {
+        match err.raw_os_error() {
+            Some(5) => LauncherError::AccessDenied("Access denied".to_string()),
+            Some(740) => LauncherError::AccessDenied("Admin privileges required".to_string()),
+            _ => LauncherError::Io(err),
+        }
+    }
+}
+
+impl From<serde_json::Error> for LauncherError {
+    fn from(err: serde_json::Error) -> Self {
+        LauncherError::SerdeJson(err)
+    }
+}
+
+impl From<std::time::SystemTimeError> for LauncherError {
+    fn from(err: std::time::SystemTimeError) -> Self {
+        LauncherError::SystemTime(err)
+    }
+}
+
+impl From<String> for LauncherError {
+    fn from(msg: String) -> Self {
+        LauncherError::InternalError(msg)
+    }
+}
+
+impl From<LauncherError> for String {
+    fn from(err: LauncherError) -> Self {
+        match err {
+            LauncherError::AccessDenied(_) => "need_admin".to_string(),
+            _ => err.to_string(),
+        }
+    }
+}
+
+pub type Result<T> = std::result::Result<T, LauncherError>;
+
+impl From<LauncherError> for tauri::InvokeError {
+    fn from(err: LauncherError) -> Self {
+        tauri::InvokeError::from(err.to_string())
+    }
+}