feat: rename module to soulseek-rs

src/message/mod.rs

@@ -5,11 +5,10 @@ mod message_reader;
 pub mod peer;
 pub mod server;
 
-// Re-export commonly used items
 pub use handlers::{Handlers, MessageHandler};
 pub use message_reader::MessageReader;
 
-use std::str;
+use std::{str, usize};
 
 #[derive(Debug, PartialEq)]
 #[allow(dead_code)]
@@ -148,6 +147,10 @@ impl Message {
         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 }
     }
@@ -222,6 +225,21 @@ impl Message {
         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;
@@ -250,6 +268,11 @@ impl Message {
         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
@@ -311,9 +334,16 @@ impl Message {
                 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)))

src/message/peer/file_search_response.rs

@@ -9,7 +9,10 @@ impl MessageHandler<PeerOperation> for FileSearchResponse {
         9
     }
     fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
-        let file_search = FileSearchResult::new_from_message(message);
+        let file_search = match FileSearchResult::new_from_message(message) {
+            Ok(result) => result,
+            Err(_) => return, // Skip malformed search results
+        };
 
         sender
             .send(PeerOperation::FileSearchResult(file_search))
@@ -40,7 +43,7 @@ fn test_new_from_message() {
     let mut message = Message::new_with_data(data);
     message.set_pointer(8);
 
-    let file_search = FileSearchResult::new_from_message(&mut message);
+    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];

src/message/peer/mod.rs

@@ -1,10 +1,14 @@
 mod file_search_response;
 mod get_share_file_list;
+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 place_in_queue_response::PlaceInQueueResponse;
 pub use transfer_request::TransferRequest;
+pub use transfer_response::TransferResponse;
 pub use upload_failed::UploadFailedHandler;

src/message/peer/place_in_queue_response.rs

@@ -0,0 +1,22 @@
+use crate::{
+    message::{Message, MessageHandler},
+    peer::PeerOperation,
+};
+use std::sync::mpsc::Sender;
+
+pub struct PlaceInQueueResponse;
+
+impl MessageHandler<PeerOperation> for PlaceInQueueResponse {
+    fn get_code(&self) -> u8 {
+        43
+    }
+
+    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+        let filename = message.read_string();
+        let place = message.read_int32() as u32;
+
+        sender
+            .send(PeerOperation::PlaceInQueueResponse { filename, place })
+            .unwrap();
+    }
+}

src/message/peer/transfer_request.rs

@@ -1,6 +1,7 @@
 use crate::{
     message::{Message, MessageHandler},
     peer::PeerOperation,
+    trace,
     types::Transfer,
 };
 use std::sync::mpsc::Sender;
@@ -11,6 +12,7 @@ impl MessageHandler<PeerOperation> for TransferRequest {
         40
     }
     fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+        trace!("transfer_response: {:?}", message.get_buffer());
         let transfer = Transfer::new_from_message(message);
 
         sender

src/message/peer/transfer_response.rs

@@ -0,0 +1,27 @@
+use crate::{
+    message::{Message, MessageHandler},
+    peer::PeerOperation,
+};
+use std::sync::mpsc::Sender;
+
+pub struct TransferResponse;
+
+impl MessageHandler<PeerOperation> for TransferResponse {
+    fn get_code(&self) -> u8 {
+        41
+    }
+
+    fn handle(&self, message: &mut Message, sender: Sender<PeerOperation>) {
+        let token = message.read_int32();
+        let allowed = message.read_int8();
+        let reason = (allowed == 0).then(|| message.read_string());
+
+        sender
+            .send(PeerOperation::TransferResponse {
+                token,
+                allowed: allowed == 1,
+                reason,
+            })
+            .unwrap();
+    }
+}

src/message/server/connect_to_peer.rs

@@ -1,7 +1,6 @@
 use crate::message::{Message, MessageHandler};
-use crate::peer::{ConnectionType, Peer};
+use crate::peer::Peer;
 use crate::server::ServerOperation;
-use crate::trace;
 use std::sync::mpsc::Sender;
 pub struct ConnectToPeerHandler;
 impl MessageHandler<ServerOperation> for ConnectToPeerHandler {
@@ -10,12 +9,8 @@ impl MessageHandler<ServerOperation> for ConnectToPeerHandler {
     }
     fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
         let peer = Peer::new_from_message(message);
-        match peer.connection_type {
-            ConnectionType::P => (),
-            ConnectionType::F => trace!("[server] ConnectToPeer {:?}", peer),
-            ConnectionType::D => (),
-        }
-
+        println!("ConnectToPeerHandler: {:?}", peer);
+        println!("ConnectToPeerHandler: {:?}", peer.username);
         sender.send(ServerOperation::ConnectToPeer(peer)).unwrap();
     }
 }

src/message/server/get_peer_address.rs

@@ -0,0 +1,37 @@
+use crate::message::{Message, MessageHandler};
+use crate::server::ServerOperation;
+use std::sync::mpsc::Sender;
+
+pub struct GetPeerAddressHandler;
+
+impl MessageHandler<ServerOperation> for GetPeerAddressHandler {
+    fn get_code(&self) -> u8 {
+        3
+    }
+
+    fn handle(&self, message: &mut Message, sender: Sender<ServerOperation>) {
+        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(ServerOperation::GetPeerAddressResponse {
+                username,
+                host,
+                port,
+                obfuscation_type,
+                obfuscated_port,
+            })
+            .unwrap();
+    }
+}

src/message/server/message_factory.rs

@@ -4,6 +4,13 @@ use crate::{
 
 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(
         //     [
@@ -31,9 +38,8 @@ impl MessageFactory {
             .write_string(password)
             .write_int32(157) // version
             .write_string(&hash)
-            .write_int32(100); //minor version
-
-        message
+            .write_int32(100)
+            .clone()
     }
 
     pub fn build_shared_folders_message(
@@ -47,14 +53,6 @@ impl MessageFactory {
             .clone()
     }
     pub fn build_file_search_message(token: u32, query: &str) -> 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, 0, 0,
-        //     ]
-        //     .to_vec(),
-        // )
-        // .clone()
         Message::new()
             .write_int32(26)
             .write_int32(token)
@@ -68,10 +66,15 @@ impl MessageFactory {
             .clone()
     }
     pub fn build_no_parent_message() -> Message {
-        Message::new().write_int32(71).write_int32(1).clone()
+        Message::new().write_int32(71).write_bool(true).clone()
     }
-    pub fn build_set_wait_port_message() -> Message {
-        Message::new().write_int32(2).write_int32(2234).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()
@@ -87,11 +90,23 @@ impl MessageFactory {
             .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 {
@@ -108,6 +123,7 @@ impl MessageFactory {
         token: u32,
     ) -> Message {
         Message::new()
+            .write_int8(1)
             .write_string(own_username)
             .write_string(&connection_type.to_string())
             .write_int32(token)

src/message/server/mod.rs

@@ -1,6 +1,7 @@
 mod connect_to_peer;
 mod excluded_search_phrases;
 mod file_search;
+mod get_peer_address;
 mod login;
 mod message_factory;
 mod message_user;
@@ -10,10 +11,10 @@ mod privileged_users;
 mod room_list;
 mod wish_list_interval;
 
-// Re-export handlers
 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;