docs: 📝 readme

README.md

@@ -1 +1,5 @@
-# rust-remote
+# Remote Code Execution Program
+
+I implemented this for my remote server. 
+
+Sometimes ssh can't be possible because of NAT. That's why I add a public remote server as a relay.

src/client.rs

@@ -90,7 +90,7 @@ async fn execute(payload: Payload, debug: bool) -> Option<Output> {
             if debug {
                 eprintln!("Error: Command Execution | {}", err_val);
             }
-            return None;
+            None
         }
     }
 }
@@ -145,6 +145,10 @@ async fn send(
         },
     };
 
+    if debug {
+        report.print();
+    }
+
     let report = serde_json::json!(report);
     let result = ws_sender.lock().await.send(report.to_string().into()).await;
     match result {

src/lib.rs

@@ -14,6 +14,7 @@ pub enum Runner {
 
 impl Runner {
     fn print(&self) {
+        println!("-------");
         match self {
             Runner::Server => println!("Runner = Server"),
             Runner::Client => println!("Runner = Client"),
@@ -44,6 +45,7 @@ pub struct Config {
 
 impl Config {
     pub fn print(&self) {
+        println!("-------");
         println!("IP = {}", self.ip);
         println!("Port = {}", self.port);
     }
@@ -51,15 +53,12 @@ impl Config {
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Payload {
-    pub sudo: bool,
-    pub user: String,
     pub args: String,
 }
 
 impl Payload {
     fn print(&self) {
-        println!("sudo = {}", self.sudo);
+        println!("-------");
-        println!("user = {}", self.user);
         println!("args = {}", self.args);
     }
 }
@@ -88,7 +87,6 @@ impl Report {
         }
         if !self.stderr.is_empty() {
             println!("Stderr ↓ \n{}", self.stderr);
-            println!("-------");
         }
     }
 }

src/main.rs

@@ -8,14 +8,9 @@ async fn main() {
 
     match args {
         Some((runner_mode, config)) => {
-            println!("-------");
-            println!("Runner Mode ↓");
             runner_mode.print();
-            println!("-------");
-            println!("Config ↓");
             config.print();
-            println!("-------");
+
-            
             match runner_mode {
                 RunnerMode::State(Runner::Server, false) => {
                     rust_remote::server::start(config, false).await

src/server.rs

@@ -31,15 +31,21 @@ pub async fn start(config: Config, debug: bool) {
                     match payload_from_input(debug).await {
                         Some(payload) => {
                             if !send(payload, ws_sender, debug).await {
+                                if debug {
+                                    eprintln!("Error: Send");
+                                }
                                 break;
                             }
                             tokio::spawn(async move {
-                                match receive(ws_receiver, debug).await {
+                                if let Some(report) = receive(ws_receiver, debug).await {
-                                    Some(report) => match serde_json::from_str::<Report>(&report) {
+                                    match serde_json::from_str::<Report>(&report) {
                                         Ok(report) => report.print(),
-                                        Err(_) => {}
+                                        Err(err_val) => {
-                                    },
+                                            if debug {
-                                    None => todo!(),
+                                                eprintln!("Error: Deserialize | {}", err_val);
+                                            }
+                                        }
+                                    }
                                 }
                             });
                         }
@@ -87,31 +93,9 @@ async fn establish_connection(
 }
 
 async fn payload_from_input(debug: bool) -> Option<Payload> {
-    println!("User");
+    println!("-------");
-    // let user = match get_input(debug) {
-    //     Some(input) => input,
-    //     None => return None,
-    // };
-    let user = "tahinli".to_string();
     println!("Command");
-    match get_input(debug) {
+    get_input(debug).map(|args| Payload { args })
-        Some(input) => {
-            let mut sudo = false;
-            let args = match input.split_once(" ") {
-                Some(input_splitted) => {
-                    if input_splitted.0 == "sudo" {
-                        sudo = true;
-                        input_splitted.1.to_string()
-                    } else {
-                        input
-                    }
-                }
-                None => input,
-            };
-            Some(Payload { sudo, user, args })
-        }
-        None => None,
-    }
 }
 
 fn get_input(debug: bool) -> Option<String> {

src/utils.rs

@@ -13,8 +13,8 @@ pub fn take_args() -> Option<(RunnerMode, Config)> {
             "--server" | "-sv" => runner = Runner::Server,
             "--client" | "-cl" => runner = Runner::Client,
             "--debug" | "-d" => debug = true,
-            "--ip" | "-i" => ip = args[i + 1].clone(),
+            "--ip" | "-i" => ip.clone_from(&args[i + 1]),
-            "--port" | "-p" => port = args[i + 1].clone(),
+            "--port" | "-p" => port.clone_from(&args[i + 1]),
             "--help" | "-h" => {
                 show_help();
                 std::process::exit(0);