fix: a lot of errors

Author: sofaspawn

.gitignore

@@ -1,2 +1,3 @@
 /target
 /.idea
+/files

Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "p2p-share-backend"
+name = "shellshare"
 version = "0.1.0"
 edition = "2024"
 

Cargo.toml

@@ -46,30 +46,35 @@ cd p2p-file-sharing
 cargo build --release
 ```
 
+**Download binary locally** 
+```bash
+cargo install --path .
+```  
+
 **Run the tracker**
 ```bash
-cargo run -- tracker --port 8080
+shellshare tracker --port 8080
 ```
 
 **Run a peer**
 ```bash
-cargo run -- peer --tracker 127.0.0.1:8080 --port 9001
+shellshare peer --tracker 127.0.0.1:8080 --port 9001
 ```
 
 **Commands**
 - Upload a file  
 ```bash
-cargo run -- peer --tracker 127.0.0.1:8080 --port 9001 upload <file_path>
+shellshare peer --tracker 127.0.0.1:8080 --port 9001 upload <file_path>
 ```  
 
 - Download a file  
 ```bash
-cargo run -- peer --tracker 127.0.0.1:8080 --port 9001 download <file_name>
+shellshare peer --tracker 127.0.0.1:8080 --port 9001 download <file_name>
 ```  
 
 - List available files  
 ```bash
-cargo run -- peer --tracker 127.0.0.1:8080 --port 9001 list
+shellshare peer --tracker 127.0.0.1:8080 --port 9001 list
 ```  
 
 <br>

README.md

@@ -1 +0,0 @@
-this is a test file

files/test.txt

@@ -6,11 +6,13 @@ use std::thread;
 use std::fs;
 use std::time::Duration;
 use clap::{Parser, Subcommand};
+use std::path::Path;
 
 use colored::*;
 
+/// CLI root
 #[derive(Parser)]
-#[command(name = "ShellShare")]
+#[command(name = "shellshare")]
 #[command(about = "CLI application to share files peer-to-peer", long_about = None)]
 struct Cli {
     #[command(subcommand)]
@@ -19,24 +21,37 @@ struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
+    /// Start the tracker
     Tracker {
         #[arg(short, long)]
         port: String,
     },
+
+    /// Start or interact with a peer
     Peer {
         #[arg(short, long)]
         port: String,
 
         #[arg(short, long)]
         tracker: String,
+
+        #[command(subcommand)]
+        action: Option<PeerAction>,
     },
-    Download {
-        #[arg(short, long)]
-        file: String,
+}
 
-        #[arg(short, long)]
-        tracker: String,
+#[derive(Subcommand)]
+enum PeerAction {
+    /// Upload a file to the network
+    Upload {
+        file_path: String,
     },
+    /// Download a file from the network
+    Download {
+        file_name: String,
+    },
+    /// List available files
+    List,
 }
 
 fn start_file_server(port: &str) {
@@ -55,10 +70,10 @@ fn start_file_server(port: &str) {
                         let path = format!("files/{}", filename);
                         match fs::read(&path) {
                             Ok(data) => {
-                                stream.write_all(&data).unwrap();
+                                let _ = stream.write_all(&data);
                             }
                             Err(_) => {
-                                stream.write_all(b"ERROR").unwrap();
+                                let _ = stream.write_all(b"ERROR");
                             }
                         }
                     }
@@ -69,9 +84,12 @@ fn start_file_server(port: &str) {
 }
 
 fn register_with_tracker(peer_addr: &str, tracker_addr: &str) {
-    let files = fs::read_dir("files").unwrap();
-    let mut file_list = Vec::new();
+    let files = fs::read_dir("files").unwrap_or_else(|_| {
+        fs::create_dir_all("files").unwrap();
+        fs::read_dir("files").unwrap()
+    });
 
+    let mut file_list = Vec::new();
     for entry in files {
         if let Ok(entry) = entry {
             if let Some(name) = entry.file_name().to_str() {
@@ -82,15 +100,39 @@ fn register_with_tracker(peer_addr: &str, tracker_addr: &str) {
 
     let msg = format!("REGISTER|{}|{}", peer_addr, file_list.join(","));
     if let Ok(mut stream) = TcpStream::connect(tracker_addr) {
-        stream.write_all(msg.as_bytes()).unwrap();
+        let _ = stream.write_all(msg.as_bytes());
         let mut buf = [0; 512];
-        stream.read(&mut buf).unwrap();
+        let _ = stream.read(&mut buf);
         println!("Registered with tracker");
     } else {
         println!("Failed to connect to tracker");
     }
 }
 
+fn list_files_from_tracker(tracker_addr: &str) {
+    let query = "LIST".to_string();
+
+    if let Ok(mut tracker_stream) = TcpStream::connect(tracker_addr) {
+        if tracker_stream.write_all(query.as_bytes()).is_err() {
+            println!("Failed to send LIST command to tracker.");
+            return;
+        }
+
+        let mut buf = [0; 4096];
+        let size = tracker_stream.read(&mut buf).unwrap_or(0);
+        let response = String::from_utf8_lossy(&buf[..size]);
+
+        if response.trim().is_empty() {
+            println!("No files available on the network.");
+        } else {
+            println!("Available files on network:\n{}", response);
+        }
+    } else {
+        println!("Failed to connect to tracker.");
+    }
+}
+
+
 fn query_tracker_and_download(filename: &str, tracker_addr: &str) {
     let query = format!("QUERY|{}", filename);
     if let Ok(mut tracker_stream) = TcpStream::connect(tracker_addr) {
@@ -119,6 +161,7 @@ fn query_tracker_and_download(filename: &str, tracker_addr: &str) {
                     continue;
                 }
 
+                fs::create_dir_all("downloads").unwrap();
                 fs::write(format!("downloads/{}", filename), &file_buf).unwrap();
                 println!("Downloaded {} from {}", filename, peer);
                 return;
@@ -129,18 +172,30 @@ fn query_tracker_and_download(filename: &str, tracker_addr: &str) {
     }
 }
 
+fn upload_file(file_path: &str, tracker_addr: &str, peer_addr: &str) {
+    let path = Path::new(file_path);
+    if !path.exists() {
+        println!("File {} does not exist!", file_path);
+        return;
+    }
+
+    fs::create_dir_all("files").unwrap();
+    let filename = path.file_name().unwrap().to_string_lossy().to_string();
+    let dest = format!("files/{}", filename);
+
+    if let Err(e) = fs::copy(file_path, &dest) {
+        println!("Failed to copy file: {}", e);
+        return;
+    }
+
+    println!("Uploaded {} to local peer storage.", filename);
+    register_with_tracker(peer_addr, tracker_addr);
+}
+
 fn print_ascii_logo() {
     match fs::read_to_string("logo-ascii.txt") {
         Ok(logo) => {
-            // Define a smoother gradient palette
-            let palette = [
-                "bright_red",
-                "red",
-                "magenta",
-                "bright_magenta",
-                "purple",
-            ];
-
+            let palette = ["bright_red", "red", "magenta", "bright_magenta", "purple"];
             for (i, line) in logo.lines().enumerate() {
                 let color = match i % palette.len() {
                     0 => line.bright_red(),
@@ -163,8 +218,6 @@ fn print_ascii_logo() {
     }
 }
 
-
-
 fn main() {
     print_ascii_logo();
     let cli = Cli::parse();
@@ -173,23 +226,37 @@ fn main() {
         Commands::Tracker { port } => {
             tracker::start_tracker(&port);
         }
-        Commands::Peer { port, tracker } => {
+        Commands::Peer { port, tracker, action } => {
             let peer_addr = format!("127.0.0.1:{}", port);
-            let port_clone = port.clone();
 
-            thread::spawn(move || {
-                start_file_server(&port_clone);
-            });
+            match action {
+                Some(PeerAction::List) => {
+                    list_files_from_tracker(&tracker);
+                }
+                Some(PeerAction::Download { file_name }) => {
+                    query_tracker_and_download(&file_name, &tracker);
+                }
+                Some(PeerAction::Upload { file_path }) => {
+                    upload_file(&file_path, &tracker, &peer_addr);
+                }
+                None => {
+                    let port_clone = port.clone();
+
+                    thread::spawn(move || {
+                        start_file_server(&port_clone);
+                    });
 
-            thread::sleep(Duration::from_millis(500));
-            register_with_tracker(&peer_addr, &tracker);
-            println!("Peer running. Listening on {} and connected to tracker {}", port, tracker);
-            loop {
-                thread::sleep(Duration::from_secs(60));
+                    thread::sleep(Duration::from_millis(500));
+                    register_with_tracker(&peer_addr, &tracker);
+                    println!(
+                        "Peer running. Listening on {} and connected to tracker {}",
+                        port, tracker
+                    );
+                    loop {
+                        thread::sleep(Duration::from_secs(60));
+                    }
+                }
             }
         }
-        Commands::Download { file, tracker } => {
-            query_tracker_and_download(&file, &tracker);
-        }
     }
 }