Tahinli/rust-tcp-file-transfer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

cleaning

Browse source
This commit is contained in:
Ahmet Kaan GÜMÜŞ 2023-10-13 03:12:51 +03:00
parent d42412c57d
commit 1eb1969560
1 changed files with 178 additions and 229 deletions
Download patch file Download diff file Expand all files Collapse all files

321
src/main.rs
View file

@ -1,13 +1,11 @@
use std::fs::{File, Metadata, self}; use std::fs::{File, Metadata, self};
use std::os::unix::prelude::FileExt;
use std::time::Instant; use std::time::Instant;
use std::net::{TcpListener, TcpStream}; 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}; use std::env::{self};
const BUFFER_SIZE:usize = 512; const BUFFER_SIZE:usize = 100000;
struct FileInfo struct FileInfo
{ {
file:Option<File>, file:Option<File>,
@ -26,13 +24,13 @@ impl FileInfo
{ {
if Metadata::is_file(metadata) if Metadata::is_file(metadata)
{ {
self.read_file(); self.open_file();
self.file_to_byte(stream); self.send_file(stream);
} }
else if Metadata::is_symlink(metadata) else if Metadata::is_symlink(metadata)
{ {
self.read_file(); self.open_file();
self.file_to_byte(stream); self.send_file(stream);
} }
else else
{ {
@ -49,14 +47,14 @@ impl FileInfo
} }
fn writing_operations(&mut self, stream:&mut TcpStream) fn writing_operations(&mut self, stream:&mut TcpStream)
{ {
self.forge_file();
self.write_file(stream); self.write_file(stream);
} }
fn read_metadata(&mut self) 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")); 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) match File::open(&self.location)
{ {
@ -72,122 +70,82 @@ impl FileInfo
} }
} }
fn file_to_byte(&mut self, stream:&mut TcpStream) fn send_file(&mut self, stream:&mut TcpStream)
{ {
let mut iteration = (self.metadata.as_ref().unwrap().len()/BUFFER_SIZE as u64)+1; let size = self.metadata.as_ref().unwrap().len();
let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); let mut iteration = (size/BUFFER_SIZE as u64)+1;
let mut stream_reader = BufReader::new(stream.try_clone().unwrap()); self.handshake_validation(stream, size);
match stream_writer.write_all(self.metadata.as_ref().unwrap().len().to_string().as_bytes()) println!("Size = {}", size);
{
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<u8> = 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());
println!("Iteration = {}", iteration); println!("Iteration = {}", iteration);
while iteration != 0 while iteration != 0
{ {
iteration -= 1; 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());
if iteration != 0 if iteration != 0
{ {
match self.file.as_ref().unwrap().read_exact(&mut buffer) self.read_exact(&mut buffer);
}
else
{
self.read_exact(&mut buffer[..(size%BUFFER_SIZE as u64) as usize]);
}
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) =>
{
if handshake_callback == size.to_string().as_bytes().to_vec()
{
println!("Done: Handshake -> {}", self.location);
}
else
{
println!("Error: Handshake -> {}", self.location);
println!("{:#?} ", handshake_callback);
panic!()
}
}
None =>
{
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(_) => Ok(_) =>
{ {
self.size_current += buffer.len(); self.size_current += buffer.len();
println!("Size now = {}", self.size_current); //println!("Done: Send Bytes -> {}", self.location);
//println!("{} | {} | {:#?}", iteration,buffer.len(), buffer);
}
Err(err_val) =>
{
println!("Error: File to Byte -> {} | Error: {}", self.location, err_val);
return;
}
}
}
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;
}
}
}
match stream_writer.write_all(&mut buffer)
{
Ok(_) =>
{
println!("Done: Send Bytes -> {} | Iteration = {}", self.location, iteration);
} }
Err(err_val) => Err(err_val) =>
{ {
println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val); println!("Error: Send Bytes -> {} | Error: {}", self.location, err_val);
return; panic!();
} }
} }
match stream_writer.flush() match stream_writer.flush()
@ -199,73 +157,100 @@ impl FileInfo
Err(err_val) => Err(err_val) =>
{ {
println!("Error: Flush -> {} | Error: {}", self.location, err_val); println!("Error: Flush -> {} | Error: {}", self.location, err_val);
return; panic!()
} }
} }
} }
} fn recv_exact(&mut self, buffer:&mut [u8], stream:&mut TcpStream)
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_reader = BufReader::new(stream.try_clone().unwrap());
let mut stream_writer = BufWriter::new(stream.try_clone().unwrap()); match stream_reader.read_exact(buffer)
let size:u64;
let mut handshake:Vec<u8> = Vec::new();
match stream_reader.read_until(b'\n',&mut handshake)
{ {
Ok(_) => Ok(_) =>
{ {
//read until and take self.size_current += buffer.len();
handshake.pop(); //println!("Done: Receive Bytes -> {}", self.location);
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) => Err(err_val) =>
{ {
println!("Error: Handshake Send -> {} | Error: {}", self.location, err_val); println!("Error: Receive Bytes -> {} | Error: {}", self.location, err_val);
return; panic!();
} }
} }
match stream_writer.write_all(String::from("\n").as_bytes()) }
fn recv_until(&mut self, stream:&mut TcpStream, until:char) -> Option<Vec<u8>>
{
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(_) => Ok(_) =>
{ {
println!("Done: Send Terminator -> {}", self.location); //println!("Done: Receive Until -> {}", self.location);
buffer.pop();
} }
Err(err_val) => Err(err_val) =>
{ {
println!("Error: Send Terminator -> {} | Error: {}", self.location, err_val); println!("Error: Receive Until -> {} | Error: {}", self.location, err_val);
return; return None;
} }
} }
match stream_writer.flush() 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(_) => Ok(_) =>
{ {
println!("Done: Flush -> {}", self.location); //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) => Err(err_val) =>
{ {
println!("Error: Flush -> {} | Error: {}", self.location,err_val); println!("Error: Flush -> {} | Error: {}", self.location,err_val);
return; panic!();
} }
} }
} }
Err(err_val) => fn write_file(&mut self, stream:&mut TcpStream)
{ {
println!("Error: Handshake Recv -> {} | Error: {}", self.location, err_val); let size = self.handshake_recv(stream);
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!("Size = {}", size);
println!("Iteration = {}", iteration); println!("Iteration = {}", iteration);
@ -273,53 +258,16 @@ impl FileInfo
{ {
iteration -= 1; iteration -= 1;
let mut buffer = [0u8;BUFFER_SIZE]; let mut buffer = [0u8;BUFFER_SIZE];
match stream_reader.read_exact(&mut buffer) self.recv_exact(&mut buffer, stream);
{
Ok(_) =>
{
self.size_current += buffer.len();
println!("{} | {:#?}", iteration, buffer);
if iteration != 0 if iteration != 0
{ {
match file_writer.write_all(&mut buffer) self.save_exact(&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 else
{ {
match file_writer.write_all(&mut buffer[..(size%BUFFER_SIZE as u64)as usize]) self.save_exact(&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;
}
}
}
} }
} }
enum Connection enum Connection
@ -356,6 +304,7 @@ impl Connection
let mut stay = true; let mut stay = true;
while stay while stay
{ {
println!("Connected");
let start_time = Instant::now(); let start_time = Instant::now();
FileInfo::writing_operations(file_info, &mut stream); FileInfo::writing_operations(file_info, &mut stream);
let finish_time = Instant::now(); let finish_time = Instant::now();
@ -392,8 +341,8 @@ impl Connection
{ {
Ok(mut stream) => Ok(mut stream) =>
{ {
let start_time = Instant::now();
println!("Connected"); println!("Connected");
let start_time = Instant::now();
FileInfo::reading_operations(file_info, &mut stream); FileInfo::reading_operations(file_info, &mut stream);
let finish_time = Instant::now(); let finish_time = Instant::now();
println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time)); println!("Passed: Total -> {:#?}", finish_time.duration_since(start_time));