feat: rename module to soulseek-rs
This commit is contained in:
Michel de Graaf
+107
-93
@@ -1,8 +1,10 @@
|
||||
use crate::client::ClientOperation;
|
||||
use crate::dispatcher::MessageDispatcher;
|
||||
use crate::error::{Result, SoulseekRs};
|
||||
use crate::message::server::ConnectToPeerHandler;
|
||||
use crate::message::server::ExcludedSearchPhrasesHandler;
|
||||
use crate::message::server::FileSearchHandler;
|
||||
use crate::message::server::GetPeerAddressHandler;
|
||||
use crate::message::server::LoginHandler;
|
||||
use crate::message::server::MessageFactory;
|
||||
use crate::message::server::MessageUser;
|
||||
@@ -11,10 +13,9 @@ use crate::message::server::ParentSpeedRatioHandler;
|
||||
use crate::message::server::PrivilegedUsersHandler;
|
||||
use crate::message::server::RoomListHandler;
|
||||
use crate::message::server::WishListIntervalHandler;
|
||||
use crate::message::Handlers;
|
||||
use crate::message::Message;
|
||||
use crate::message::MessageReader;
|
||||
use crate::peer::listen::Listen;
|
||||
use crate::message::{Handlers, MessageType};
|
||||
use crate::peer::ConnectionType;
|
||||
use crate::peer::Peer;
|
||||
|
||||
@@ -26,7 +27,7 @@ use std::sync::{Arc, Barrier, Mutex};
|
||||
use std::thread::{self};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use crate::{debug, error, info, warn};
|
||||
use crate::{debug, error, info, trace, warn};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct PeerAddress {
|
||||
@@ -69,14 +70,6 @@ impl Context {
|
||||
logged_in: Option::None,
|
||||
}
|
||||
}
|
||||
|
||||
// pub fn get_messages_for_user(&self, username: String) -> Option<&UserMessage> {
|
||||
// self.user_messages.get(&username)
|
||||
// }
|
||||
//
|
||||
// pub fn get_rooms(&mut self) -> &mut Rooms {
|
||||
// &mut self.rooms
|
||||
// }
|
||||
}
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct UserMessage {
|
||||
@@ -186,6 +179,14 @@ pub enum ServerOperation {
|
||||
#[allow(dead_code)]
|
||||
ConnectToPeer(Peer),
|
||||
PierceFirewall(u32),
|
||||
GetPeerAddress(String),
|
||||
GetPeerAddressResponse {
|
||||
username: String,
|
||||
host: String,
|
||||
port: u32,
|
||||
obfuscation_type: u32,
|
||||
obfuscated_port: u16,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
@@ -195,11 +196,10 @@ pub struct Server {
|
||||
context: Arc<Mutex<Context>>,
|
||||
}
|
||||
impl Server {
|
||||
/// Create a new instance of Server, returning a Result
|
||||
pub fn new(
|
||||
address: PeerAddress,
|
||||
client_channel: Sender<ClientOperation>,
|
||||
) -> Result<Self, io::Error> {
|
||||
) -> std::result::Result<Self, io::Error> {
|
||||
let (sender, server_channel): (
|
||||
Sender<ServerOperation>,
|
||||
Receiver<ServerOperation>,
|
||||
@@ -230,7 +230,7 @@ impl Server {
|
||||
&mut self,
|
||||
server_channel: Receiver<ServerOperation>,
|
||||
client_channel: Sender<ClientOperation>,
|
||||
) -> Result<(), io::Error> {
|
||||
) -> std::result::Result<(), io::Error> {
|
||||
let socket_address =
|
||||
format!("{}:{}", self.address.host, self.address.port)
|
||||
.to_socket_addrs()?
|
||||
@@ -279,9 +279,11 @@ impl Server {
|
||||
handlers.register_handler(ParentSpeedRatioHandler);
|
||||
handlers.register_handler(PrivilegedUsersHandler);
|
||||
handlers.register_handler(FileSearchHandler);
|
||||
handlers.register_handler(GetPeerAddressHandler);
|
||||
handlers.register_handler(ConnectToPeerHandler);
|
||||
|
||||
let dispatcher = MessageDispatcher::new(sender, handlers);
|
||||
let dispatcher =
|
||||
MessageDispatcher::new("server".to_string(), sender, handlers);
|
||||
|
||||
let mut buffered_reader = MessageReader::new();
|
||||
loop {
|
||||
@@ -305,16 +307,16 @@ impl Server {
|
||||
|
||||
match buffered_reader.extract_message() {
|
||||
Ok(Some(mut message)) => {
|
||||
// trace!(
|
||||
// "[server] ← {:?}",
|
||||
// message
|
||||
// .get_message_name(
|
||||
// MessageType::Server,
|
||||
// message.get_message_code() as u32
|
||||
// )
|
||||
// .map_err(|e| e.to_string())
|
||||
// );
|
||||
|
||||
trace!(
|
||||
"[server] ← {:?} - {}",
|
||||
message
|
||||
.get_message_name(
|
||||
MessageType::Server,
|
||||
message.get_message_code_u32()
|
||||
)
|
||||
.map_err(|e| e.to_string()),
|
||||
message.get_message_code_u32()
|
||||
);
|
||||
dispatcher.dispatch(&mut message)
|
||||
}
|
||||
Err(e) => {
|
||||
@@ -325,10 +327,6 @@ impl Server {
|
||||
}
|
||||
});
|
||||
|
||||
// let monitor_handle = thread::spawn(move || loop {
|
||||
// thread::sleep(Duration::from_secs(1));
|
||||
// println!("Stream state: connected={}", stream.peer_addr().is_ok());
|
||||
// });
|
||||
let context = self.context.clone();
|
||||
thread::spawn(move || {
|
||||
write_barrier.wait();
|
||||
@@ -336,72 +334,98 @@ impl Server {
|
||||
if let Ok(operation) = server_channel.recv() {
|
||||
match operation {
|
||||
ServerOperation::ConnectToPeer(peer) => {
|
||||
match peer.connection_type {
|
||||
debug!(
|
||||
"[server] ConnectToPeer {} - ConnectionType {}",
|
||||
peer.username, peer.connection_type
|
||||
);
|
||||
|
||||
if let Some(op) = match peer.connection_type {
|
||||
ConnectionType::P => {
|
||||
match client_channel.send(
|
||||
ClientOperation::ConnectToPeer(peer),
|
||||
) {
|
||||
Ok(_) => {}
|
||||
Err(_e) => {}
|
||||
}
|
||||
Some(ClientOperation::ConnectToPeer(peer))
|
||||
}
|
||||
ConnectionType::F => {
|
||||
match client_channel.send(
|
||||
ClientOperation::PierceFireWall(peer),
|
||||
) {
|
||||
Ok(_) => {
|
||||
debug!("Sent PierceFireWall operation for F-type connection");
|
||||
}
|
||||
Err(_e) => {
|
||||
error!("Failed to send PierceFireWall operation");
|
||||
}
|
||||
}
|
||||
Some(ClientOperation::PierceFireWall(peer))
|
||||
}
|
||||
ConnectionType::D => {}
|
||||
ConnectionType::D => None,
|
||||
} {
|
||||
client_channel.send(op).unwrap();
|
||||
}
|
||||
}
|
||||
ServerOperation::LoginStatus(message) => {
|
||||
context.lock().unwrap().logged_in = Some(message);
|
||||
}
|
||||
ServerOperation::PierceFirewall(token) => {
|
||||
let pierce_message =
|
||||
MessageFactory::build_pierce_firewall_message(
|
||||
if let Err(e) = write_stream.write_all(
|
||||
&MessageFactory::build_pierce_firewall_message(
|
||||
token,
|
||||
)
|
||||
.get_buffer(),
|
||||
) {
|
||||
error!(
|
||||
"Error writing PierceFirewall message: {}",
|
||||
e
|
||||
);
|
||||
match write_stream
|
||||
.write_all(&pierce_message.get_buffer())
|
||||
{
|
||||
Ok(_) => {
|
||||
debug!("Sent PierceFirewall message with token: {}", token);
|
||||
}
|
||||
Err(e) => {
|
||||
error!("Error writing PierceFirewall message: {}", e);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
debug!(
|
||||
"Sent PierceFirewall message with token: {}",
|
||||
token
|
||||
);
|
||||
}
|
||||
ServerOperation::SendMessage(message) => {
|
||||
// trace!(
|
||||
// "[server] ➡ {:?}",
|
||||
// message
|
||||
// .get_message_name(
|
||||
// MessageType::Server,
|
||||
// u32::from_le_bytes(
|
||||
// message.get_slice(0, 4).try_into().unwrap()
|
||||
// )
|
||||
// )
|
||||
// .map_err(|e| e.to_string()),
|
||||
// );
|
||||
match write_stream.write_all(&message.get_buffer())
|
||||
{
|
||||
Ok(_) => {}
|
||||
Err(e) => {
|
||||
error!(
|
||||
"Error writing message to stream : {}",
|
||||
e
|
||||
);
|
||||
break;
|
||||
}
|
||||
Ok(_) => trace!(
|
||||
"[server] → {:?} - {:}",
|
||||
message
|
||||
.get_message_name(
|
||||
MessageType::Server,
|
||||
message.get_message_code_send()
|
||||
as u32
|
||||
)
|
||||
.map_err(|e| e.to_string()),
|
||||
message.get_message_code_send() as u32
|
||||
),
|
||||
Err(e) => error!(
|
||||
"Error writing message to server: {}",
|
||||
e
|
||||
),
|
||||
}
|
||||
}
|
||||
ServerOperation::GetPeerAddress(username) => {
|
||||
if let Err(e) = write_stream.write_all(
|
||||
&MessageFactory::build_get_peer_address(
|
||||
&username,
|
||||
)
|
||||
.get_buffer(),
|
||||
) {
|
||||
error!("Error writing get_peeer_address message: {}", e);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ServerOperation::GetPeerAddressResponse {
|
||||
username,
|
||||
host,
|
||||
port,
|
||||
obfuscation_type,
|
||||
obfuscated_port,
|
||||
} => {
|
||||
debug!(
|
||||
"Received GetPeerAddress response for {}: {}:{} (obf_type: {}, obf_port: {})",
|
||||
username, host, port, obfuscation_type, obfuscated_port
|
||||
);
|
||||
|
||||
// Forward the response to the client channel
|
||||
if let Err(e) = client_channel.send(
|
||||
ClientOperation::GetPeerAddressResponse {
|
||||
username,
|
||||
host,
|
||||
port,
|
||||
obfuscation_type,
|
||||
obfuscated_port,
|
||||
},
|
||||
) {
|
||||
error!("Error forwarding GetPeerAddress response to client: {}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -418,16 +442,7 @@ impl Server {
|
||||
Err(e) => error!("Failed to send: {}", e),
|
||||
}
|
||||
}
|
||||
fn start_listener(&self, server_channel: Sender<ServerOperation>) {
|
||||
thread::spawn(move || Listen::start(2234, server_channel));
|
||||
}
|
||||
|
||||
pub fn login(
|
||||
&self,
|
||||
username: &str,
|
||||
password: &str,
|
||||
) -> Result<bool, std::io::Error> {
|
||||
self.start_listener(self.sender.clone());
|
||||
pub fn login(&self, username: &str, password: &str) -> Result<bool> {
|
||||
// Send the login message
|
||||
self.queue_message(MessageFactory::build_login_message(
|
||||
username, password,
|
||||
@@ -441,10 +456,7 @@ impl Server {
|
||||
loop {
|
||||
if start.elapsed() > timeout {
|
||||
warn!("Timeout waiting for login response");
|
||||
return Err(std::io::Error::new(
|
||||
std::io::ErrorKind::TimedOut,
|
||||
"Timeout waiting for login response",
|
||||
));
|
||||
return Err(SoulseekRs::Timeout);
|
||||
}
|
||||
|
||||
{
|
||||
@@ -458,12 +470,14 @@ impl Server {
|
||||
|
||||
if logged_in.unwrap() {
|
||||
info!("Logged in as {}", username);
|
||||
self.queue_message(MessageFactory::build_set_wait_port_message());
|
||||
self.queue_message(MessageFactory::build_shared_folders_message(
|
||||
1, 499,
|
||||
));
|
||||
self.queue_message(MessageFactory::build_no_parent_message());
|
||||
self.queue_message(MessageFactory::build_set_status_message(2));
|
||||
self.queue_message(MessageFactory::build_set_wait_port_message(
|
||||
2235,
|
||||
));
|
||||
}
|
||||
|
||||
Ok(logged_in.unwrap())
|
||||
|
||||
Reference in New Issue
Block a user