feat: added ability to download files

sparse-05/sparse-05-server/src/connection/download_file.rs

@@ -1,7 +1,7 @@
 use std::{
     collections::HashMap,
     fs::{self, OpenOptions},
-    io::Write,
+    io::Read,
     path::PathBuf,
     sync::{
         atomic::{AtomicU64, Ordering},
@@ -38,50 +38,65 @@ pub(super) fn start_file_download<'a, 'b: 'a>(
         let mut file = OpenOptions::new().read(true).open(&file_path)?;
         let file_size = file.metadata()?.len();
 
-        conninfo.send(conninfo.encrypt_and_sign_resp(Response::StartDownloadFile(
-            id,
-            (file_size / FILE_TRANSFER_PACKET_SIZE as u64) + 1,
-        ))?)?;
+        let packet_count = (file_size / FILE_TRANSFER_PACKET_SIZE as u64) + 1;
+        conninfo
+            .send(conninfo.encrypt_and_sign_resp(Response::StartDownloadFile(id, packet_count))?)?;
 
         let mut current_packet_count = 0;
 
-        /*while current_packet_count < packet_count {
-            let mut buffers: Vec<Option<Vec<u8>>> = vec![None; FILE_BUFFER_BUFFER_SIZE];
+        loop {
+            let mut file_data: Vec<Vec<u8>> = Vec::with_capacity(FILE_BUFFER_BUFFER_SIZE);
+            let mut buffer = [0u8; FILE_TRANSFER_PACKET_SIZE];
+            let mut done = false;
+
+            for _ in 0..FILE_BUFFER_BUFFER_SIZE {
+                let amount = file.read(&mut buffer)?;
+
+                if amount == 0 {
+                    done = true;
+                    break;
+                }
+
+                file_data.push(buffer[..amount].to_vec());
+            }
+
+            for (i, buffer) in file_data.iter().enumerate() {
+                conninfo.send(
+                    conninfo.encrypt_and_sign_resp(Response::DownloadFileSegment(
+                        id,
+                        i as u64,
+                        buffer.clone(),
+                    ))?,
+                )?;
+            }
 
             loop {
-                let Ok((i, buffer)) = data_receiver.recv_timeout(Duration::from_millis(250)) else {
-                    let up_to = receive_request_status.recv()?;
+                std::thread::sleep(std::time::Duration::from_millis(1000));
 
-                    let needed = buffers[..up_to as usize]
-                        .iter()
-                        .enumerate()
-                        .flat_map(|(i, b)| match b {
-                            Some(..) => None,
-                            None => Some(i as u64),
-                        })
-                        .collect::<Vec<_>>();
+                conninfo.send(conninfo.encrypt_and_sign_resp(
+                    Response::GetDownloadFileStatus(id, file_data.len() as u64),
+                )?)?;
 
-                    let is_empty = needed.is_empty();
+                let buffers_needed: Vec<u64> = receive_download_status.recv()?;
 
-                    conninfo.send(
-                        conninfo.encrypt_and_sign_resp(Response::UploadFileStatus(id, needed))?,
-                    )?;
+                if buffers_needed.is_empty() {
+                    break;
+                }
 
-                    if is_empty {
-                        current_packet_count += up_to;
-                        break;
-                    } else {
-                        continue;
-                    }
-                };
-                buffers[i as usize] = Some(buffer);
+                for buffer_needed in &buffers_needed {
+                    let resp = Response::DownloadFileSegment(
+                        id,
+                        *buffer_needed,
+                        file_data[*buffer_needed as usize].clone(),
+                    );
+                    conninfo.send(conninfo.encrypt_and_sign_resp(resp)?)?;
+                }
             }
 
-            for buffer in buffers {
-                let Some(buffer) = buffer else { break };
-                target_file.write(&buffer)?;
+            if done {
+                break;
             }
-        }*/
+        }
 
         let Ok(mut lock) = download_file_map.lock() else {
             return Ok(());