From 5de07db02a02933caf280a90cc599993300be0c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Sun, 8 Oct 2023 01:52:42 +0300 Subject: [PATCH 01/11] I do not know --- src/main.rs | 115 ++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 84 insertions(+), 31 deletions(-) diff --git a/src/main.rs b/src/main.rs index 25631b8..d4fbe2c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,20 +1,22 @@ use std::fs::{File, Metadata, self}; use std::time::Instant; use std::net::{TcpListener, TcpStream}; -use std::io::{Read, Write, self}; +use std::io::{Read, Write, self, BufReader}; use std::env::{self}; struct FileInfo { file:Option, + reader:Option>, location:String, - bytes:Vec, - size:usize, + bytes_current:Vec, + size_current:usize, + size_total:Option, metadata:Option, } impl FileInfo { - fn reading_operations(&mut self) + fn reading_operations(&mut self, stream:&mut TcpStream) { self.read_metadata(); match self.metadata @@ -23,10 +25,12 @@ impl FileInfo { if Metadata::is_file(metadata) { + self.size_total = Some(Metadata::len(&metadata) as usize); self.read_file(); } else if Metadata::is_symlink(metadata) { + self.size_total = Some(Metadata::len(&metadata) as usize); self.read_file(); } else @@ -38,48 +42,104 @@ impl FileInfo } None => { - + println!("Error: Read Metadata -> {}", self.location); + } + } + match self.size_total + { + Some(ref mut size_total) => + { + + self.file_to_byte(stream) + } + None => + { + println!("Error: Read Size -> {}", self.location); } } - - self.file_to_byte(); } - fn writing_operations(&mut self) + fn writing_operations(&mut self, stream:&mut TcpStream) { self.write_file(); } fn read_metadata(&mut self) { + //use match, there is a chance to fail creation. don't pass with just some self.metadata = Some(fs::metadata(&self.location).expect("Error: Read Metadata")); } fn read_file(&mut self) { - self.file = Some(File::open(&self.location).expect("Error: Open File")); + match File::open(&self.location) + { + Ok(file) => + { + self.file = Some(file); + self.reader = Some(BufReader::new(file)); + } + Err(err_val) => + { + println!("Error: Open File -> {} | Error: {}", self.location, err_val); + } + } + } - fn file_to_byte(&mut self) + fn file_to_byte(&mut self, stream:&mut TcpStream) { + self.bytes_current.clear(); match self.file { Some(ref mut file_descriptor) => { - match File::read_to_end(file_descriptor, &mut self.bytes) + //replace with readbuffer ? + match self.reader { - Ok(size) => + Some(reader) => { - self.size = size; - println!("Done: Read -> {} bytes", size); + // I don't know what to do } - Err(err_val) => println!("Error: Read {}", err_val), + None => + { + + } + } + match File::read_exact(file_descriptor, &mut self.bytes_current) + { + Ok(_) => + { + self.size_current = self.size_current+self.bytes_current.len(); + //need to send data, or call here from connection + match stream.write_all(&self.bytes_current) + { + Ok(_) => + { + // We will track when we stop later + } + Err(err_val) => + { + println!("Error: Send -> {} | Error: {}", self.location, err_val) + } + } + if self.size_total == Some(self.size_current) + { + println!("Done: Read -> {} | Done: Read -> {} bytes", self.location, self.size_current); + } + else + { + self.file_to_byte(stream); + } + } + Err(err_val) => println!("Error: Read -> {} | Error: {}", self.location, err_val), } } None => { - println!("Error: File None"); + println!("Error: File None -> {}", self.location); } } } fn write_file(&mut self) { + //use match, there is a chance to fail creation. don't pass with just some self.file = Some(File::create(&self.location).expect("Error: Create File")); match self.file { @@ -89,7 +149,7 @@ impl FileInfo { Ok(_) => { - self.size = self.bytes.len(); + self.size_total = self.bytes.len(); println!("Done: Write -> {} bytes", &mut self.size); } Err(err_val) => println!("Error: Write {}", err_val), @@ -148,11 +208,8 @@ impl Connection return; } file_info.bytes = data; - let start_disk_time = Instant::now(); - println!("Passed: Network -> {:#?}", start_disk_time.duration_since(start_time)); - FileInfo::writing_operations(file_info); + FileInfo::writing_operations(file_info, &mut stream); let finish_time = Instant::now(); - println!("Passed: Write -> {:#?}", finish_time.duration_since(start_disk_time)); println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time)); } Err(e) => @@ -190,16 +247,12 @@ impl Connection } match TcpStream::connect(address) { - Ok(mut socket) => + Ok(mut stream) => { let start_time = Instant::now(); println!("Connected"); - FileInfo::reading_operations(file_info); - let start_network_time = Instant::now(); - println!("Passed: Read -> {:#?}", start_network_time.duration_since(start_time)); - socket.write_all(&file_info.bytes).unwrap(); + FileInfo::reading_operations(file_info, &mut stream); let finish_time = Instant::now(); - println!("Passed: Network -> {:#?}", finish_time.duration_since(start_network_time)); println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time)); } Err(e) => @@ -231,14 +284,14 @@ fn main() //First we should check folder structure and validation then make connection. println!("Hello, world!"); - let bytes:Vec = vec![]; - let size:usize = 0 as usize; let mut data = FileInfo { file:None, + reader:None, location:take_arg(), - bytes:bytes, - size:size, + bytes_current:Vec::with_capacity(1024), + size_current:0 as usize, + size_total:None, metadata:None, }; match &take_string("Input: Server 's', Client 'c'".to_string())[0..1] From 1e2e49935206f7abc5c31173a3abd93d68e80f33 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Sun, 8 Oct 2023 15:18:37 +0300 Subject: [PATCH 02/11] feat: sender_ram_limitation_removed --- src/main.rs | 149 +++++++++++++++++++++++----------------------------- 1 file changed, 65 insertions(+), 84 deletions(-) diff --git a/src/main.rs b/src/main.rs index d4fbe2c..99aaab7 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,17 +1,17 @@ use std::fs::{File, Metadata, self}; use std::time::Instant; use std::net::{TcpListener, TcpStream}; -use std::io::{Read, Write, self, BufReader}; +use std::io::{Read, Write, self}; use std::env::{self}; + +const BUFFER_SIZE:usize = 1024; + struct FileInfo { file:Option, - reader:Option>, location:String, - bytes_current:Vec, size_current:usize, - size_total:Option, metadata:Option, } impl FileInfo @@ -25,13 +25,13 @@ impl FileInfo { if Metadata::is_file(metadata) { - self.size_total = Some(Metadata::len(&metadata) as usize); self.read_file(); + self.file_to_byte(stream); } else if Metadata::is_symlink(metadata) { - self.size_total = Some(Metadata::len(&metadata) as usize); self.read_file(); + self.file_to_byte(stream); } else { @@ -45,22 +45,10 @@ impl FileInfo println!("Error: Read Metadata -> {}", self.location); } } - match self.size_total - { - Some(ref mut size_total) => - { - - self.file_to_byte(stream) - } - None => - { - println!("Error: Read Size -> {}", self.location); - } - } } fn writing_operations(&mut self, stream:&mut TcpStream) { - self.write_file(); + self.write_file(stream); } fn read_metadata(&mut self) { @@ -74,7 +62,6 @@ impl FileInfo Ok(file) => { self.file = Some(file); - self.reader = Some(BufReader::new(file)); } Err(err_val) => { @@ -85,75 +72,89 @@ impl FileInfo } fn file_to_byte(&mut self, stream:&mut TcpStream) { - self.bytes_current.clear(); - match self.file + + //replace with readbuffer ? + let mut iteration = (self.metadata.as_ref().unwrap().len()/BUFFER_SIZE as u64)+1; + while iteration != 0 { - Some(ref mut file_descriptor) => + iteration -= 1; + let mut buffer = [0u8;BUFFER_SIZE]; + match self.file.as_ref().as_mut().unwrap().read(&mut buffer) { - //replace with readbuffer ? - match self.reader + Ok(read_size) => { - Some(reader) => + self.size_current += read_size; + if iteration != 0 { - // I don't know what to do - } - None => - { - - } - } - match File::read_exact(file_descriptor, &mut self.bytes_current) - { - Ok(_) => - { - self.size_current = self.size_current+self.bytes_current.len(); - //need to send data, or call here from connection - match stream.write_all(&self.bytes_current) + match stream.write_all(&mut buffer) { Ok(_) => { - // We will track when we stop later + println!("Done: Send Bytes -> {}", self.location); } Err(err_val) => { - println!("Error: Send -> {} | Error: {}", self.location, err_val) + println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); } } - if self.size_total == Some(self.size_current) + } + else + { + println!("Son"); + let mut last_buffer:Vec = (&buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64)as usize]).to_vec(); + println!("VEC = {:#?}", last_buffer); + match stream.write_all(&mut last_buffer) { - println!("Done: Read -> {} | Done: Read -> {} bytes", self.location, self.size_current); - } - else - { - self.file_to_byte(stream); + Ok(_) => + { + println!("Done: Send Last Bytes -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Send Last Bytes -> {} | Error: {}", self.location, err_val); + } } } - Err(err_val) => println!("Error: Read -> {} | Error: {}", self.location, err_val), + + } + Err(err_val) => + { + println!("Error: File to Byte -> {} | Error: {}", self.location, err_val); } } - None => - { - println!("Error: File None -> {}", self.location); - } + + } } - fn write_file(&mut self) + fn write_file(&mut self, stream:&mut TcpStream) { + //use match, there is a chance to fail creation. don't pass with just some self.file = Some(File::create(&self.location).expect("Error: Create File")); match self.file { Some(ref mut file_descriptor) => { - match File::write_all(file_descriptor, &mut self.bytes) + let mut buffer: Vec = Vec::new(); + match stream.read_to_end(&mut buffer) { Ok(_) => { - self.size_total = self.bytes.len(); - println!("Done: Write -> {} bytes", &mut self.size); + match File::write_all(file_descriptor, &mut buffer) + { + Ok(_) => + { + self.size_current += buffer.len(); + println!("Done: Write -> {} bytes", &mut self.size_current); + } + Err(err_val) => println!("Error: Write {}", err_val), + } } - Err(err_val) => println!("Error: Write {}", err_val), - } + Err(err_val) => + { + println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); + } + } } None => { @@ -193,31 +194,14 @@ impl Connection { Ok(mut stream) => { - let stay = true; + let mut stay = true; while stay { - let mut data = vec![]; let start_time = Instant::now(); - match stream.read_to_end(&mut data) - { - Ok(res) => - { - if res == 0 - { - println!("Connection Closed"); - return; - } - file_info.bytes = data; - FileInfo::writing_operations(file_info, &mut stream); - let finish_time = Instant::now(); - println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time)); - } - Err(e) => - { - println!("Error: Failed to Read -> {}", e); - return; - } - } + FileInfo::writing_operations(file_info, &mut stream); + let finish_time = Instant::now(); + println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time)); + stay = false; } } Err(e) => @@ -287,11 +271,8 @@ fn main() let mut data = FileInfo { file:None, - reader:None, location:take_arg(), - bytes_current:Vec::with_capacity(1024), size_current:0 as usize, - size_total:None, metadata:None, }; match &take_string("Input: Server 's', Client 'c'".to_string())[0..1] From 4a6f1bec74ce1e4993f33d87109b3f148e34f2a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Mon, 9 Oct 2023 01:51:15 +0300 Subject: [PATCH 03/11] need_parser_or_smthng_to_send_file_size_correctly --- src/main.rs | 106 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 85 insertions(+), 21 deletions(-) diff --git a/src/main.rs b/src/main.rs index 99aaab7..07bd15d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,7 +5,7 @@ use std::io::{Read, Write, self}; use std::env::{self}; -const BUFFER_SIZE:usize = 1024; +const BUFFER_SIZE:usize = 100000; struct FileInfo { @@ -72,9 +72,32 @@ impl FileInfo } fn file_to_byte(&mut self, stream:&mut TcpStream) { - //replace with readbuffer ? let mut iteration = (self.metadata.as_ref().unwrap().len()/BUFFER_SIZE as u64)+1; + let mut handshake = [0u8;BUFFER_SIZE]; + handshake[..self.metadata.as_ref().unwrap().len().to_string().as_bytes().len()].copy_from_slice(self.metadata.as_ref().unwrap().len().to_string().as_bytes()); + match stream.write_all(&mut handshake) + { + Ok(_) => + { + let mut handshake_callback = [0u8;BUFFER_SIZE]; + match stream.read_exact(&mut handshake_callback) + { + Ok(_) => + { + println!("Done: Handshake -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); + } + } + } + Err(err_val) => + { + println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); + } + } while iteration != 0 { iteration -= 1; @@ -90,19 +113,29 @@ impl FileInfo { Ok(_) => { - println!("Done: Send Bytes -> {}", self.location); + println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); } Err(err_val) => { println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); + return; + } + } + match stream.flush() + { + Ok(_) => + { + println!("Done: Flush -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush -> {} | Error: {}", self.location, err_val); } } } else - { - println!("Son"); - let mut last_buffer:Vec = (&buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64)as usize]).to_vec(); - println!("VEC = {:#?}", last_buffer); + { + let mut last_buffer:Vec = (&buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64)as usize]).to_vec(); match stream.write_all(&mut last_buffer) { Ok(_) => @@ -128,33 +161,64 @@ impl FileInfo } fn write_file(&mut self, stream:&mut TcpStream) { - //use match, there is a chance to fail creation. don't pass with just some self.file = Some(File::create(&self.location).expect("Error: Create File")); match self.file { Some(ref mut file_descriptor) => { - let mut buffer: Vec = Vec::new(); - match stream.read_to_end(&mut buffer) + let mut handshake = [0u8;BUFFER_SIZE]; + let mut size:u64 = 0; + match stream.read_exact(&mut handshake) { Ok(_) => { - match File::write_all(file_descriptor, &mut buffer) - { - Ok(_) => - { - self.size_current += buffer.len(); - println!("Done: Write -> {} bytes", &mut self.size_current); - } - Err(err_val) => println!("Error: Write {}", err_val), - } + todo!(); + size = String::from_utf8(handshake.to_vec()).unwrap().parse().unwrap(); + println!("Done: Handshake Recv -> {}", self.location); + match stream.write_all(&mut handshake) + { + Ok(_) => + { + println!("Done: Handshake Send -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); + } + } } Err(err_val) => { - println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); + println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); } - } + } + let mut iteration:u64 = (size%BUFFER_SIZE as u64)+1; + while iteration != 0 + { + iteration -= 1; + //let mut buffer: Vec = Vec::new(); + let mut buffer = [0u8;BUFFER_SIZE]; + match stream.read(&mut buffer) + { + Ok(_) => + { + match File::write_all(file_descriptor, &mut buffer) + { + Ok(_) => + { + self.size_current += buffer.len(); + println!("Done: Write -> {} bytes", &mut self.size_current); + } + Err(err_val) => println!("Error: Write {}", err_val), + } + } + Err(err_val) => + { + println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); + } + } + } } None => { From beb13c37033b759e0ab3ab072469faf9ef2d1810 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Tue, 10 Oct 2023 02:13:26 +0300 Subject: [PATCH 04/11] buf_reader_and_writer --- src/main.rs | 144 ++++++++++++++++++++++++++++------------------------ 1 file changed, 78 insertions(+), 66 deletions(-) diff --git a/src/main.rs b/src/main.rs index 07bd15d..649a692 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,7 @@ use std::fs::{File, Metadata, self}; use std::time::Instant; use std::net::{TcpListener, TcpStream}; -use std::io::{Read, Write, self}; +use std::io::{Read, Write, self, BufWriter, BufReader, BufRead}; use std::env::{self}; @@ -76,12 +76,25 @@ impl FileInfo let mut iteration = (self.metadata.as_ref().unwrap().len()/BUFFER_SIZE as u64)+1; let mut handshake = [0u8;BUFFER_SIZE]; handshake[..self.metadata.as_ref().unwrap().len().to_string().as_bytes().len()].copy_from_slice(self.metadata.as_ref().unwrap().len().to_string().as_bytes()); - match stream.write_all(&mut handshake) + let mut writer_stream = BufWriter::new(stream.try_clone().unwrap()); + let mut reader_stream = BufReader::new(stream.try_clone().unwrap()); + match writer_stream.write_all(&mut handshake) { Ok(_) => { + match writer_stream.flush() + { + Ok(_) => + { + println!("Done: Flush Handshake -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush Handshake -> {} | Error: {}", self.location, err_val); + } + } let mut handshake_callback = [0u8;BUFFER_SIZE]; - match stream.read_exact(&mut handshake_callback) + match reader_stream.read_exact(&mut handshake_callback) { Ok(_) => { @@ -96,20 +109,22 @@ impl FileInfo Err(err_val) => { println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); + return; } } while iteration != 0 { iteration -= 1; - let mut buffer = [0u8;BUFFER_SIZE]; - match self.file.as_ref().as_mut().unwrap().read(&mut buffer) + let mut buffer = [0u8;BUFFER_SIZE]; + let mut file_reader = BufReader::new(self.file.as_ref().unwrap()); + match file_reader.read(&mut buffer) { Ok(read_size) => { self.size_current += read_size; if iteration != 0 { - match stream.write_all(&mut buffer) + match writer_stream.write_all(&mut buffer) { Ok(_) => { @@ -121,22 +136,11 @@ impl FileInfo return; } } - match stream.flush() - { - Ok(_) => - { - println!("Done: Flush -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Flush -> {} | Error: {}", self.location, err_val); - } - } } else { let mut last_buffer:Vec = (&buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64)as usize]).to_vec(); - match stream.write_all(&mut last_buffer) + match writer_stream.write_all(&mut last_buffer) { Ok(_) => { @@ -148,6 +152,17 @@ impl FileInfo } } } + match writer_stream.flush() + { + Ok(_) => + { + println!("Done: Flush -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush -> {} | Error: {}", self.location, err_val); + } + } } Err(err_val) => @@ -163,68 +178,65 @@ impl FileInfo { //use match, there is a chance to fail creation. don't pass with just some self.file = Some(File::create(&self.location).expect("Error: Create File")); - match self.file + let mut file_reader = BufReader::new(self.file.as_ref().unwrap()); + let mut file_writer = BufWriter::new(self.file.as_ref().unwrap()); + let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); + let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); + let mut size:u64 = 0; + let mut handshake:Vec = Vec::new(); + match stream_reader.read_until(b'\n',&mut handshake) { - Some(ref mut file_descriptor) => + Ok(_) => { - let mut handshake = [0u8;BUFFER_SIZE]; - let mut size:u64 = 0; - match stream.read_exact(&mut handshake) + //read until and take + todo!(); + size = String::from_utf8(handshake.to_vec()).unwrap().parse().unwrap(); + println!("Done: Handshake Recv -> {}", self.location); + match stream.write_all(&mut handshake) { Ok(_) => { - todo!(); - size = String::from_utf8(handshake.to_vec()).unwrap().parse().unwrap(); - println!("Done: Handshake Recv -> {}", self.location); - match stream.write_all(&mut handshake) - { - Ok(_) => - { - println!("Done: Handshake Send -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); - } - } + println!("Done: Handshake Send -> {}", self.location); } Err(err_val) => { - println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); + println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); } } - let mut iteration:u64 = (size%BUFFER_SIZE as u64)+1; - while iteration != 0 - { - iteration -= 1; - //let mut buffer: Vec = Vec::new(); - let mut buffer = [0u8;BUFFER_SIZE]; - match stream.read(&mut buffer) - { - Ok(_) => - { - match File::write_all(file_descriptor, &mut buffer) - { - Ok(_) => - { - self.size_current += buffer.len(); - println!("Done: Write -> {} bytes", &mut self.size_current); - } - Err(err_val) => println!("Error: Write {}", err_val), - } - } - Err(err_val) => - { - println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); - } - } - } } - None => + Err(err_val) => { - println!("Error: File None"); + println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); } } + let mut iteration:u64 = (size%BUFFER_SIZE as u64)+1; + while iteration != 0 + { + iteration -= 1; + //let mut buffer: Vec = Vec::new(); + let mut buffer = [0u8;BUFFER_SIZE]; + match stream.read(&mut buffer) + { + Ok(_) => + { + match File::write_all(file_descriptor, &mut buffer) + { + Ok(_) => + { + self.size_current += buffer.len(); + println!("Done: Write -> {} bytes", &mut self.size_current); + } + Err(err_val) => println!("Error: Write {}", err_val), + } + } + Err(err_val) => + { + println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); + } + } + } + + } } enum Connection From c6b5dcdd9d67f60b45ed9beb83760543e129f332 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Wed, 11 Oct 2023 02:54:21 +0300 Subject: [PATCH 05/11] buggy_but_close_i_hope --- src/main.rs | 142 ++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 109 insertions(+), 33 deletions(-) diff --git a/src/main.rs b/src/main.rs index 649a692..6673561 100644 --- a/src/main.rs +++ b/src/main.rs @@ -71,18 +71,26 @@ impl FileInfo } fn file_to_byte(&mut self, stream:&mut TcpStream) - { - //replace with readbuffer ? + { let mut iteration = (self.metadata.as_ref().unwrap().len()/BUFFER_SIZE as u64)+1; - let mut handshake = [0u8;BUFFER_SIZE]; - handshake[..self.metadata.as_ref().unwrap().len().to_string().as_bytes().len()].copy_from_slice(self.metadata.as_ref().unwrap().len().to_string().as_bytes()); - let mut writer_stream = BufWriter::new(stream.try_clone().unwrap()); - let mut reader_stream = BufReader::new(stream.try_clone().unwrap()); - match writer_stream.write_all(&mut handshake) + let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); + let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); + match stream_writer.write_all(self.metadata.as_ref().unwrap().len().to_string().as_bytes()) { Ok(_) => { - match writer_stream.flush() + match stream_writer.write_all(String::from("\n").as_bytes()) + { + Ok(_) => + { + println!("Done: Send Terminator -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); + } + } + match stream_writer.flush() { Ok(_) => { @@ -93,16 +101,27 @@ impl FileInfo println!("Error: Flush Handshake -> {} | Error: {}", self.location, err_val); } } - let mut handshake_callback = [0u8;BUFFER_SIZE]; - match reader_stream.read_exact(&mut handshake_callback) + let mut handshake_callback:Vec = Vec::new(); + match stream_reader.read_until( b'\n',&mut handshake_callback) { Ok(_) => { - println!("Done: Handshake -> {}", self.location); + println!("Done: Handshake Callback -> {}", self.location); + handshake_callback.pop(); + if handshake_callback.as_slice() == self.metadata.as_ref().unwrap().len().to_string().as_bytes() + { + println!("Done: Handshake Correct -> {}", self.location); + } + else + { + println!("Error: Handshake Incorrect -> {}", self.location); + return; + } } Err(err_val) => { println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); + return; } } } @@ -112,6 +131,8 @@ impl FileInfo return; } } + println!("Size = {}", self.metadata.as_ref().unwrap().len()); + println!("Iteration = {}", iteration); while iteration != 0 { iteration -= 1; @@ -124,11 +145,11 @@ impl FileInfo self.size_current += read_size; if iteration != 0 { - match writer_stream.write_all(&mut buffer) + match stream_writer.write_all(&mut buffer) { Ok(_) => { - println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); + //println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); } Err(err_val) => { @@ -140,7 +161,7 @@ impl FileInfo else { let mut last_buffer:Vec = (&buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64)as usize]).to_vec(); - match writer_stream.write_all(&mut last_buffer) + match stream_writer.write_all(&mut last_buffer) { Ok(_) => { @@ -152,11 +173,22 @@ impl FileInfo } } } - match writer_stream.flush() + match stream_writer.write_all(String::from("\n").as_bytes()) { Ok(_) => { - println!("Done: Flush -> {}", self.location); + //println!("Done: Send Terminator -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); + } + } + match stream_writer.flush() + { + Ok(_) => + { + //println!("Done: Flush -> {}", self.location); } Err(err_val) => { @@ -178,21 +210,20 @@ impl FileInfo { //use match, there is a chance to fail creation. don't pass with just some self.file = Some(File::create(&self.location).expect("Error: Create File")); - let mut file_reader = BufReader::new(self.file.as_ref().unwrap()); let mut file_writer = BufWriter::new(self.file.as_ref().unwrap()); let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); - let mut size:u64 = 0; + let size:u64; let mut handshake:Vec = Vec::new(); match stream_reader.read_until(b'\n',&mut handshake) { Ok(_) => { //read until and take - todo!(); - size = String::from_utf8(handshake.to_vec()).unwrap().parse().unwrap(); + handshake.pop(); + size = String::from_utf8(handshake.clone()).unwrap().parse().unwrap(); println!("Done: Handshake Recv -> {}", self.location); - match stream.write_all(&mut handshake) + match stream_writer.write_all(&mut handshake) { Ok(_) => { @@ -201,33 +232,78 @@ impl FileInfo Err(err_val) => { println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); + return; + } + } + match stream_writer.write_all(String::from("\n").as_bytes()) + { + Ok(_) => + { + println!("Done: Send Terminator -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); + return; + } + } + match stream_writer.flush() + { + Ok(_) => + { + println!("Done: Flush -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush -> {} | Error: {}", self.location, err_val); + return; } } } Err(err_val) => { println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); + return; } } - let mut iteration:u64 = (size%BUFFER_SIZE as u64)+1; + let mut iteration:u64 = (size/BUFFER_SIZE as u64)+1; + println!("Size = {}", size); + println!("Iteration = {}", iteration); while iteration != 0 { iteration -= 1; - //let mut buffer: Vec = Vec::new(); let mut buffer = [0u8;BUFFER_SIZE]; - match stream.read(&mut buffer) + match stream_reader.read_exact(&mut buffer) { Ok(_) => { - match File::write_all(file_descriptor, &mut buffer) - { - Ok(_) => - { - self.size_current += buffer.len(); - println!("Done: Write -> {} bytes", &mut self.size_current); - } - Err(err_val) => println!("Error: Write {}", err_val), - } + if iteration != 0 + { + match file_writer.write_all(&mut buffer) + { + Ok(_) => + { + self.size_current += buffer.len(); + //println!("Done: Write -> {} bytes | Iteration = {}", &mut self.size_current, iteration); + } + Err(err_val) => println!("Error: Write {}", err_val), + } + } + else + { + let mut last_buffer:Vec = (&buffer[..(size%BUFFER_SIZE as u64)as usize]).to_vec(); + match stream_writer.write_all(&mut last_buffer) + { + Ok(_) => + { + println!("Done: Recv Last Bytes -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Recv Last Bytes -> {} | Error: {}", self.location, err_val); + } + } + } } Err(err_val) => { From 2a13e072b2a7f0ed586a0e779118ba7eb281f437 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Thu, 12 Oct 2023 02:54:57 +0300 Subject: [PATCH 06/11] pretty_close --- src/main.rs | 74 ++++++++++++++++++++--------------------------------- 1 file changed, 28 insertions(+), 46 deletions(-) diff --git a/src/main.rs b/src/main.rs index 6673561..ebd3fc8 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,7 +5,7 @@ use std::io::{Read, Write, self, BufWriter, BufReader, BufRead}; use std::env::{self}; -const BUFFER_SIZE:usize = 100000; +const BUFFER_SIZE:usize = 1024; struct FileInfo { @@ -66,6 +66,7 @@ impl FileInfo Err(err_val) => { println!("Error: Open File -> {} | Error: {}", self.location, err_val); + return; } } @@ -88,6 +89,7 @@ impl FileInfo Err(err_val) => { println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); + return; } } match stream_writer.flush() @@ -99,6 +101,7 @@ impl FileInfo Err(err_val) => { println!("Error: Flush Handshake -> {} | Error: {}", self.location, err_val); + return; } } let mut handshake_callback:Vec = Vec::new(); @@ -143,45 +146,17 @@ impl FileInfo Ok(read_size) => { self.size_current += read_size; - if iteration != 0 - { - match stream_writer.write_all(&mut buffer) - { - Ok(_) => - { - //println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); - } - Err(err_val) => - { - println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); - return; - } - } - } - else - { - let mut last_buffer:Vec = (&buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64)as usize]).to_vec(); - match stream_writer.write_all(&mut last_buffer) - { - Ok(_) => - { - println!("Done: Send Last Bytes -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Send Last Bytes -> {} | Error: {}", self.location, err_val); - } - } - } - match stream_writer.write_all(String::from("\n").as_bytes()) + //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); + match stream_writer.write_all(&mut buffer) { Ok(_) => { - //println!("Done: Send Terminator -> {}", self.location); + println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); } Err(err_val) => { - println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); + println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); + return; } } match stream_writer.flush() @@ -193,6 +168,7 @@ impl FileInfo Err(err_val) => { println!("Error: Flush -> {} | Error: {}", self.location, err_val); + return; } } @@ -200,6 +176,7 @@ impl FileInfo Err(err_val) => { println!("Error: File to Byte -> {} | Error: {}", self.location, err_val); + return; } } @@ -272,44 +249,51 @@ impl FileInfo while iteration != 0 { iteration -= 1; - let mut buffer = [0u8;BUFFER_SIZE]; + let mut buffer = [0u8;BUFFER_SIZE]; match stream_reader.read_exact(&mut buffer) { Ok(_) => { + self.size_current += buffer.len(); + //println!("{} | {:#?}", iteration, buffer); if iteration != 0 { match file_writer.write_all(&mut buffer) { Ok(_) => { - self.size_current += buffer.len(); - //println!("Done: Write -> {} bytes | Iteration = {}", &mut self.size_current, iteration); + println!("Done: Write -> {} bytes | Iteration = {}", &mut self.size_current, iteration); + } + Err(err_val) => + { + println!("Error: Write -> {} | Error: {}", self.location,err_val); + return; } - Err(err_val) => println!("Error: Write {}", err_val), } } else - { - let mut last_buffer:Vec = (&buffer[..(size%BUFFER_SIZE as u64)as usize]).to_vec(); - match stream_writer.write_all(&mut last_buffer) + { + match file_writer.write_all(&mut buffer[..(size%BUFFER_SIZE as u64)as usize]) { Ok(_) => { - println!("Done: Recv Last Bytes -> {}", self.location); + println!("Done: Write Last -> {} bytes | Iteration = {}", &mut self.size_current, iteration); } Err(err_val) => { - println!("Error: Recv Last Bytes -> {} | Error: {}", self.location, err_val); + println!("Error: Write Last -> {} | Error: {}", self.location,err_val); + return; } } } } Err(err_val) => { + println!("{} | {:#?}", iteration, buffer); println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); + return; } - } + } } @@ -412,8 +396,6 @@ fn take_arg() -> String env::args().last().as_deref().unwrap_or("default").to_string() } - - fn main() { //DONT FORGET From 3c011983a36a3fdae848cf4f406a5ab853852fd1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Thu, 12 Oct 2023 13:52:08 +0300 Subject: [PATCH 07/11] bufreader_cause_problem_i_think --- src/main.rs | 82 ++++++++++++++++++++++++++++++++++------------------- 1 file changed, 53 insertions(+), 29 deletions(-) diff --git a/src/main.rs b/src/main.rs index ebd3fc8..19fbc5d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,7 +5,7 @@ use std::io::{Read, Write, self, BufWriter, BufReader, BufRead}; use std::env::{self}; -const BUFFER_SIZE:usize = 1024; +const BUFFER_SIZE:usize = 512; struct FileInfo { @@ -139,43 +139,67 @@ impl FileInfo while iteration != 0 { iteration -= 1; - let mut buffer = [0u8;BUFFER_SIZE]; + let mut buffer = [0u8;BUFFER_SIZE]; let mut file_reader = BufReader::new(self.file.as_ref().unwrap()); - match file_reader.read(&mut buffer) + if iteration != 0 { - Ok(read_size) => + match file_reader.read_exact(&mut buffer) { - self.size_current += read_size; - //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); - match stream_writer.write_all(&mut buffer) + Ok(_) => { - Ok(_) => - { - println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); - } - Err(err_val) => - { - println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); - return; - } + self.size_current += buffer.len(); + println!("Size now = {}", self.size_current); + //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); + } - match stream_writer.flush() + Err(err_val) => { - Ok(_) => - { - //println!("Done: Flush -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Flush -> {} | Error: {}", self.location, err_val); - return; - } + println!("Error: File to Byte -> {} | Error: {}", self.location, err_val); + return; } - + } + } + else + { + let mut last_buffer:Vec = Vec::new(); + match file_reader.read_to_end(&mut last_buffer) + { + Ok(read_size) => + { + self.size_current += read_size; + last_buffer.append(&mut buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64) as usize].to_vec()); + buffer.copy_from_slice(&last_buffer); + println!("Size now = {}", self.size_current); + //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); + } + Err(err_val) => + { + println!("Error: File to Byte Last -> {} | Error: {}", self.location, err_val); + return; + } + } + } + match stream_writer.write_all(&mut buffer) + { + Ok(_) => + { + println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); } Err(err_val) => { - println!("Error: File to Byte -> {} | Error: {}", self.location, err_val); + println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); + return; + } + } + match stream_writer.flush() + { + Ok(_) => + { + //println!("Done: Flush -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush -> {} | Error: {}", self.location, err_val); return; } } @@ -255,7 +279,7 @@ impl FileInfo Ok(_) => { self.size_current += buffer.len(); - //println!("{} | {:#?}", iteration, buffer); + println!("{} | {:#?}", iteration, buffer); if iteration != 0 { match file_writer.write_all(&mut buffer) From d42412c57d7d95672ba64b3e489b95f1c4b04a08 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Thu, 12 Oct 2023 14:21:47 +0300 Subject: [PATCH 08/11] remove_ram_limitations --- README.md | 2 +- src/main.rs | 15 +++++++-------- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 1027232..021d417 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ TCP File Transfer Server and Client in Rust ☑ File transfer over network. -☐ Remove memory limitations. +☑ Remove memory limitations. ☐ Folder transfer. diff --git a/src/main.rs b/src/main.rs index 19fbc5d..5c42ab5 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,8 @@ use std::fs::{File, Metadata, self}; +use std::os::unix::prelude::FileExt; use std::time::Instant; use std::net::{TcpListener, TcpStream}; -use std::io::{Read, Write, self, BufWriter, BufReader, BufRead}; +use std::io::{Read, Write, self, BufWriter, BufReader, BufRead, Seek}; use std::env::{self}; @@ -143,7 +144,7 @@ impl FileInfo let mut file_reader = BufReader::new(self.file.as_ref().unwrap()); if iteration != 0 { - match file_reader.read_exact(&mut buffer) + match self.file.as_ref().unwrap().read_exact(&mut buffer) { Ok(_) => { @@ -161,14 +162,12 @@ impl FileInfo } else { - let mut last_buffer:Vec = Vec::new(); - match file_reader.read_to_end(&mut last_buffer) + match self.file.as_ref().unwrap().read_exact(&mut buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64) as usize]) { - Ok(read_size) => + //fix it + Ok(_) => { - self.size_current += read_size; - last_buffer.append(&mut buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64) as usize].to_vec()); - buffer.copy_from_slice(&last_buffer); + self.size_current += (self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64) as usize; println!("Size now = {}", self.size_current); //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); } From 1eb1969560631ee2a15b6654763ba142812e0f0a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Fri, 13 Oct 2023 03:12:51 +0300 Subject: [PATCH 09/11] cleaning --- src/main.rs | 407 +++++++++++++++++++++++----------------------------- 1 file changed, 178 insertions(+), 229 deletions(-) diff --git a/src/main.rs b/src/main.rs index 5c42ab5..eaa87ce 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,13 +1,11 @@ use std::fs::{File, Metadata, self}; -use std::os::unix::prelude::FileExt; use std::time::Instant; use std::net::{TcpListener, TcpStream}; -use std::io::{Read, Write, self, BufWriter, BufReader, BufRead, Seek}; +use std::io::{Read, Write, self, BufWriter, BufReader, BufRead}; use std::env::{self}; -const BUFFER_SIZE:usize = 512; - +const BUFFER_SIZE:usize = 100000; struct FileInfo { file:Option, @@ -26,13 +24,13 @@ impl FileInfo { if Metadata::is_file(metadata) { - self.read_file(); - self.file_to_byte(stream); + self.open_file(); + self.send_file(stream); } else if Metadata::is_symlink(metadata) { - self.read_file(); - self.file_to_byte(stream); + self.open_file(); + self.send_file(stream); } else { @@ -49,14 +47,14 @@ impl FileInfo } fn writing_operations(&mut self, stream:&mut TcpStream) { + self.forge_file(); self.write_file(stream); } fn read_metadata(&mut self) { - //use match, there is a chance to fail creation. don't pass with just some self.metadata = Some(fs::metadata(&self.location).expect("Error: Read Metadata")); } - fn read_file(&mut self) + fn open_file(&mut self) { match File::open(&self.location) { @@ -72,200 +70,187 @@ impl FileInfo } } - fn file_to_byte(&mut self, stream:&mut TcpStream) - { - let mut iteration = (self.metadata.as_ref().unwrap().len()/BUFFER_SIZE as u64)+1; - let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); - let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); - match stream_writer.write_all(self.metadata.as_ref().unwrap().len().to_string().as_bytes()) - { - Ok(_) => - { - match stream_writer.write_all(String::from("\n").as_bytes()) - { - Ok(_) => - { - println!("Done: Send Terminator -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); - return; - } - } - match stream_writer.flush() - { - Ok(_) => - { - println!("Done: Flush Handshake -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Flush Handshake -> {} | Error: {}", self.location, err_val); - return; - } - } - let mut handshake_callback:Vec = Vec::new(); - match stream_reader.read_until( b'\n',&mut handshake_callback) - { - Ok(_) => - { - println!("Done: Handshake Callback -> {}", self.location); - handshake_callback.pop(); - if handshake_callback.as_slice() == self.metadata.as_ref().unwrap().len().to_string().as_bytes() - { - println!("Done: Handshake Correct -> {}", self.location); - } - else - { - println!("Error: Handshake Incorrect -> {}", self.location); - return; - } - } - Err(err_val) => - { - println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); - return; - } - } - } - Err(err_val) => - { - println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); - return; - } - } - println!("Size = {}", self.metadata.as_ref().unwrap().len()); + fn send_file(&mut self, stream:&mut TcpStream) + { + let size = self.metadata.as_ref().unwrap().len(); + let mut iteration = (size/BUFFER_SIZE as u64)+1; + self.handshake_validation(stream, size); + println!("Size = {}", size); println!("Iteration = {}", iteration); while iteration != 0 { iteration -= 1; let mut buffer = [0u8;BUFFER_SIZE]; - let mut file_reader = BufReader::new(self.file.as_ref().unwrap()); if iteration != 0 { - match self.file.as_ref().unwrap().read_exact(&mut buffer) - { - Ok(_) => - { - self.size_current += buffer.len(); - println!("Size now = {}", self.size_current); - //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); - - } - Err(err_val) => - { - println!("Error: File to Byte -> {} | Error: {}", self.location, err_val); - return; - } - } + self.read_exact(&mut buffer); } else { - match self.file.as_ref().unwrap().read_exact(&mut buffer[..(self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64) as usize]) - { - //fix it - Ok(_) => - { - self.size_current += (self.metadata.as_ref().unwrap().len()%BUFFER_SIZE as u64) as usize; - println!("Size now = {}", self.size_current); - //println!("{} | {} | {:#?}", iteration,buffer.len(), buffer); - } - Err(err_val) => - { - println!("Error: File to Byte Last -> {} | Error: {}", self.location, err_val); - return; - } - } + self.read_exact(&mut buffer[..(size%BUFFER_SIZE as u64) as usize]); } - match stream_writer.write_all(&mut buffer) + self.send_exact(&mut buffer, stream); + + } + } + fn handshake_validation(&mut self, stream:&mut TcpStream, size:u64) + { + self.send_exact(String::from(size.to_string()+"\n").as_bytes(), stream); + match self.recv_until(stream, '\n') + { + Some(handshake_callback) => { - Ok(_) => + if handshake_callback == size.to_string().as_bytes().to_vec() { - println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration); + println!("Done: Handshake -> {}", self.location); } - Err(err_val) => + else { - println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); - return; + println!("Error: Handshake -> {}", self.location); + println!("{:#?} ", handshake_callback); + panic!() } } - match stream_writer.flush() + None => { - Ok(_) => - { - //println!("Done: Flush -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Flush -> {} | Error: {}", self.location, err_val); - return; - } + panic!() + } + } + } + fn read_exact(&mut self, buffer:&mut [u8]) + { + match self.file.as_ref().unwrap().read_exact(buffer) + { + Ok(_) => + { + //println!("Done: Read Bytes -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Read Bytes -> {} | Error: {}", self.location, err_val); + panic!() + } + } + } + fn send_exact(&mut self, buffer:&[u8], stream:&mut TcpStream) + { + let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); + match stream_writer.write_all(buffer) + { + Ok(_) => + { + self.size_current += buffer.len(); + //println!("Done: Send Bytes -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); + panic!(); + } + } + match stream_writer.flush() + { + Ok(_) => + { + //println!("Done: Flush -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush -> {} | Error: {}", self.location, err_val); + panic!() + } + } + } + fn recv_exact(&mut self, buffer:&mut [u8], stream:&mut TcpStream) + { + let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); + match stream_reader.read_exact(buffer) + { + Ok(_) => + { + self.size_current += buffer.len(); + //println!("Done: Receive Bytes -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Receive Bytes -> {} | Error: {}", self.location, err_val); + panic!(); + } + } + } + fn recv_until(&mut self, stream:&mut TcpStream, until:char) -> Option> + { + let mut buffer = Vec::new(); + let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); + match stream_reader.read_until(until as u8,&mut buffer) + { + Ok(_) => + { + //println!("Done: Receive Until -> {}", self.location); + buffer.pop(); + } + Err(err_val) => + { + println!("Error: Receive Until -> {} | Error: {}", self.location, err_val); + return None; + } + } + return Some(buffer); + } + fn forge_file(&mut self) + { + self.file = Some(File::create(&self.location).expect("Error: Create File")); + } + fn handshake_recv(&mut self, stream:&mut TcpStream) -> u64 + { + match self.recv_until(stream, '\n') + { + Some(handshake) => + { + println!("Done: Handshake -> {}", self.location); + let mut handshake_terminated = handshake.clone(); + handshake_terminated.push(b'\n'); + self.send_exact(handshake_terminated.as_slice(), stream); + String::from_utf8(handshake.clone()).unwrap().parse().unwrap() + } + None => + { + println!("Error: Handshake -> {}", self.location); + 0 + } + } + } + fn save_exact(&mut self, buffer:&[u8]) + { + let mut file_writer = BufWriter::new(self.file.as_ref().unwrap()); + match file_writer.write_all(buffer) + { + Ok(_) => + { + //println!("Done: Write -> {} | {} bytes", self.location, self.size_current); + } + Err(err_val) => + { + println!("Error: Write -> {} | Error: {}", self.location,err_val); + panic!(); + } + } + match file_writer.flush() + { + Ok(_) => + { + //println!("Done: Flush -> {}", self.location); + } + Err(err_val) => + { + println!("Error: Flush -> {} | Error: {}", self.location,err_val); + panic!(); } - - } } fn write_file(&mut self, stream:&mut TcpStream) { - //use match, there is a chance to fail creation. don't pass with just some - self.file = Some(File::create(&self.location).expect("Error: Create File")); - let mut file_writer = BufWriter::new(self.file.as_ref().unwrap()); - let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); - let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); - let size:u64; - let mut handshake:Vec = Vec::new(); - match stream_reader.read_until(b'\n',&mut handshake) - { - Ok(_) => - { - //read until and take - handshake.pop(); - size = String::from_utf8(handshake.clone()).unwrap().parse().unwrap(); - println!("Done: Handshake Recv -> {}", self.location); - match stream_writer.write_all(&mut handshake) - { - Ok(_) => - { - println!("Done: Handshake Send -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); - return; - } - } - match stream_writer.write_all(String::from("\n").as_bytes()) - { - Ok(_) => - { - println!("Done: Send Terminator -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); - return; - } - } - match stream_writer.flush() - { - Ok(_) => - { - println!("Done: Flush -> {}", self.location); - } - Err(err_val) => - { - println!("Error: Flush -> {} | Error: {}", self.location, err_val); - return; - } - } - } - Err(err_val) => - { - println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); - return; - } - } + let size = self.handshake_recv(stream); let mut iteration:u64 = (size/BUFFER_SIZE as u64)+1; println!("Size = {}", size); println!("Iteration = {}", iteration); @@ -273,53 +258,16 @@ impl FileInfo { iteration -= 1; let mut buffer = [0u8;BUFFER_SIZE]; - match stream_reader.read_exact(&mut buffer) - { - Ok(_) => - { - self.size_current += buffer.len(); - println!("{} | {:#?}", iteration, buffer); - if iteration != 0 - { - match file_writer.write_all(&mut buffer) - { - Ok(_) => - { - println!("Done: Write -> {} bytes | Iteration = {}", &mut self.size_current, iteration); - } - Err(err_val) => - { - println!("Error: Write -> {} | Error: {}", self.location,err_val); - return; - } - } - } - else - { - match file_writer.write_all(&mut buffer[..(size%BUFFER_SIZE as u64)as usize]) - { - Ok(_) => - { - println!("Done: Write Last -> {} bytes | Iteration = {}", &mut self.size_current, iteration); - } - Err(err_val) => - { - println!("Error: Write Last -> {} | Error: {}", self.location,err_val); - return; - } - } - } - } - Err(err_val) => - { - println!("{} | {:#?}", iteration, buffer); - println!("Error: Recv Bytes -> {} | Error: {}", self.location, err_val); - return; - } - } - } - - + self.recv_exact(&mut buffer, stream); + if iteration != 0 + { + self.save_exact(&buffer); + } + else + { + self.save_exact(&buffer[..(size%BUFFER_SIZE as u64) as usize]); + } + } } } enum Connection @@ -356,6 +304,7 @@ impl Connection let mut stay = true; while stay { + println!("Connected"); let start_time = Instant::now(); FileInfo::writing_operations(file_info, &mut stream); let finish_time = Instant::now(); @@ -392,8 +341,8 @@ impl Connection { Ok(mut stream) => { - let start_time = Instant::now(); println!("Connected"); + let start_time = Instant::now(); FileInfo::reading_operations(file_info, &mut stream); let finish_time = Instant::now(); println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time)); From 87511f184a4d1491eae79771d07c4d35581b7fe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Sat, 14 Oct 2023 00:32:12 +0300 Subject: [PATCH 10/11] docs: Update README.md --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 021d417..d1495b0 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ TCP File Transfer Server and Client in Rust ☑ File transfer over network. -☑ Remove memory limitations. +☑ Remove memory limitations. [d42412c](https://github.com/Tahinli/rust-tcp-file-transfer/pull/1/commits/d42412c57d7d95672ba64b3e489b95f1c4b04a08) ☐ Folder transfer. @@ -12,4 +12,4 @@ TCP File Transfer Server and Client in Rust ☐ Reach over NAT (peer to peer). -☐ Async. \ No newline at end of file +☐ Async. From 475010542c17890416281b1c449f9b525a1a75a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ahmet=20Kaan=20G=C3=9CM=C3=9C=C5=9E?= <96421894+Tahinli@users.noreply.github.com> Date: Sat, 14 Oct 2023 00:33:18 +0300 Subject: [PATCH 11/11] style: handshake_recv --- src/main.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/main.rs b/src/main.rs index eaa87ce..a4725bc 100644 --- a/src/main.rs +++ b/src/main.rs @@ -205,13 +205,14 @@ impl FileInfo { match self.recv_until(stream, '\n') { - Some(handshake) => + Some(mut handshake) => { + // try then commit println!("Done: Handshake -> {}", self.location); - let mut handshake_terminated = handshake.clone(); - handshake_terminated.push(b'\n'); - self.send_exact(handshake_terminated.as_slice(), stream); - String::from_utf8(handshake.clone()).unwrap().parse().unwrap() + let size = String::from_utf8(handshake.clone()).unwrap().parse().unwrap(); + handshake.push(b'\n'); + self.send_exact(&handshake.as_slice(), stream); + size } None => {