diff --git a/src/client.rs b/src/client.rs index 2802234..ad6088a 100644 --- a/src/client.rs +++ b/src/client.rs @@ -136,7 +136,7 @@ impl Client { let unlocked_context = context.lock().unwrap(); if let Some(sender) = &unlocked_context.sender { - if unlocked_context.peers.get(&peer.username).is_none() { + if !unlocked_context.peers.contains_key(&peer.username) { let peer_clone = peer.clone(); let sender_clone = sender.clone(); thread::spawn(move || { diff --git a/src/dispatcher.rs b/src/dispatcher.rs index 21aec92..4b21cb3 100644 --- a/src/dispatcher.rs +++ b/src/dispatcher.rs @@ -1,4 +1,4 @@ -use crate::message::{handlers::Handlers, message::Message}; +use crate::message::{handlers::Handlers, Message}; use std::sync::mpsc::Sender; /// Add `` to make it generic over any operation type. diff --git a/src/message/handlers.rs b/src/message/handlers.rs index a8edc1a..c24c956 100644 --- a/src/message/handlers.rs +++ b/src/message/handlers.rs @@ -25,7 +25,7 @@ impl Handlers { self.handlers.insert(handler.get_code(), Box::new(handler)); self } - pub fn get_handler(&self, code: u8) -> Option<&Box>> { - self.handlers.get(&code) + pub fn get_handler(&self, code: u8) -> Option<&dyn MessageHandler> { + self.handlers.get(&code).map(|v| &**v) } } diff --git a/src/message/message.rs b/src/message/message.rs index 06e5c2c..e69de29 100644 --- a/src/message/message.rs +++ b/src/message/message.rs @@ -1,317 +0,0 @@ -use std::str; - -#[derive(Debug, PartialEq, Clone)] -pub struct Message { - data: Vec, - pointer: usize, -} - -impl Message { - pub fn new() -> Self { - Self { - data: Vec::new(), - pointer: 0, - } - } - - pub fn print_hex(&self) { - let data = &self.data; - const BYTES_PER_LINE: usize = 16; - - let chunks = data.chunks(BYTES_PER_LINE); - for (i, chunk) in chunks.enumerate() { - // Print the offset - print!("{:04x} ", i * BYTES_PER_LINE); - - // Print the hexadecimal part - for j in 0..BYTES_PER_LINE { - if j < chunk.len() { - print!("{:02x} ", chunk[j]); - } else { - print!(" "); - } - - // Add extra space in the middle - if j == 7 { - print!(" "); - } - } - - print!(" "); - - // Print the ASCII part - let mut i = 0; - for &byte in chunk { - i += 1; - if byte.is_ascii_graphic() || byte.is_ascii_whitespace() { - print!("{}", byte as char); - } else { - print!("."); - } - - if i == 8 { - print!(" "); - } - } - - println!(); - } - } - // - // pub fn print_hex2(&self) -> String { - // let data = &self.data; - // let mut out = String::from(""); - // const BYTES_PER_LINE: usize = 16; - // - // let chunks = data.chunks(BYTES_PER_LINE); - // for (i, chunk) in chunks.enumerate() { - // // Print the offset - // // out += &format!("{:04x} ", i * BYTES_PER_LINE); - // - // // Print the hexadecimal part - // for j in 0..BYTES_PER_LINE { - // if j < chunk.len() { - // out += &format!("{:02x} ", chunk[j]); - // } else { - // // out += &format!(" "); - // } - // - // // Add extra space in the middle - // // if j == 7 { - // // out += &format!(" "); - // // } - // } - // - // // // Print the ASCII part - // // let mut i = 0; - // // for &byte in chunk { - // // i = i + 1; - // // if byte.is_ascii_graphic() || byte.is_ascii_whitespace() { - // // print!("{}", byte as char); - // // } else {messa - // // print!("."); - // // } - // // - // // if i == 8 { - // // print!(" "); - // // } - // // } - // // - // } - // println!("{:?}", out.trim()); - // return out.trim().into(); - // } - - pub fn get_message_code_u32(&self) -> u32 { - u32::from_le_bytes(self.data[4..8].try_into().unwrap()) - } - - pub fn get_message_code(&self) -> u8 { - self.data[4] - } - - pub fn new_with_data(data: Vec) -> Self { - Self { data, pointer: 0 } - } - // pub fn reset_pointer(&mut self) { - // self.pointer = 0; - // } - pub fn set_pointer(&mut self, pointer: usize) { - self.pointer = pointer; - } - - pub fn get_pointer(&mut self) -> usize { - self.pointer - } - - pub fn get_size(&mut self) -> usize { - self.data.len() - } - - pub fn get_data(&self) -> Vec { - self.data.clone() - } - - pub fn get_slice(&self, from: usize, to: usize) -> Vec { - self.data[from..to].to_vec() - } - - /// gets buffer with the message length prepended - pub fn get_buffer(&self) -> Vec { - let mut b = vec![0u8; 4]; - let length = self.data.len() as u32; - b[0..4].copy_from_slice(&length.to_le_bytes()); - let mut combined = b; - combined.extend(&self.data); - combined - } - - pub fn read_string(&mut self) -> String { - let size = u32::from_le_bytes([ - self.data[self.pointer], - self.data[self.pointer + 1], - self.data[self.pointer + 2], - self.data[self.pointer + 3], - ]) as usize; - - self.pointer += 4; - let data = &self.data[self.pointer..self.pointer + size]; - self.pointer += size; - - String::from_utf8(data.to_vec()).expect("Failed to read string") - } - pub fn read_raw_hex_str(&mut self, size: usize) -> String { - let hex_str = self.data[self.pointer..self.pointer + size] - .iter() - .map(|byte| format!("{:02x}", byte)) - .collect::(); - self.pointer += size; - hex_str - } - - pub fn read_int8(&mut self) -> i8 { - let val = self.data[self.pointer] as i8; - self.pointer += 1; - val - } - - #[allow(dead_code)] - pub fn read_int64(&mut self) -> i64 { - let val = i64::from_le_bytes([ - self.data[self.pointer], - self.data[self.pointer + 1], - self.data[self.pointer + 2], - self.data[self.pointer + 3], - self.data[self.pointer + 4], - self.data[self.pointer + 5], - self.data[self.pointer + 6], - self.data[self.pointer + 7], - ]); - self.pointer += 8; - val - } - - pub fn read_int32(&mut self) -> i32 { - if self.pointer + 4 > self.data.len() { - return 0; - } - - let val = i32::from_le_bytes([ - self.data[self.pointer], - self.data[self.pointer + 1], - self.data[self.pointer + 2], - self.data[self.pointer + 3], - ]); - self.pointer += 4; - val - } - - pub fn read_bool(&mut self) -> bool { - let val = self.data[self.pointer] == 1; - self.pointer += 1; - val - } - - pub fn write_string(&mut self, val: &str) -> &mut Self { - let length = val.len() as u32; - self.data.extend_from_slice(&length.to_le_bytes()); - self.data.extend_from_slice(val.as_bytes()); - self - } - - pub fn write_int32(&mut self, value: i32) -> &mut Self { - self.data.extend_from_slice(&value.to_le_bytes()); - self - } - pub fn write_raw_bytes(&mut self, value: Vec) -> &mut Self { - self.data.extend_from_slice(&value); - self - } - - pub fn write_raw_hex_string(&mut self, val: &str) -> &mut Self { - let mut b = Vec::new(); - for i in (0..val.len()).step_by(2) { - let byte_str = &val[i..i + 2]; - let byte = u8::from_str_radix(byte_str, 16).expect("Invalid hex string"); - b.push(byte); - } - self.data.extend_from_slice(&b); - self.pointer += b.len(); - self - } - // pub fn decode(&self) { - // println!("{:?}", self.data); - // } -} - -#[test] -fn test_get_buffer() { - let message = Message::new_with_data( - [ - 26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119, 101, 101, 107, 101, - 110, 100, - ] - .to_vec(), - ); - assert_eq!( - message.get_buffer(), - [ - 23, 0, 0, 0, 26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119, 101, - 101, 107, 101, 110, 100, - ] - .to_vec() - ); - - let message = Message::new_with_data( - [ - 1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95, 116, 104, 101, - 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51, 55, 160, 0, 0, - 0, 32, 0, 0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, 55, 56, 102, - 56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0, 0, - ] - .to_vec(), - ); - assert_eq!( - message.get_buffer(), - [ - 84, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95, - 116, 104, 101, 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51, - 55, 160, 0, 0, 0, 32, 0, 0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, - 55, 56, 102, 56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0, - 0, - ] - .to_vec() - ); -} -#[test] -fn test_read_string() { - let data = vec![ - 5, 0, 0, 0, // size = 5 - 72, 101, 108, 108, 111, // "Hello" - ]; - let mut test_data = Message::new_with_data(data); - assert_eq!(test_data.read_string(), "Hello"); -} - -#[test] -fn test_read_string_2() { - let data = vec![ - 50, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 81, 170, 162, 77, 32, 0, 0, 0, 101, 102, 99, 97, - 51, 52, 102, 99, 52, 99, 56, 98, 101, 56, 98, 55, 101, 102, 51, 56, 97, 102, 50, 54, 50, - 52, 100, 101, 53, 52, 54, 52, 0, - ]; - let mut test_data = Message::new_with_data(data); - test_data.set_pointer(9); - assert_eq!(test_data.read_string(), ""); -} - -#[test] -#[should_panic(expected = "Failed to read string")] -fn test_read_string_invalid_utf8() { - let data = vec![ - 3, 0, 0, 0, // size = 3 - 255, 255, 255, // invalid UTF-8 sequence - ]; - let mut test_data = Message::new_with_data(data); - test_data.read_string(); -} diff --git a/src/message/mod.rs b/src/message/mod.rs index f80c9cc..ef1a084 100644 --- a/src/message/mod.rs +++ b/src/message/mod.rs @@ -1,9 +1,329 @@ pub mod handlers; -pub mod message; pub mod message_reader; pub mod peer; pub mod server; pub use handlers::*; -pub use message::*; pub use message_reader::*; + +use std::str; + +#[derive(Debug, PartialEq, Clone)] +pub struct Message { + data: Vec, + pointer: usize, +} + +impl Message { + pub fn new() -> Self { + Self { + data: Vec::new(), + pointer: 0, + } + } + + pub fn print_hex(&self) { + let data = &self.data; + const BYTES_PER_LINE: usize = 16; + + let chunks = data.chunks(BYTES_PER_LINE); + for (i, chunk) in chunks.enumerate() { + // Print the offset + print!("{:04x} ", i * BYTES_PER_LINE); + + // Print the hexadecimal part + for j in 0..BYTES_PER_LINE { + if j < chunk.len() { + print!("{:02x} ", chunk[j]); + } else { + print!(" "); + } + + // Add extra space in the middle + if j == 7 { + print!(" "); + } + } + + print!(" "); + + // Print the ASCII part + let mut i = 0; + for &byte in chunk { + i += 1; + if byte.is_ascii_graphic() || byte.is_ascii_whitespace() { + print!("{}", byte as char); + } else { + print!("."); + } + + if i == 8 { + print!(" "); + } + } + + println!(); + } + } + // + // pub fn print_hex2(&self) -> String { + // let data = &self.data; + // let mut out = String::from(""); + // const BYTES_PER_LINE: usize = 16; + // + // let chunks = data.chunks(BYTES_PER_LINE); + // for (i, chunk) in chunks.enumerate() { + // // Print the offset + // // out += &format!("{:04x} ", i * BYTES_PER_LINE); + // + // // Print the hexadecimal part + // for j in 0..BYTES_PER_LINE { + // if j < chunk.len() { + // out += &format!("{:02x} ", chunk[j]); + // } else { + // // out += &format!(" "); + // } + // + // // Add extra space in the middle + // // if j == 7 { + // // out += &format!(" "); + // // } + // } + // + // // // Print the ASCII part + // // let mut i = 0; + // // for &byte in chunk { + // // i = i + 1; + // // if byte.is_ascii_graphic() || byte.is_ascii_whitespace() { + // // print!("{}", byte as char); + // // } else {messa + // // print!("."); + // // } + // // + // // if i == 8 { + // // print!(" "); + // // } + // // } + // // + // } + // println!("{:?}", out.trim()); + // return out.trim().into(); + // } + + #[allow(dead_code)] + pub fn get_message_code_u32(&self) -> u32 { + u32::from_le_bytes(self.data[4..8].try_into().unwrap()) + } + + pub fn get_message_code(&self) -> u8 { + self.data[4] + } + + pub fn new_with_data(data: Vec) -> Self { + Self { data, pointer: 0 } + } + // pub fn reset_pointer(&mut self) { + // self.pointer = 0; + // } + pub fn set_pointer(&mut self, pointer: usize) { + self.pointer = pointer; + } + + pub fn get_pointer(&mut self) -> usize { + self.pointer + } + + pub fn get_size(&mut self) -> usize { + self.data.len() + } + + pub fn get_data(&self) -> Vec { + self.data.clone() + } + + pub fn get_slice(&self, from: usize, to: usize) -> Vec { + self.data[from..to].to_vec() + } + + /// gets buffer with the message length prepended + pub fn get_buffer(&self) -> Vec { + let mut b = vec![0u8; 4]; + let length = self.data.len() as u32; + b[0..4].copy_from_slice(&length.to_le_bytes()); + let mut combined = b; + combined.extend(&self.data); + combined + } + + pub fn read_string(&mut self) -> String { + let size = u32::from_le_bytes([ + self.data[self.pointer], + self.data[self.pointer + 1], + self.data[self.pointer + 2], + self.data[self.pointer + 3], + ]) as usize; + + self.pointer += 4; + let data = &self.data[self.pointer..self.pointer + size]; + self.pointer += size; + + String::from_utf8(data.to_vec()).expect("Failed to read string") + } + pub fn read_raw_hex_str(&mut self, size: usize) -> String { + let hex_str = self.data[self.pointer..self.pointer + size] + .iter() + .fold(String::new(), |mut acc, byte| { + use std::fmt::Write; + write!(acc, "{:02x}", byte).expect("Failed to write to string"); + acc + }); + self.pointer += size; + hex_str + } + + pub fn read_int8(&mut self) -> i8 { + let val = self.data[self.pointer] as i8; + self.pointer += 1; + val + } + + #[allow(dead_code)] + pub fn read_int64(&mut self) -> i64 { + let val = i64::from_le_bytes([ + self.data[self.pointer], + self.data[self.pointer + 1], + self.data[self.pointer + 2], + self.data[self.pointer + 3], + self.data[self.pointer + 4], + self.data[self.pointer + 5], + self.data[self.pointer + 6], + self.data[self.pointer + 7], + ]); + self.pointer += 8; + val + } + + pub fn read_int32(&mut self) -> i32 { + if self.pointer + 4 > self.data.len() { + return 0; + } + + let val = i32::from_le_bytes([ + self.data[self.pointer], + self.data[self.pointer + 1], + self.data[self.pointer + 2], + self.data[self.pointer + 3], + ]); + self.pointer += 4; + val + } + + pub fn read_bool(&mut self) -> bool { + let val = self.data[self.pointer] == 1; + self.pointer += 1; + val + } + + pub fn write_string(&mut self, val: &str) -> &mut Self { + let length = val.len() as u32; + self.data.extend_from_slice(&length.to_le_bytes()); + self.data.extend_from_slice(val.as_bytes()); + self + } + + pub fn write_int32(&mut self, value: i32) -> &mut Self { + self.data.extend_from_slice(&value.to_le_bytes()); + self + } + pub fn write_raw_bytes(&mut self, value: Vec) -> &mut Self { + self.data.extend_from_slice(&value); + self + } + + pub fn write_raw_hex_string(&mut self, val: &str) -> &mut Self { + let mut b = Vec::new(); + for i in (0..val.len()).step_by(2) { + let byte_str = &val[i..i + 2]; + let byte = u8::from_str_radix(byte_str, 16).expect("Invalid hex string"); + b.push(byte); + } + self.data.extend_from_slice(&b); + self.pointer += b.len(); + self + } + // pub fn decode(&self) { + // println!("{:?}", self.data); + // } +} + +#[test] +fn test_get_buffer() { + let message = Message::new_with_data( + [ + 26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119, 101, 101, 107, 101, + 110, 100, + ] + .to_vec(), + ); + assert_eq!( + message.get_buffer(), + [ + 23, 0, 0, 0, 26, 0, 0, 0, 219, 178, 47, 28, 11, 0, 0, 0, 116, 104, 101, 32, 119, 101, + 101, 107, 101, 110, 100, + ] + .to_vec() + ); + + let message = Message::new_with_data( + [ + 1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95, 116, 104, 101, + 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51, 55, 160, 0, 0, + 0, 32, 0, 0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, 55, 56, 102, + 56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0, 0, + ] + .to_vec(), + ); + assert_eq!( + message.get_buffer(), + [ + 84, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 105, 110, 115, 97, 110, 101, 95, 105, 110, 95, + 116, 104, 101, 95, 98, 114, 97, 105, 110, 50, 8, 0, 0, 0, 49, 51, 51, 55, 53, 49, 51, + 55, 160, 0, 0, 0, 32, 0, 0, 0, 50, 101, 100, 102, 53, 49, 100, 48, 51, 55, 57, 52, 51, + 55, 56, 102, 56, 98, 98, 54, 51, 49, 48, 100, 52, 54, 48, 99, 50, 50, 98, 49, 17, 0, 0, + 0, + ] + .to_vec() + ); +} +#[test] +fn test_read_string() { + let data = vec![ + 5, 0, 0, 0, // size = 5 + 72, 101, 108, 108, 111, // "Hello" + ]; + let mut test_data = Message::new_with_data(data); + assert_eq!(test_data.read_string(), "Hello"); +} + +#[test] +fn test_read_string_2() { + let data = vec![ + 50, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 81, 170, 162, 77, 32, 0, 0, 0, 101, 102, 99, 97, + 51, 52, 102, 99, 52, 99, 56, 98, 101, 56, 98, 55, 101, 102, 51, 56, 97, 102, 50, 54, 50, + 52, 100, 101, 53, 52, 54, 52, 0, + ]; + let mut test_data = Message::new_with_data(data); + test_data.set_pointer(9); + assert_eq!(test_data.read_string(), ""); +} + +#[test] +#[should_panic(expected = "Failed to read string")] +fn test_read_string_invalid_utf8() { + let data = vec![ + 3, 0, 0, 0, // size = 3 + 255, 255, 255, // invalid UTF-8 sequence + ]; + let mut test_data = Message::new_with_data(data); + test_data.read_string(); +} \ No newline at end of file diff --git a/src/message/peer/file_search_response.rs b/src/message/peer/file_search_response.rs index f73b09a..819dce8 100644 --- a/src/message/peer/file_search_response.rs +++ b/src/message/peer/file_search_response.rs @@ -5,6 +5,7 @@ use std::collections::HashMap; use std::sync::mpsc::Sender; #[derive(Debug)] +#[allow(dead_code)] pub struct File { pub username: String, pub name: String, @@ -12,6 +13,7 @@ pub struct File { pub attribs: HashMap, } #[derive(Debug)] +#[allow(dead_code)] pub struct FileSearch { pub token: String, pub files: Vec, diff --git a/src/message/server/file_search.rs b/src/message/server/file_search.rs index 3f0596e..8559eaf 100644 --- a/src/message/server/file_search.rs +++ b/src/message/server/file_search.rs @@ -1,8 +1,8 @@ use std::sync::mpsc::Sender; -use crate::{ - message::{handlers::MessageHandler, message::Message}, +use crate::{message::handlers::MessageHandler, server::ServerOperation, + message::Message }; pub struct FileSearchHandler; diff --git a/src/message/server/message_factory.rs b/src/message/server/message_factory.rs index 46e5e2b..a128674 100644 --- a/src/message/server/message_factory.rs +++ b/src/message/server/message_factory.rs @@ -1,4 +1,4 @@ -use crate::{message::message::Message, utils::md5}; +use crate::{message::Message, utils::md5}; pub struct MessageFactory; impl MessageFactory { diff --git a/src/peer/default_peer.rs b/src/peer/default_peer.rs index ddfb431..3837642 100644 --- a/src/peer/default_peer.rs +++ b/src/peer/default_peer.rs @@ -7,13 +7,14 @@ use std::sync::mpsc::{Receiver, Sender}; use std::sync::{Arc, Barrier}; use std::thread::{self}; -use super::peer::Peer; +use crate::peer::Peer; use crate::client::ClientOperation; use std::io::{self, Write}; use std::net::TcpStream; use std::net::ToSocketAddrs; use std::time::Duration; +#[allow(dead_code)] pub struct DefaultPeer { peer: Peer, // client_channel: Sender, @@ -45,7 +46,7 @@ impl DefaultPeer { stream.set_write_timeout(Some(Duration::from_secs(5)))?; if let Some(token) = self.peer.token.clone() { stream - .write_all(&MessageFactory::build_watch_user(&token).get_data()) + .write_all(&MessageFactory::build_watch_user(token.as_str()).get_data()) .unwrap(); } self.start_read_write_loops(stream).unwrap(); diff --git a/src/peer/listen.rs b/src/peer/listen.rs index 87a7967..f548118 100644 --- a/src/peer/listen.rs +++ b/src/peer/listen.rs @@ -7,7 +7,7 @@ use crate::server::ServerOperation; pub struct Listen {} impl Listen { - pub fn new(port: u32, server_channel: Sender) { + pub fn start(port: u32, _server_channel: Sender) { println!("starting listener on port {port}"); let listener = TcpListener::bind(format!("0.0.0.0:{port}")).unwrap(); for stream in listener.incoming() { diff --git a/src/peer/mod.rs b/src/peer/mod.rs index abb56ba..05c7ca4 100644 --- a/src/peer/mod.rs +++ b/src/peer/mod.rs @@ -1,4 +1,157 @@ pub mod default_peer; + +pub use default_peer::*; pub mod listen; -pub mod peer; -pub use self::{default_peer::*, peer::*}; + +use crate::message::Message; +use core::fmt; +use std::str::FromStr; + +#[derive(Debug, Clone)] +pub enum ConnectionType { + P, + F, + D, +} + +// Define the error type +#[derive(Debug, Clone)] +pub struct ParseConnectionTypeError; + +impl fmt::Display for ParseConnectionTypeError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "invalid connection type") + } +} + +impl std::error::Error for ParseConnectionTypeError {} + +// Implement FromStr for ConnectionType +impl FromStr for ConnectionType { + type Err = ParseConnectionTypeError; + + fn from_str(s: &str) -> Result { + match s { + "P" => Ok(ConnectionType::P), + "F" => Ok(ConnectionType::F), + "D" => Ok(ConnectionType::D), + _ => Err(ParseConnectionTypeError), + } + } +} + +#[derive(Debug, Clone)] +#[allow(dead_code)] +pub struct Peer { + pub username: String, + pub connection_type: ConnectionType, + pub host: String, + pub port: i32, + pub token: Option, + pub privileged: i8, + pub unknown: i8, + pub obfuscated_port: i8, +} +impl Peer { + #[allow(clippy::too_many_arguments)] + pub fn new( + username: String, + connection_type: ConnectionType, + host: String, + port: i32, + token: String, + privileged: i8, + unknown: i8, + obfuscated_port: i8, + ) -> Self { + Self { + username, + connection_type, + host, + port, + token: Some(token), + privileged, + unknown, + obfuscated_port, + } + } + #[allow(dead_code)] + pub fn new_from_message(message: &mut Message) -> Self { + let username = message.read_string(); + let connection_type: ConnectionType = message.read_string().parse().unwrap(); + + let mut ip: Vec = vec![]; + for _ in 0..4 { + ip.push(message.read_int8().into()); + } + let host: String = format!( + "{}.{}.{}.{}", + ip[3].abs(), + ip[2].abs(), + ip[1].abs(), + ip[0].abs() + ); + + let (port, token, privileged, unknown, obfuscated_port) = ( + message.read_int32(), + message.read_raw_hex_str(4), + message.read_int8(), + message.read_int8(), + message.read_int8(), + ); + + Self { + username, + connection_type, + host, + port, + token: Some(token), + privileged, + unknown, + obfuscated_port, + } + } +} +#[test] +fn test_new_from_message() { + let data: Vec = [ + 36, 0, 0, 0, 18, 0, 0, 0, 2, 0, 0, 0, 100, 112, 1, 0, 0, 0, 80, 27, 231, 37, 45, 186, 8, 0, + 0, 178, 78, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ] + .to_vec(); + let mut message = Message::new_with_data(data); + message.set_pointer(8); + + let peer = Peer::new_from_message(&mut message); + + assert_eq!(peer.username, "dp"); + assert!(matches!(peer.connection_type, ConnectionType::P)); + assert_eq!(peer.host, "45.37.25.27"); + assert_eq!(peer.port, 2234); + assert_eq!(peer.token, Some("b24e1900".to_string())); + assert_eq!(peer.privileged, 0); + assert_eq!(peer.unknown, 0); + assert_eq!(peer.obfuscated_port, 0); +} + +#[test] +fn test_new_from_message2() { + let data: Vec = [ + 42, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 0, 103, 114, 97, 110, 100, 112, 97, 103, 1, 0, 0, 0, 80, + 137, 128, 193, 68, 187, 8, 0, 0, 58, 16, 0, 0, 0, 1, 0, 0, 0, 188, 8, 0, 0, + ] + .to_vec(); + let mut message = Message::new_with_data(data); + message.set_pointer(8); + + let peer = Peer::new_from_message(&mut message); + + assert_eq!(peer.username, "grandpag"); + assert!(matches!(peer.connection_type, ConnectionType::P)); + assert_eq!(peer.host, "68.63.128.119"); + assert_eq!(peer.port, 2235); + assert_eq!(peer.token, Some("3a100000".to_string())); + assert_eq!(peer.privileged, 0); + assert_eq!(peer.unknown, 1); + assert_eq!(peer.obfuscated_port, 0); +} \ No newline at end of file diff --git a/src/peer/peer.rs b/src/peer/peer.rs index a31fdc2..e69de29 100644 --- a/src/peer/peer.rs +++ b/src/peer/peer.rs @@ -1,153 +0,0 @@ -use core::fmt; -use std::str::FromStr; - -use crate::message::Message; - -#[derive(Debug, Clone)] -pub enum ConnectionType { - P, - F, - D, -} - -// Define the error type -#[derive(Debug, Clone)] -pub struct ParseConnectionTypeError; - -impl fmt::Display for ParseConnectionTypeError { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "invalid connection type") - } -} - -impl std::error::Error for ParseConnectionTypeError {} - -// Implement FromStr for ConnectionType -impl FromStr for ConnectionType { - type Err = ParseConnectionTypeError; - - fn from_str(s: &str) -> Result { - match s { - "P" => Ok(ConnectionType::P), - "F" => Ok(ConnectionType::F), - "D" => Ok(ConnectionType::D), - _ => Err(ParseConnectionTypeError), - } - } -} - -#[derive(Debug, Clone)] -#[allow(dead_code)] -pub struct Peer { - pub username: String, - pub connection_type: ConnectionType, - pub host: String, - pub port: i32, - pub token: Option, - pub privileged: i8, - pub unknown: i8, - pub obfuscated_port: i8, -} -impl Peer { - #[allow(dead_code)] - pub fn new( - username: String, - connection_type: ConnectionType, - host: String, - port: i32, - token: String, - privileged: i8, - unknown: i8, - obfuscated_port: i8, - ) -> Self { - Self { - username, - connection_type, - host, - port, - token: Some(token), - privileged, - unknown, - obfuscated_port, - } - } - #[allow(dead_code)] - pub fn new_from_message(message: &mut Message) -> Self { - let username = message.read_string(); - let connection_type: ConnectionType = message.read_string().parse().unwrap(); - - let mut ip: Vec = vec![]; - for _ in 0..4 { - ip.push(message.read_int8().into()); - } - let host: String = format!( - "{}.{}.{}.{}", - ip[3].abs(), - ip[2].abs(), - ip[1].abs(), - ip[0].abs() - ); - - let (port, token, privileged, unknown, obfuscated_port) = ( - message.read_int32(), - message.read_raw_hex_str(4), - message.read_int8(), - message.read_int8(), - message.read_int8(), - ); - - Self { - username, - connection_type, - host, - port, - token: Some(token), - privileged, - unknown, - obfuscated_port, - } - } -} -#[test] -fn test_new_from_message() { - let data: Vec = [ - 36, 0, 0, 0, 18, 0, 0, 0, 2, 0, 0, 0, 100, 112, 1, 0, 0, 0, 80, 27, 231, 37, 45, 186, 8, 0, - 0, 178, 78, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - ] - .to_vec(); - let mut message = Message::new_with_data(data); - message.set_pointer(8); - - let peer = Peer::new_from_message(&mut message); - - assert_eq!(peer.username, "dp"); - assert!(matches!(peer.connection_type, ConnectionType::P)); - assert_eq!(peer.host, "45.37.25.27"); - assert_eq!(peer.port, 2234); - assert_eq!(peer.token, Some("b24e1900".to_string())); - assert_eq!(peer.privileged, 0); - assert_eq!(peer.unknown, 0); - assert_eq!(peer.obfuscated_port, 0); -} - -#[test] -fn test_new_from_message2() { - let data: Vec = [ - 42, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 0, 103, 114, 97, 110, 100, 112, 97, 103, 1, 0, 0, 0, 80, - 137, 128, 193, 68, 187, 8, 0, 0, 58, 16, 0, 0, 0, 1, 0, 0, 0, 188, 8, 0, 0, - ] - .to_vec(); - let mut message = Message::new_with_data(data); - message.set_pointer(8); - - let peer = Peer::new_from_message(&mut message); - - assert_eq!(peer.username, "grandpag"); - assert!(matches!(peer.connection_type, ConnectionType::P)); - assert_eq!(peer.host, "68.63.128.119"); - assert_eq!(peer.port, 2235); - assert_eq!(peer.token, Some("3a100000".to_string())); - assert_eq!(peer.privileged, 0); - assert_eq!(peer.unknown, 1); - assert_eq!(peer.obfuscated_port, 0); -} diff --git a/src/server.rs b/src/server.rs index cb2cbb7..1eddc4c 100644 --- a/src/server.rs +++ b/src/server.rs @@ -15,7 +15,7 @@ use crate::message::Handlers; use crate::message::Message; use crate::message::MessageReader; use crate::peer::listen::Listen; -use crate::peer::peer::Peer; +use crate::peer::Peer; use std::io::{self, Write}; use std::net::{TcpStream, ToSocketAddrs}; @@ -332,7 +332,7 @@ impl Server { } } fn start_listener(&self, server_channel: Sender) { - thread::spawn(move || Listen::new(2234, server_channel)); + thread::spawn(move || Listen::start(2234, server_channel)); } pub fn login(&self, username: &str, password: &str) -> Result { diff --git a/src/utils/md5.rs b/src/utils/md5.rs index 7921eb2..70fdfad 100644 --- a/src/utils/md5.rs +++ b/src/utils/md5.rs @@ -71,8 +71,8 @@ fn round_one_operations( mut b: u32, mut c: u32, mut d: u32, - table: &Vec, - x: &Vec, + table: &[u32], + x: &[u32], ) -> [u32; 4] { let _ = x; let _ = table; @@ -119,8 +119,8 @@ fn round_two_operations( mut b: u32, mut c: u32, mut d: u32, - table: &Vec, - x: &Vec, + table: &[u32], + x: &[u32], ) -> [u32; 4] { macro_rules! round2 { ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i:expr) => { @@ -165,8 +165,8 @@ fn round_three_operations( mut b: u32, mut c: u32, mut d: u32, - table: &Vec, - x: &Vec, + table: &[u32], + x: &[u32], ) -> [u32; 4] { macro_rules! round3 { ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i:expr ) => { @@ -211,8 +211,8 @@ fn round_four_operations( mut b: u32, mut c: u32, mut d: u32, - table: &Vec, - x: &Vec, + table: &[u32], + x: &[u32], ) -> [u32; 4] { macro_rules! round4 { ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i:expr ) => { @@ -260,8 +260,8 @@ fn convert_u8_chunk_to_u32(chunk: &mut [u8]) -> Vec { // iterate over our block and take // our 8 bit ints and convert them to // 32 bit integers - for i in 0..chunk.len() { - temporary_vec.push(chunk[i]); + for item in chunk { + temporary_vec.push(*item); count += 1; if count == 4 { let temp_arr: [u8; 4] = vec_to_array(temporary_vec.clone()); diff --git a/src/utils/zlib.rs b/src/utils/zlib.rs index d95a1bf..bec3d1f 100644 --- a/src/utils/zlib.rs +++ b/src/utils/zlib.rs @@ -291,15 +291,11 @@ fn decode_trees(r: &mut BitReader) -> Result<(HuffmanTree, HuffmanTree), String> } else if sym == 17 { // repeat code length 0 for 3..10 times. (3 bits of length) let repeat_length = r.read_bits(3)? + 3; - for _ in 0..repeat_length { - bl.push(0); - } + bl.resize(bl.len() + repeat_length as usize, 0); } else if sym == 18 { // repeat code length 0 for 11..138 times. (7 bits of length) let repeat_length = r.read_bits(7)? + 11; - for _ in 0..repeat_length { - bl.push(0); - } + bl.resize(bl.len() + repeat_length as usize, 0); } else { return Err("Invalid symbol".to_string()); } @@ -362,8 +358,8 @@ mod tests { #[test] fn test_extract_header_success() { - let data = vec![120, 156]; // Valid zlib header - let result = deflate(&vec![120, 156, 3, 0, 0, 0, 0, 1]); // Minimal valid zlib stream + let _data = [120, 156]; // Valid zlib header + let result = deflate(&[120, 156, 3, 0, 0, 0, 0, 1]); // Minimal valid zlib stream assert!(result.is_ok()); }