feat: seperate into lib and cli packages
This commit is contained in:
Michel de Graaf
@@ -0,0 +1,40 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::message::Message;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub trait MessageHandler<Op>: Send {
|
||||
fn get_code(&self) -> u8;
|
||||
fn handle(&self, message: &mut Message, sender: Sender<Op>);
|
||||
}
|
||||
pub struct Handlers<Op> {
|
||||
handlers: HashMap<u8, Box<dyn MessageHandler<Op> + Send>>,
|
||||
}
|
||||
|
||||
impl<Op> Default for Handlers<Op> {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl<Op> Handlers<Op> {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
handlers: HashMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn register_handler<H>(&mut self, handler: H) -> &mut Self
|
||||
where
|
||||
H: 'static + MessageHandler<Op> + Send + Sync,
|
||||
{
|
||||
self.handlers.insert(handler.get_code(), Box::new(handler));
|
||||
self
|
||||
}
|
||||
pub fn get_handler(
|
||||
&self,
|
||||
code: u8,
|
||||
) -> Option<&(dyn MessageHandler<Op> + Send)> {
|
||||
self.handlers.get(&code).map(|v| &**v)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,137 @@
|
||||
use std::io::{self, Read};
|
||||
use std::{collections::VecDeque, net::TcpStream};
|
||||
|
||||
use crate::message::Message;
|
||||
|
||||
// # why buffered message reader?
|
||||
// the stream comes in chunks of bytes: 1024 for example
|
||||
// the soulseek protocol has binary messages
|
||||
// the first 4 bytes of the message represent the message size
|
||||
// the rest of the bytes represent the message itself
|
||||
//
|
||||
// # how to implement the buffered message reader?
|
||||
// read 4 bytes from the stream
|
||||
// if the stream has less than 4 bytes, buffer then add the rest of the bytes to the buffered
|
||||
// message reader buffer and return
|
||||
// if the stream has 4 bytes, read the message size
|
||||
// if the stream is as long as the message size + 4 bytes, read the message
|
||||
// create a new message struct and read the message size from the buffer, thats a message
|
||||
// the rest of the bytes are the next message so you call the read function again with the rest of the bytes
|
||||
// else
|
||||
// buffer the rest of the bytes and return
|
||||
//
|
||||
//
|
||||
//
|
||||
|
||||
pub struct MessageReader {
|
||||
buffer: VecDeque<u8>,
|
||||
}
|
||||
|
||||
impl Default for MessageReader {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl MessageReader {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
buffer: VecDeque::new(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub fn new_with_buffer(buffer: Vec<u8>) -> Self {
|
||||
Self {
|
||||
buffer: buffer.into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_from_socket(
|
||||
&mut self,
|
||||
stream: &mut TcpStream,
|
||||
) -> io::Result<()> {
|
||||
let mut temp_buffer = [0; 1024]; // Temporary buffer for reading from the socket
|
||||
let bytes_read = stream.read(&mut temp_buffer)?;
|
||||
if bytes_read == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Add the read bytes to the internal buffer
|
||||
self.buffer.extend(&temp_buffer[..bytes_read]);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn buffer_len(&self) -> usize {
|
||||
self.buffer.len()
|
||||
}
|
||||
|
||||
pub fn get_buffer(&mut self) -> Vec<u8> {
|
||||
self.buffer.drain(..).collect()
|
||||
}
|
||||
|
||||
pub fn extract_message(&mut self) -> io::Result<Option<Message>> {
|
||||
let bytes_read = self.buffer.len();
|
||||
if bytes_read < 4 {
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
let message_size = u32::from_le_bytes([
|
||||
self.buffer[0],
|
||||
self.buffer[1],
|
||||
self.buffer[2],
|
||||
self.buffer[3],
|
||||
]) as usize;
|
||||
|
||||
let total_size = message_size + 4;
|
||||
|
||||
if bytes_read < total_size {
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
let message_buffer: Vec<u8> = self.buffer.drain(..total_size).collect();
|
||||
Ok(Some(Message::new_with_data(message_buffer)))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::message::MessageReader;
|
||||
|
||||
#[test]
|
||||
fn test_extract_message() {
|
||||
let buffer: Vec<u8> = [
|
||||
8, 0, 0, 0, 117, 115, 101, 114, 110, 97, 109, 101, 8, 0, 0, 0, 112,
|
||||
97, 115, 115, 119, 111, 114, 100, 160, 0, 0, 0, 32, 0, 0, 0, 100,
|
||||
53, 49, 99, 57, 97, 55, 101, 57, 51, 53, 51, 55, 52, 54, 97, 54,
|
||||
48, 50, 48, 102, 57, 54, 48, 50, 100, 52, 53, 50, 57, 50, 57, 17,
|
||||
0, 0, 0,
|
||||
]
|
||||
.to_vec();
|
||||
let mut buffered_reader = MessageReader::new_with_buffer(buffer);
|
||||
let mut message = buffered_reader.extract_message().unwrap().unwrap();
|
||||
assert_eq!(
|
||||
message.get_data(),
|
||||
vec![8, 0, 0, 0, 117, 115, 101, 114, 110, 97, 109, 101]
|
||||
);
|
||||
assert_eq!(message.read_string(), "username");
|
||||
}
|
||||
#[test]
|
||||
fn test_extract_message_incomplete_message() {
|
||||
let incomplete_buffer = vec![1, 2, 3];
|
||||
let mut buffered_reader =
|
||||
MessageReader::new_with_buffer(incomplete_buffer);
|
||||
|
||||
let result = buffered_reader.extract_message();
|
||||
assert_eq!(None, result.unwrap());
|
||||
|
||||
let rest: Vec<u8> = buffered_reader
|
||||
.buffer
|
||||
.drain(..buffered_reader.buffer.len())
|
||||
.collect();
|
||||
|
||||
assert!(buffered_reader.buffer.is_empty());
|
||||
assert_eq!(vec![1, 2, 3], rest);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,483 @@
|
||||
pub use crate::{debug, error, info, trace, warn};
|
||||
|
||||
pub mod handlers;
|
||||
mod message_reader;
|
||||
pub mod peer;
|
||||
pub mod server;
|
||||
|
||||
pub use handlers::{Handlers, MessageHandler};
|
||||
pub use message_reader::MessageReader;
|
||||
|
||||
use std::str;
|
||||
|
||||
#[derive(Debug, PartialEq)]
|
||||
#[allow(dead_code)]
|
||||
pub enum MessageType {
|
||||
Server,
|
||||
Peer,
|
||||
PeerInit,
|
||||
Distributed,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Error(String);
|
||||
|
||||
impl std::fmt::Display for Error {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "{}", self.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for Error {}
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub struct Message {
|
||||
data: Vec<u8>,
|
||||
pointer: usize,
|
||||
}
|
||||
|
||||
impl Default for Message {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
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!(" ");
|
||||
}
|
||||
}
|
||||
|
||||
trace!("");
|
||||
}
|
||||
}
|
||||
//
|
||||
// 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 get_message_code_send(&self) -> u8 {
|
||||
self.data[0]
|
||||
}
|
||||
|
||||
pub fn new_with_data(data: Vec<u8>) -> Self {
|
||||
Self { data, pointer: 0 }
|
||||
}
|
||||
#[allow(dead_code)]
|
||||
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<u8> {
|
||||
self.data.clone()
|
||||
}
|
||||
|
||||
pub fn get_slice(&self, from: usize, to: usize) -> Vec<u8> {
|
||||
self.data[from..to].to_vec()
|
||||
}
|
||||
|
||||
/// gets buffer with the message length prepended
|
||||
pub fn get_buffer(&self) -> Vec<u8> {
|
||||
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;
|
||||
|
||||
match String::from_utf8(data.to_vec()) {
|
||||
Ok(s) => s,
|
||||
Err(_) => data.iter().map(|&b| b as char).collect::<String>(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn read_int8(&mut self) -> u8 {
|
||||
let val = self.data[self.pointer];
|
||||
self.pointer += 1;
|
||||
val
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn read_int64(&mut self) -> u64 {
|
||||
let val = u64::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_raw_byte(&mut self) -> Vec<u8> {
|
||||
if self.pointer + 4 > self.data.len() {
|
||||
return vec![];
|
||||
}
|
||||
|
||||
let val = vec![
|
||||
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_int32(&mut self) -> u32 {
|
||||
if self.pointer + 4 > self.data.len() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
let val = u32::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_int8(&mut self, value: u8) -> &mut Self {
|
||||
self.data.extend_from_slice(&value.to_le_bytes());
|
||||
self
|
||||
}
|
||||
|
||||
pub fn write_int32(&mut self, value: u32) -> &mut Self {
|
||||
self.data.extend_from_slice(&value.to_le_bytes());
|
||||
self
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn write_int64(&mut self, value: u64) -> &mut Self {
|
||||
self.data.extend_from_slice(&value.to_le_bytes());
|
||||
self
|
||||
}
|
||||
pub fn write_raw_bytes(&mut self, value: Vec<u8>) -> &mut Self {
|
||||
self.data.extend_from_slice(&value);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn write_bool(&mut self, value: bool) -> &mut Self {
|
||||
self.data.push(if value { 1 } else { 0 });
|
||||
self
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
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 get_message_name(
|
||||
&self,
|
||||
msg_type: MessageType,
|
||||
code: u32,
|
||||
) -> Result<&str, Error> {
|
||||
match msg_type {
|
||||
MessageType::Server => match code {
|
||||
1 => Ok("Login"),
|
||||
2 => Ok("SetWaitPort"),
|
||||
3 => Ok("GetPeerAddress"),
|
||||
5 => Ok("WatchUser"),
|
||||
6 => Ok("UnwatchUser"),
|
||||
7 => Ok("GetUserStatus"),
|
||||
13 => Ok("SayChatroom"),
|
||||
14 => Ok("JoinRoom"),
|
||||
15 => Ok("LeaveRoom"),
|
||||
18 => Ok("ConnectToPeer"),
|
||||
22 => Ok("MessageUser"),
|
||||
23 => Ok("MessageAcked"),
|
||||
26 => Ok("FileSearch"),
|
||||
28 => Ok("SetStatus"),
|
||||
32 => Ok("ServerPing"),
|
||||
35 => Ok("SharedFoldersFiles"),
|
||||
36 => Ok("GetUserStats"),
|
||||
41 => Ok("Relogged"),
|
||||
42 => Ok("UserSearch"),
|
||||
64 => Ok("RoomList"),
|
||||
69 => Ok("PrivilegedUsers"),
|
||||
71 => Ok("HaveNoParent"),
|
||||
83 => Ok("ParentMinSpeed"),
|
||||
84 => Ok("ParentSpeedRatio"),
|
||||
92 => Ok("CheckPrivileges"),
|
||||
93 => Ok("EmbeddedMessage"),
|
||||
100 => Ok("AcceptChildren"),
|
||||
102 => Ok("PossibleParents"),
|
||||
104 => Ok("WishlistInterval"),
|
||||
160 => Ok("ExcludedSearchPhrases"),
|
||||
1001 => Ok("CantConnectToPeer"),
|
||||
_ => {
|
||||
Err(Error(format!("Unknown server message code: {}", code)))
|
||||
}
|
||||
},
|
||||
MessageType::PeerInit => match code {
|
||||
0 => Ok("PierceFireWall"),
|
||||
1 => Ok("PeerInit"),
|
||||
_ => Err(Error(format!(
|
||||
"Unknown peer init message code: {}",
|
||||
code
|
||||
))),
|
||||
},
|
||||
MessageType::Peer => match code {
|
||||
1 => Ok("PeerInit"),
|
||||
4 => Ok("GetShareFileList"),
|
||||
5 => Ok("SharedFileListResponse"),
|
||||
9 => Ok("FileSearchResponse"),
|
||||
15 => Ok("UserInfoRequest"),
|
||||
16 => Ok("UserInfoResponse"),
|
||||
36 => Ok("FolderContentsRequest"),
|
||||
37 => Ok("FolderContentsResponse"),
|
||||
40 => Ok("TransferRequest"),
|
||||
41 => Ok("TransferResponse"),
|
||||
43 => Ok("QueueUpload"),
|
||||
44 => Ok("PlaceInQueueResponse"),
|
||||
46 => Ok("UploadFailed"),
|
||||
50 => Ok("UploadDenied"),
|
||||
51 => Ok("PlaceInQueueRequest"),
|
||||
_ => Err(Error(format!("Unknown peer message code: {}", code))),
|
||||
},
|
||||
MessageType::Distributed => match code {
|
||||
3 => Ok("SearchRequest"),
|
||||
4 => Ok("BranchLevel"),
|
||||
5 => Ok("BranchRoot"),
|
||||
93 => Ok("EmbeddedMessage"),
|
||||
_ => Err(Error(format!(
|
||||
"Unknown distributed message code: {}",
|
||||
code
|
||||
))),
|
||||
},
|
||||
}
|
||||
}
|
||||
// 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]
|
||||
fn test_read_string_invalid_utf82() {
|
||||
let data = [
|
||||
128, 0, 0, 0, 103, 58, 92, 100, 105, 115, 107, 52, 92, 115, 101, 109,
|
||||
105, 114, 97, 109, 105, 115, 92, 99, 104, 105, 108, 108, 44, 32, 100,
|
||||
117, 98, 44, 32, 100, 111, 119, 110, 98, 101, 97, 116, 44, 32, 97, 109,
|
||||
98, 105, 101, 110, 116, 92, 118, 97, 114, 105, 111, 117, 115, 32, 97,
|
||||
114, 116, 105, 115, 116, 115, 92, 112, 111, 116, 116, 32, 104, 101, 97,
|
||||
100, 122, 32, 45, 32, 100, 111, 112, 101, 32, 115, 109, 111, 107, 105,
|
||||
110, 180, 98, 101, 97, 116, 115, 32, 107, 98, 115, 32, 49, 50, 56, 32,
|
||||
49, 57, 57, 54, 92, 48, 53, 32, 45, 32, 98, 108, 117, 101, 32, 116,
|
||||
114, 97, 105, 110, 46, 109, 112, 51,
|
||||
]
|
||||
.to_vec();
|
||||
|
||||
let mut test_data = Message::new_with_data(data);
|
||||
let str = test_data.read_string();
|
||||
assert_eq!(
|
||||
str,
|
||||
r"g:\disk4\semiramis\chill, dub, downbeat, ambient\various artists\pott headz - dope smokin´beats kbs 128 1996\05 - blue train.mp3"
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
use crate::message::{Message, MessageHandler};
|
||||
use crate::peer::PeerMessage;
|
||||
use crate::types::FileSearchResult;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct FileSearchResponse;
|
||||
impl MessageHandler<PeerMessage> for FileSearchResponse {
|
||||
fn get_code(&self) -> u8 {
|
||||
9
|
||||
}
|
||||
fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
|
||||
let file_search = match FileSearchResult::new_from_message(message) {
|
||||
Ok(result) => result,
|
||||
Err(_) => return, // Skip malformed search results
|
||||
};
|
||||
|
||||
sender
|
||||
.send(PeerMessage::FileSearchResult(file_search))
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_new_from_message() {
|
||||
let data: Vec<u8> = [
|
||||
229, 0, 0, 0, 9, 0, 0, 0, 120, 156, 99, 103, 96, 96, 72, 201, 79, 201,
|
||||
76, 79, 204, 203, 213, 158, 98, 194, 4, 228, 50, 250, 3, 9, 7, 135,
|
||||
162, 156, 148, 194, 188, 152, 228, 252, 220, 130, 156, 212, 146, 212,
|
||||
24, 231, 196, 188, 228, 204, 252, 188, 212, 226, 152, 144, 162, 210,
|
||||
226, 226, 212, 28, 93, 67, 75, 115, 75, 93, 119, 160, 144, 130, 91,
|
||||
126, 145, 66, 72, 70, 170, 66, 120, 106, 106, 118, 106, 94, 138, 174,
|
||||
161, 89, 82, 102, 137, 174, 137, 137, 142, 161, 119, 70, 149, 94, 90,
|
||||
78, 98, 114, 203, 175, 243, 32, 163, 193, 128, 25, 100, 7, 16, 23, 0,
|
||||
9, 22, 32, 237, 178, 134, 129, 129, 21, 72, 11, 128, 196, 243, 176,
|
||||
217, 29, 156, 153, 151, 158, 147, 90, 12, 54, 95, 193, 216, 84, 193,
|
||||
200, 192, 200, 36, 198, 45, 181, 168, 40, 53, 57, 91, 193, 37, 177, 60,
|
||||
79, 71, 193, 55, 177, 44, 181, 40, 19, 200, 13, 78, 76, 42, 74, 85, 80,
|
||||
83, 240, 75, 45, 7, 10, 38, 103, 100, 2, 221, 167, 139, 238, 66, 5, 13,
|
||||
144, 17, 154, 96, 167, 173, 228, 215, 98, 68, 119, 218, 74, 6, 76, 167,
|
||||
49, 60, 153, 202, 200, 160, 199, 128, 0, 0, 161, 99, 76, 142,
|
||||
]
|
||||
.to_vec();
|
||||
let mut message = Message::new_with_data(data);
|
||||
message.set_pointer(8);
|
||||
|
||||
let file_search = FileSearchResult::new_from_message(&mut message).unwrap();
|
||||
assert_eq!(file_search.token, 882125677);
|
||||
assert_eq!(file_search.files.len(), 2);
|
||||
let file = &file_search.files[0];
|
||||
assert_eq!(
|
||||
file.name,
|
||||
"@@rldqn\\complete\\Canciones\\Trussel-1979-Gone For The Weekend-16bit-44,1Khz.flac"
|
||||
);
|
||||
assert_eq!(file.username, "dodigan");
|
||||
assert_eq!(file.size, 47184516);
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
use crate::{
|
||||
message::{server::MessageFactory, Message, MessageHandler},
|
||||
peer::PeerMessage,
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct GetShareFileList;
|
||||
impl MessageHandler<PeerMessage> for GetShareFileList {
|
||||
fn get_code(&self) -> u8 {
|
||||
4
|
||||
}
|
||||
fn handle(&self, _message: &mut Message, sender: Sender<PeerMessage>) {
|
||||
let message = MessageFactory::build_shared_folders_message(100, 800);
|
||||
|
||||
sender.send(PeerMessage::SendMessage(message)).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
mod file_search_response;
|
||||
mod get_share_file_list;
|
||||
mod peer_init;
|
||||
mod place_in_queue_response;
|
||||
mod transfer_request;
|
||||
mod transfer_response;
|
||||
mod upload_failed;
|
||||
|
||||
// Re-export handlers
|
||||
pub use file_search_response::FileSearchResponse;
|
||||
pub use get_share_file_list::GetShareFileList;
|
||||
pub use peer_init::PeerInit;
|
||||
pub use place_in_queue_response::PlaceInQueueResponse;
|
||||
pub use transfer_request::TransferRequest;
|
||||
pub use transfer_response::TransferResponse;
|
||||
pub use upload_failed::UploadFailedHandler;
|
||||
@@ -0,0 +1,30 @@
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::{
|
||||
message::{Message, MessageHandler},
|
||||
peer::PeerMessage,
|
||||
trace,
|
||||
};
|
||||
|
||||
pub struct PeerInit;
|
||||
impl MessageHandler<PeerMessage> for PeerInit {
|
||||
fn get_code(&self) -> u8 {
|
||||
1
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
|
||||
message.set_pointer(4);
|
||||
let _message_code = message.read_int8();
|
||||
let username = message.read_string();
|
||||
let connection_type = message.read_string();
|
||||
let token = message.read_int32();
|
||||
trace!(
|
||||
"PeerInit: username: {}, connection_type: {}, token: {}",
|
||||
username,
|
||||
connection_type,
|
||||
token
|
||||
);
|
||||
|
||||
sender.send(PeerMessage::SetUsername(username)).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
use crate::{
|
||||
message::{Message, MessageHandler},
|
||||
peer::PeerMessage,
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct PlaceInQueueResponse;
|
||||
|
||||
impl MessageHandler<PeerMessage> for PlaceInQueueResponse {
|
||||
fn get_code(&self) -> u8 {
|
||||
43
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
|
||||
let filename = message.read_string();
|
||||
let place = message.read_int32();
|
||||
|
||||
sender
|
||||
.send(PeerMessage::PlaceInQueueResponse { filename, place })
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
use crate::{
|
||||
message::{Message, MessageHandler},
|
||||
peer::PeerMessage,
|
||||
types::Transfer,
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct TransferRequest;
|
||||
impl MessageHandler<PeerMessage> for TransferRequest {
|
||||
fn get_code(&self) -> u8 {
|
||||
40
|
||||
}
|
||||
fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
|
||||
let transfer = Transfer::new_from_message(message);
|
||||
|
||||
sender.send(PeerMessage::TransferRequest(transfer)).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
use crate::{
|
||||
message::{Message, MessageHandler},
|
||||
peer::PeerMessage,
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct TransferResponse;
|
||||
|
||||
impl MessageHandler<PeerMessage> for TransferResponse {
|
||||
fn get_code(&self) -> u8 {
|
||||
41
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, sender: Sender<PeerMessage>) {
|
||||
let token = message.read_int32();
|
||||
let allowed = message.read_int8();
|
||||
let reason = (allowed == 0).then(|| message.read_string());
|
||||
|
||||
sender
|
||||
.send(PeerMessage::TransferResponse {
|
||||
token,
|
||||
allowed: allowed == 1,
|
||||
reason,
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
use crate::info;
|
||||
use crate::{
|
||||
message::{Message, MessageHandler},
|
||||
peer::PeerMessage,
|
||||
types::UploadFailed,
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct UploadFailedHandler;
|
||||
impl MessageHandler<PeerMessage> for UploadFailedHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
46
|
||||
}
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<PeerMessage>) {
|
||||
let upload_failed = UploadFailed::new_from_message(message);
|
||||
info!("Upload failed for ${}", upload_failed.filename);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
use crate::actor::server_actor::ServerMessage;
|
||||
use crate::message::{Message, MessageHandler};
|
||||
use crate::peer::Peer;
|
||||
use std::sync::mpsc::Sender;
|
||||
pub struct ConnectToPeerHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for ConnectToPeerHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
18
|
||||
}
|
||||
fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
|
||||
let peer = Peer::new_from_message(message);
|
||||
sender.send(ServerMessage::ConnectToPeer(peer)).unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
use crate::debug;
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage,
|
||||
message::{Message, MessageHandler},
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct ExcludedSearchPhrasesHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for ExcludedSearchPhrasesHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
160
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
let item_count = message.read_int32();
|
||||
|
||||
let mut exluded_phrases: Vec<String> = Vec::new();
|
||||
for _ in 0..item_count {
|
||||
// Read the file name, size, and path (structure can vary)
|
||||
let phrase = message.read_string();
|
||||
exluded_phrases.push(phrase);
|
||||
}
|
||||
debug!("Excluded search phrases: {:?}", exluded_phrases);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
use crate::{debug, info};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage, message::handlers::MessageHandler,
|
||||
message::Message,
|
||||
};
|
||||
|
||||
pub struct FileSearchHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for FileSearchHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
26
|
||||
}
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
debug!("Handling file search message");
|
||||
let username = message.read_string();
|
||||
let token = message.read_int32();
|
||||
let query = message.read_string();
|
||||
info!(
|
||||
"Message search username:{}, token: {}, query: {}",
|
||||
username, token, query
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
use crate::actor::server_actor::ServerMessage;
|
||||
use crate::message::{Message, MessageHandler};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct GetPeerAddressHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for GetPeerAddressHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
3
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
|
||||
let username = message.read_string();
|
||||
|
||||
// Read IP address as 4 bytes
|
||||
let mut ip: Vec<u8> = vec![];
|
||||
for _ in 0..4 {
|
||||
ip.push(message.read_int8());
|
||||
}
|
||||
let host = format!("{}.{}.{}.{}", ip[3], ip[2], ip[1], ip[0]);
|
||||
|
||||
let port = message.read_int32();
|
||||
let obfuscation_type = message.read_int32();
|
||||
let obfuscated_port = message.read_int32() as u16;
|
||||
println!("GetPeerAddressHandler: {:?}", username); // Debug print
|
||||
|
||||
sender
|
||||
.send(ServerMessage::GetPeerAddressResponse {
|
||||
username,
|
||||
host,
|
||||
port,
|
||||
obfuscation_type,
|
||||
obfuscated_port,
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage, debug, info, message::Message,
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::message::MessageHandler;
|
||||
|
||||
pub struct LoginHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for LoginHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
1
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
|
||||
let response = message.read_int8();
|
||||
|
||||
if response != 1 {
|
||||
return sender.send(ServerMessage::LoginStatus(false)).unwrap();
|
||||
}
|
||||
|
||||
info!("Login successful");
|
||||
let greeting = message.read_string();
|
||||
debug!("Server greeting: {:?}", greeting);
|
||||
|
||||
sender.send(ServerMessage::LoginStatus(true)).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// fn build_login_response_message() -> Message {
|
||||
// return Message::new_with_data([
|
||||
// 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,
|
||||
// ]);
|
||||
// }
|
||||
// #[test]
|
||||
// fn test_can_handle() {
|
||||
// assert_eq!(true, LoginHandler.can_handle(build_login_response_message());
|
||||
// );
|
||||
// }
|
||||
@@ -0,0 +1,171 @@
|
||||
use crate::{
|
||||
message::Message, peer::ConnectionType, types::Transfer, utils::md5::md5,
|
||||
};
|
||||
|
||||
pub struct MessageFactory;
|
||||
impl MessageFactory {
|
||||
pub fn build_get_peer_address(username: &str) -> Message {
|
||||
let mut message = Message::new();
|
||||
|
||||
message.write_int32(3);
|
||||
message.write_string(username);
|
||||
message
|
||||
}
|
||||
pub fn build_login_message(username: &str, password: &str) -> 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,
|
||||
// //0, // 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(),
|
||||
// )
|
||||
// .clone()fac
|
||||
let hash = md5([username, password].join("").as_str());
|
||||
|
||||
let mut message = Message::new();
|
||||
|
||||
message
|
||||
.write_int32(1)
|
||||
.write_string(username)
|
||||
.write_string(password)
|
||||
.write_int32(157) // version
|
||||
.write_string(&hash)
|
||||
.write_int32(100)
|
||||
.clone()
|
||||
}
|
||||
|
||||
pub fn build_shared_folders_message(
|
||||
folder_count: u32,
|
||||
file_count: u32,
|
||||
) -> Message {
|
||||
Message::new()
|
||||
.write_int32(35)
|
||||
.write_int32(folder_count)
|
||||
.write_int32(file_count)
|
||||
.clone()
|
||||
}
|
||||
pub fn build_file_search_message(token: u32, query: &str) -> Message {
|
||||
Message::new()
|
||||
.write_int32(26)
|
||||
.write_int32(token)
|
||||
.write_string(query)
|
||||
.clone()
|
||||
}
|
||||
pub fn build_set_status_message(status_code: u32) -> Message {
|
||||
Message::new()
|
||||
.write_int32(28)
|
||||
.write_int32(status_code)
|
||||
.clone()
|
||||
}
|
||||
pub fn build_no_parent_message() -> Message {
|
||||
Message::new().write_int32(71).write_bool(true).clone()
|
||||
}
|
||||
pub fn build_set_wait_port_message(port: u32) -> Message {
|
||||
Message::new()
|
||||
.write_int32(2)
|
||||
.write_int32(port)
|
||||
// .write_int32(0)
|
||||
// .write_int32(port) // should be different port
|
||||
.clone()
|
||||
}
|
||||
pub fn build_watch_user(token: u32) -> Message {
|
||||
Message::new()
|
||||
.write_raw_bytes([5, 0, 0, 0, 0].to_vec())
|
||||
.write_int32(token)
|
||||
.clone()
|
||||
}
|
||||
|
||||
pub fn build_queue_upload_message(filename: &str) -> Message {
|
||||
Message::new()
|
||||
.write_int32(43)
|
||||
.write_string(filename)
|
||||
.clone()
|
||||
}
|
||||
|
||||
pub fn build_transfer_request_message(
|
||||
filename: &str,
|
||||
token: u32,
|
||||
) -> Message {
|
||||
Message::new()
|
||||
.write_int32(40) // code
|
||||
.write_int32(0) // direction
|
||||
.write_int32(token)
|
||||
.write_string(filename)
|
||||
.clone()
|
||||
}
|
||||
pub fn build_transfer_response_message(transfer: Transfer) -> Message {
|
||||
Message::new()
|
||||
.write_int32(41)
|
||||
.write_int32(transfer.token)
|
||||
.write_bool(true)
|
||||
// .write_int64(transfer.size)
|
||||
.clone()
|
||||
}
|
||||
pub fn build_pierce_firewall_message(token: u32) -> Message {
|
||||
Message::new()
|
||||
.write_int8(0) // PierceFirewall message code
|
||||
.write_int32(token)
|
||||
.clone()
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub fn build_peer_init_message(
|
||||
own_username: &str,
|
||||
connection_type: ConnectionType,
|
||||
token: u32,
|
||||
) -> Message {
|
||||
Message::new()
|
||||
.write_int8(1)
|
||||
.write_string(own_username)
|
||||
.write_string(&connection_type.to_string())
|
||||
.write_int32(token)
|
||||
.clone()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_watch_user() {
|
||||
let token: u32 = 223;
|
||||
let message = MessageFactory::build_watch_user(token);
|
||||
let expect: Vec<u8> = [5, 0, 0, 0, 0, 223, 0, 0, 0].to_vec();
|
||||
|
||||
assert_eq!(expect, message.get_data())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_login_message() {
|
||||
let message =
|
||||
MessageFactory::build_login_message("insane_in_the_brain2", "13375137");
|
||||
|
||||
let expect: Vec<u8> = [
|
||||
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, 157, 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, 100, 0, 0, 0,
|
||||
]
|
||||
.to_vec();
|
||||
|
||||
// println!("{:?}", print_hex(message.get_data()));
|
||||
// assert_eq!(expect, message.get_data());
|
||||
assert_eq!(expect, message.get_data())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_file_search_message() {
|
||||
let message = MessageFactory::build_file_search_message(12, "trance wax");
|
||||
let expect: Vec<u8> = [
|
||||
26, 0, 0, 0, 12, 0, 0, 0, 10, 0, 0, 0, 116, 114, 97, 110, 99, 101, 32,
|
||||
119, 97, 120,
|
||||
]
|
||||
.to_vec();
|
||||
assert_eq!(expect, message.get_data())
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
use crate::actor::server_actor::{ServerMessage, UserMessage};
|
||||
use crate::info;
|
||||
use crate::message::{Message, MessageHandler};
|
||||
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct MessageUser;
|
||||
|
||||
impl MessageHandler<ServerMessage> for MessageUser {
|
||||
fn get_code(&self) -> u8 {
|
||||
22
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
let id = message.read_int32();
|
||||
let timestamp = message.read_int32();
|
||||
let username = message.read_string();
|
||||
let message_content = message.read_string();
|
||||
let new_message = message.read_bool();
|
||||
let user_message = UserMessage::new(
|
||||
id,
|
||||
timestamp,
|
||||
username.clone(),
|
||||
message_content,
|
||||
new_message,
|
||||
);
|
||||
|
||||
info!("[MessageUser] User message received:{:?}", user_message);
|
||||
user_message.print()
|
||||
}
|
||||
}
|
||||
|
||||
// #[cfg(test)]
|
||||
// use std::sync::mpsc;
|
||||
// #[cfg(test)]
|
||||
// use std::sync::mpsc::{Receiver, Sender};
|
||||
//
|
||||
// #[test]
|
||||
// fn test_handle() {
|
||||
// let (message_sender, _message_reader): (Sender<Message>, Receiver<Message>) = mpsc::channel();
|
||||
//
|
||||
// let context = Arc::new(Mutex::new(Context::new(Arc::new(Mutex::new(
|
||||
// message_sender,
|
||||
// )))));
|
||||
// let mut message = Message::new_with_data(vec![
|
||||
// 254, 0, 0, 0, 22, 0, 0, 0, 153, 102, 47, 0, 58, 65, 228, 102, 6, 0, 0, 0, 115, 101, 114,
|
||||
// 118, 101, 114, 227, 0, 0, 0, 89, 111, 117, 114, 32, 99, 111, 110, 110, 101, 99, 116, 105,
|
||||
// 111, 110, 32, 105, 115, 32, 114, 101, 115, 116, 114, 105, 99, 116, 101, 100, 58, 32, 89,
|
||||
// 111, 117, 32, 99, 97, 110, 110, 111, 116, 32, 115, 101, 97, 114, 99, 104, 32, 111, 114, 32,
|
||||
// 99, 104, 97, 116, 46, 32, 89, 111, 117, 114, 32, 99, 108, 105, 101, 110, 116, 32, 118, 101,
|
||||
// 114, 115, 105, 111, 110, 32, 105, 115, 32, 116, 111, 111, 32, 111, 108, 100, 46, 32, 89,
|
||||
// 111, 117, 32, 110, 101, 101, 100, 32, 116, 111, 32, 117, 112, 103, 114, 97, 100, 101, 32,
|
||||
// 116, 111, 32, 116, 104, 101, 32, 108, 97, 116, 101, 115, 116, 32, 118, 101, 114, 115, 105,
|
||||
// 111, 110, 46, 32, 67, 108, 111, 115, 101, 32, 116, 104, 105, 115, 32, 99, 108, 105, 101,
|
||||
// 110, 116, 44, 32, 100, 111, 119, 110, 108, 111, 97, 100, 32, 110, 101, 119, 32, 118, 101,
|
||||
// 114, 115, 105, 111, 110, 32, 102, 114, 111, 109, 32, 104, 116, 116, 112, 58, 47, 47, 119,
|
||||
// 119, 119, 46, 115, 108, 115, 107, 110, 101, 116, 46, 111, 114, 103, 44, 32, 105, 110, 115,
|
||||
// 116, 97, 108, 108, 32, 105, 116, 32, 97, 110, 100, 32, 114, 101, 99, 111, 110, 110, 101,
|
||||
// 99, 116, 46, 1,
|
||||
// ]);
|
||||
// message.set_pointer(8);
|
||||
// MessageUser.handle(&mut message.clone(), context.clone());
|
||||
// assert_eq!(1, context.lock().unwrap().get_user_messages().len());
|
||||
// }
|
||||
// // }
|
||||
@@ -0,0 +1,25 @@
|
||||
mod connect_to_peer;
|
||||
mod excluded_search_phrases;
|
||||
mod file_search;
|
||||
mod get_peer_address;
|
||||
mod login;
|
||||
mod message_factory;
|
||||
mod message_user;
|
||||
mod parent_min_speed;
|
||||
mod parent_speed_ratio;
|
||||
mod privileged_users;
|
||||
mod room_list;
|
||||
mod wish_list_interval;
|
||||
|
||||
pub use connect_to_peer::ConnectToPeerHandler;
|
||||
pub use excluded_search_phrases::ExcludedSearchPhrasesHandler;
|
||||
pub use file_search::FileSearchHandler;
|
||||
pub use get_peer_address::GetPeerAddressHandler;
|
||||
pub use login::LoginHandler;
|
||||
pub use message_factory::MessageFactory;
|
||||
pub use message_user::MessageUser;
|
||||
pub use parent_min_speed::ParentMinSpeedHandler;
|
||||
pub use parent_speed_ratio::ParentSpeedRatioHandler;
|
||||
pub use privileged_users::PrivilegedUsersHandler;
|
||||
pub use room_list::RoomListHandler;
|
||||
pub use wish_list_interval::WishListIntervalHandler;
|
||||
@@ -0,0 +1,21 @@
|
||||
use crate::debug;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage,
|
||||
message::{Message, MessageHandler},
|
||||
};
|
||||
|
||||
pub struct ParentMinSpeedHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for ParentMinSpeedHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
83
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, sender: Sender<ServerMessage>) {
|
||||
let _ = sender;
|
||||
let number = message.read_int32();
|
||||
debug!("Parent min speed: {}", number);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
use crate::debug;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage,
|
||||
message::{Message, MessageHandler},
|
||||
};
|
||||
|
||||
pub struct ParentSpeedRatioHandler;
|
||||
|
||||
// The server sends us a speed ratio determining the number of children we can have in the distributed network. The maximum number of children is our upload speed divided by the speed ratio.
|
||||
impl MessageHandler<ServerMessage> for ParentSpeedRatioHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
84
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
let number = message.read_int32();
|
||||
debug!("Parent speed ratio: {}", number);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
use crate::debug;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage,
|
||||
message::{Message, MessageHandler},
|
||||
};
|
||||
|
||||
pub struct PrivilegedUsersHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for PrivilegedUsersHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
69
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
let number = message.read_int32();
|
||||
debug!("Number of privileged users: {}", number);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage,
|
||||
message::{Message, MessageHandler},
|
||||
};
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
pub struct RoomListHandler;
|
||||
|
||||
impl MessageHandler<ServerMessage> for RoomListHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
64
|
||||
}
|
||||
|
||||
fn handle(&self, _message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
// let num_public_rooms = message.read_int32();
|
||||
// for _ in 0..num_public_rooms {
|
||||
// rooms.public_rooms.push(Room::new(message.read_string(), 0));
|
||||
// }
|
||||
//
|
||||
// let num_public_rooms = message.read_int32();
|
||||
// for i in 0..num_public_rooms {
|
||||
// rooms.public_rooms[i as usize].set_number_of_users(message.read_int32());
|
||||
// }
|
||||
//
|
||||
// let num_owned_private_rooms = message.read_int32();
|
||||
// for _ in 0..num_owned_private_rooms {
|
||||
// rooms
|
||||
// .owned_private_rooms
|
||||
// .push(Room::new(message.read_string(), 0));
|
||||
// }
|
||||
//
|
||||
// let num_owned_private_rooms = message.read_int32();
|
||||
// for i in 0..num_owned_private_rooms {
|
||||
// rooms.owned_private_rooms[i as usize].set_number_of_users(message.read_int32());
|
||||
// }
|
||||
//
|
||||
// let num_private_rooms = message.read_int32();
|
||||
// for _ in 0..num_private_rooms {
|
||||
// rooms
|
||||
// .private_rooms
|
||||
// .push(Room::new(message.read_string(), 0));
|
||||
// }
|
||||
//
|
||||
// let num_private_rooms = message.read_int32();
|
||||
// for i in 0..num_private_rooms {
|
||||
// rooms.private_rooms[i as usize].set_number_of_users(message.read_int32());
|
||||
// }
|
||||
//
|
||||
// let num_operated_private_rooms = message.read_int32();
|
||||
// for _ in 0..num_operated_private_rooms {
|
||||
// rooms
|
||||
// .operated_private_rooms
|
||||
// .push(Room::new(message.read_string(), 0));
|
||||
// }
|
||||
// let num_operated_private_rooms = message.read_int32();
|
||||
// for i in 0..num_operated_private_rooms {
|
||||
// rooms.operated_private_rooms[i as usize].set_number_of_users(message.read_int32());
|
||||
// }
|
||||
// cvat.notify_all();
|
||||
// rooms.print();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
use crate::debug;
|
||||
use std::sync::mpsc::Sender;
|
||||
|
||||
use crate::{
|
||||
actor::server_actor::ServerMessage,
|
||||
message::{Message, MessageHandler},
|
||||
};
|
||||
|
||||
pub struct WishListIntervalHandler;
|
||||
|
||||
// The server tells us the wishlist search interval.
|
||||
// This interval is almost always 12 minutes, or 2 minutes for privileged users.
|
||||
impl MessageHandler<ServerMessage> for WishListIntervalHandler {
|
||||
fn get_code(&self) -> u8 {
|
||||
104
|
||||
}
|
||||
|
||||
fn handle(&self, message: &mut Message, _sender: Sender<ServerMessage>) {
|
||||
let number = message.read_int32();
|
||||
debug!("Wishlist search interval: {} in seconds", number);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user