158 lines
4.0 KiB
Rust
158 lines
4.0 KiB
Rust
pub mod default_peer;
|
|
|
|
pub use default_peer::*;
|
|
pub mod listen;
|
|
|
|
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<Self, Self::Err> {
|
|
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: u32,
|
|
pub token: Option<u32>,
|
|
pub privileged: u8,
|
|
pub unknown: u8,
|
|
pub obfuscated_port: u8,
|
|
}
|
|
impl Peer {
|
|
#[allow(clippy::too_many_arguments, dead_code)]
|
|
pub fn new(
|
|
username: String,
|
|
connection_type: ConnectionType,
|
|
host: String,
|
|
port: u32,
|
|
token: u32,
|
|
privileged: u8,
|
|
unknown: u8,
|
|
obfuscated_port: u8,
|
|
) -> 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 = message.read_string().parse().unwrap();
|
|
|
|
let mut ip: Vec<i32> = 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_int32(),
|
|
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<u8> = [
|
|
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<u8> = [
|
|
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);
|
|
}
|