feat: seperate into lib and cli packages

soulseek-rs-lib/src/actor/mod.rs

@@ -0,0 +1,224 @@
+use std::sync::mpsc::{channel, Receiver, Sender};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use crate::trace;
+use crate::utils::thread_pool::ThreadPool;
+
+pub mod peer_actor;
+pub mod peer_registry;
+pub mod server_actor;
+
+#[derive(Debug, Clone)]
+pub enum ConnectionState {
+    Disconnected,
+    Connecting { since: Instant },
+    Connected,
+}
+/// Core actor trait - each actor processes messages
+pub trait Actor: Send + 'static {
+    type Message: Send + Clone + 'static;
+
+    /// Handle a single message
+    fn handle(&mut self, msg: Self::Message);
+
+    /// Called when actor starts (optional hook)
+    fn on_start(&mut self) {}
+
+    /// Called when actor stops (optional hook)
+    fn on_stop(&mut self) {}
+
+    /// Optional periodic tick for background work
+    fn tick(&mut self) {}
+}
+
+#[derive(Clone)]
+pub struct ActorHandle<M: Send> {
+    pub(crate) sender: Sender<ActorMessage<M>>,
+}
+
+impl<M: Send> ActorHandle<M> {
+    pub fn send(&self, msg: M) -> Result<(), String> {
+        self.sender
+            .send(ActorMessage::UserMessage(msg))
+            .map_err(|e| format!("Failed to send message: {}", e))
+    }
+
+    /// Request actor to stop gracefully
+    pub fn stop(&self) -> Result<(), String> {
+        self.sender
+            .send(ActorMessage::Stop)
+            .map_err(|e| format!("Failed to send stop signal: {}", e))
+    }
+}
+
+/// Internal actor message wrapper
+pub(crate) enum ActorMessage<M> {
+    UserMessage(M),
+    Stop,
+    #[allow(dead_code)]
+    Tick,
+}
+
+/// Actor system that manages actor lifecycle
+pub struct ActorSystem {
+    thread_pool: Arc<ThreadPool>,
+}
+
+impl ActorSystem {
+    pub fn new(thread_pool: Arc<ThreadPool>) -> Self {
+        ActorSystem { thread_pool }
+    }
+
+    /// Spawn a new actor and return its handle
+    pub fn spawn<A: Actor>(&self, mut actor: A) -> ActorHandle<A::Message> {
+        let (sender, receiver) = channel::<ActorMessage<A::Message>>();
+        let handle = ActorHandle {
+            sender: sender.clone(),
+        };
+
+        // Start the actor event loop on the thread pool
+        self.thread_pool.execute(move || {
+            actor.on_start();
+            Self::run_actor_loop(&mut actor, receiver);
+            actor.on_stop();
+        });
+
+        handle
+    }
+
+    /// Spawn a new actor with initialization callback and return its handle
+    /// The callback receives the actor handle before on_start is called
+    pub fn spawn_with_handle<A: Actor, F>(
+        &self,
+        mut actor: A,
+        init: F,
+    ) -> ActorHandle<A::Message>
+    where
+        F: FnOnce(&mut A, ActorHandle<A::Message>) + Send + 'static,
+    {
+        let (sender, receiver) = channel::<ActorMessage<A::Message>>();
+        let handle = ActorHandle {
+            sender: sender.clone(),
+        };
+        let handle_for_init = handle.clone();
+
+        self.thread_pool.execute(move || {
+            init(&mut actor, handle_for_init);
+            actor.on_start();
+            Self::run_actor_loop(&mut actor, receiver);
+            actor.on_stop();
+        });
+
+        handle
+    }
+
+    fn run_actor_loop<A: Actor>(
+        actor: &mut A,
+        receiver: Receiver<ActorMessage<A::Message>>,
+    ) {
+        let tick_interval = Duration::from_millis(100);
+        let mut last_tick = Instant::now();
+        let mut message_count = 0;
+        let mut tick_count = 0;
+
+        loop {
+            match receiver.recv_timeout(tick_interval) {
+                Ok(ActorMessage::UserMessage(msg)) => {
+                    message_count += 1;
+                    actor.handle(msg);
+                }
+                Ok(ActorMessage::Stop) => {
+                    trace!(
+                        "[actor_system] Received Stop message, breaking loop"
+                    );
+                    break;
+                }
+                Ok(ActorMessage::Tick) => {
+                    tick_count += 1;
+                    trace!(
+                        "[actor_system] Received explicit Tick message #{}",
+                        tick_count
+                    );
+
+                    actor.tick();
+                }
+                Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                    if last_tick.elapsed() >= tick_interval {
+                        tick_count += 1;
+                        // if tick_count % 10 == 0 {
+                        //     trace!("[actor_system] Periodic tick #{} (every 1s log)", tick_count);
+                        // }
+                        actor.tick();
+                        last_tick = Instant::now();
+                    }
+                }
+                Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => {
+                    trace!(
+                        "[actor_system] Channel disconnected, breaking loop"
+                    );
+                    break;
+                }
+            }
+        }
+        trace!("[actor_system] run_actor_loop ENDED - processed {} messages, {} ticks", message_count, tick_count);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    struct CounterActor {
+        count: Arc<AtomicUsize>,
+    }
+
+    impl Actor for CounterActor {
+        type Message = usize;
+
+        fn handle(&mut self, msg: Self::Message) {
+            self.count.fetch_add(msg, Ordering::SeqCst);
+        }
+
+        fn on_start(&mut self) {
+            println!("Counter actor started");
+        }
+
+        fn on_stop(&mut self) {
+            println!("Counter actor stopped");
+        }
+    }
+
+    #[test]
+    fn test_actor_system() {
+        let thread_pool = Arc::new(ThreadPool::new(4));
+        let system = ActorSystem::new(thread_pool.clone());
+
+        let count = Arc::new(AtomicUsize::new(0));
+        let actor = CounterActor {
+            count: count.clone(),
+        };
+
+        let handle = system.spawn(actor);
+
+        // Send some messages
+        handle.send(1).unwrap();
+        handle.send(2).unwrap();
+        handle.send(3).unwrap();
+
+        // Give actor time to process
+        std::thread::sleep(Duration::from_millis(100));
+
+        assert_eq!(count.load(Ordering::SeqCst), 6);
+
+        // Stop the actor
+        handle.stop().unwrap();
+
+        // Give actor time to process the stop message
+        std::thread::sleep(Duration::from_millis(100));
+
+        // Drop the thread pool explicitly to wait for all threads
+        drop(thread_pool);
+    }
+}

soulseek-rs-lib/src/actor/peer_actor.rs

@@ -0,0 +1,537 @@
+use crate::actor::{Actor, ActorHandle, ConnectionState};
+use crate::client::ClientOperation;
+use crate::dispatcher::MessageDispatcher;
+use crate::message::peer::{
+    FileSearchResponse, GetShareFileList, PeerInit, PlaceInQueueResponse,
+    TransferRequest, TransferResponse, UploadFailedHandler,
+};
+use crate::message::server::MessageFactory;
+use crate::message::{Handlers, Message, MessageReader, MessageType};
+use crate::peer::Peer;
+use crate::types::{Download, FileSearchResult, Transfer};
+use crate::{debug, error, trace, warn};
+
+use std::io::{self, Error, Write};
+use std::net::TcpStream;
+use std::sync::mpsc::{Receiver, Sender};
+use std::sync::{Arc, RwLock};
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone)]
+pub enum PeerMessage {
+    SendMessage(Message),
+    FileSearchResult(FileSearchResult),
+    TransferRequest(Transfer),
+    UploadFailed(String, String),
+    TransferResponse {
+        token: u32,
+        allowed: bool,
+        reason: Option<String>,
+    },
+    PlaceInQueueResponse {
+        filename: String,
+        place: u32,
+    },
+    SetUsername(String),
+    QueueUpload(String),
+    RequestTransfer(Download),
+    ProcessRead,
+}
+
+pub struct PeerActor {
+    peer: Arc<RwLock<Peer>>,
+    stream: Option<TcpStream>,
+    connection_state: ConnectionState,
+    reader: MessageReader,
+    client_channel: Sender<ClientOperation>,
+    self_handle: Option<ActorHandle<PeerMessage>>,
+    dispatcher: Option<MessageDispatcher<PeerMessage>>,
+    dispatcher_receiver: Option<Receiver<PeerMessage>>,
+    queued_messages: Vec<PeerMessage>,
+}
+
+impl PeerActor {
+    pub fn new(
+        peer: Peer,
+        stream: Option<TcpStream>,
+        reader: Option<MessageReader>,
+        client_channel: Sender<ClientOperation>,
+    ) -> Self {
+        let connection_state = if stream.is_some() {
+            ConnectionState::Connected
+        } else {
+            ConnectionState::Disconnected
+        };
+
+        Self {
+            peer: Arc::new(RwLock::new(peer)),
+            stream,
+            connection_state,
+            reader: reader.unwrap_or_default(),
+            client_channel,
+            self_handle: None,
+            dispatcher: None,
+            dispatcher_receiver: None,
+            queued_messages: Vec::new(),
+        }
+    }
+
+    pub fn set_self_handle(&mut self, handle: ActorHandle<PeerMessage>) {
+        self.self_handle = Some(handle);
+    }
+
+    fn initialize_dispatcher(&mut self) {
+        let (dispatcher_sender, dispatcher_receiver) =
+            std::sync::mpsc::channel::<PeerMessage>();
+
+        self.dispatcher_receiver = Some(dispatcher_receiver);
+
+        let mut handlers = Handlers::new();
+        handlers.register_handler(FileSearchResponse);
+        handlers.register_handler(TransferRequest);
+        handlers.register_handler(TransferResponse);
+        handlers.register_handler(GetShareFileList);
+        handlers.register_handler(UploadFailedHandler);
+        handlers.register_handler(PlaceInQueueResponse);
+        handlers.register_handler(PeerInit);
+
+        self.dispatcher = Some(MessageDispatcher::new(
+            "peer".to_string(),
+            dispatcher_sender,
+            handlers,
+        ));
+    }
+
+    fn process_dispatcher_messages(&mut self) {
+        let messages: Vec<PeerMessage> = self
+            .dispatcher_receiver
+            .as_ref()
+            .map_or_else(Vec::new, |receiver| {
+                let mut msgs = Vec::new();
+                while let Ok(msg) = receiver.try_recv() {
+                    msgs.push(msg);
+                }
+                msgs
+            });
+
+        messages
+            .iter()
+            .for_each(|msg| self.handle_message(msg.clone()));
+    }
+
+    fn handle_message(&mut self, msg: PeerMessage) {
+        if matches!(self.connection_state, ConnectionState::Connecting { .. }) {
+            match &msg {
+                PeerMessage::SetUsername(_) | PeerMessage::ProcessRead => {}
+                _ => {
+                    self.queued_messages.push(msg);
+                    return;
+                }
+            }
+        }
+
+        match msg {
+            PeerMessage::SendMessage(message) => {
+                self.send_message(message);
+            }
+            PeerMessage::FileSearchResult(file_search) => {
+                self.client_channel
+                    .send(ClientOperation::SearchResult(file_search))
+                    .unwrap();
+            }
+            PeerMessage::TransferRequest(transfer) => {
+                let username = self.peer.read().unwrap().username.clone();
+                debug!(
+                    "[peer:{}] TransferRequest for {}",
+                    username, transfer.token
+                );
+
+                self.client_channel
+                    .send(ClientOperation::UpdateDownloadTokens(
+                        transfer.clone(),
+                        username.clone(),
+                    ))
+                    .unwrap();
+
+                let transfer_response =
+                    MessageFactory::build_transfer_response_message(transfer);
+
+                if let Some(ref handle) = self.self_handle {
+                    if let Err(e) =
+                        handle.send(PeerMessage::SendMessage(transfer_response))
+                    {
+                        error!("[peer:{}] Failed to send TransferResponse message: {}", username, e);
+                    }
+                }
+            }
+            PeerMessage::TransferResponse {
+                token,
+                allowed,
+                reason,
+            } => {
+                let username = self.peer.read().unwrap().username.clone();
+                debug!(
+                    "[peer:{}] transfer response token: {} allowed: {}",
+                    username, token, allowed
+                );
+
+                if !allowed {
+                    if let Some(reason_text) = reason {
+                        debug!(
+                                    "[peer:{}] Transfer rejected: {} - token {}, waiting for TransferRequest...",
+                                    username, reason_text, token
+                                );
+                    }
+                } else {
+                    debug!(
+                                "[peer:{}] Transfer allowed, ready to connect with token {:}",
+                                username, token
+                            );
+                    self.client_channel
+                        .send(ClientOperation::DownloadFromPeer(
+                            token,
+                            self.peer.read().unwrap().clone(),
+                            allowed,
+                        ))
+                        .unwrap();
+                }
+            }
+            PeerMessage::PlaceInQueueResponse { filename, place } => {
+                let username = self.peer.read().unwrap().username.clone();
+                debug!(
+                    "[peer:{}] Place in queue response - file: {}, place: {}",
+                    username, filename, place
+                );
+            }
+            PeerMessage::SetUsername(username) => {
+                trace!(
+                    "[peer:{}] SetUsername: {}",
+                    self.peer.read().unwrap().username,
+                    username
+                );
+                self.peer.write().unwrap().username = username;
+            }
+            PeerMessage::QueueUpload(filename) => {
+                let message =
+                    MessageFactory::build_queue_upload_message(&filename);
+                self.send_message(message);
+            }
+            PeerMessage::RequestTransfer(download) => {
+                let message = MessageFactory::build_transfer_request_message(
+                    &download.filename,
+                    download.token,
+                );
+                self.send_message(message);
+            }
+            PeerMessage::ProcessRead => {
+                self.process_read();
+            }
+            PeerMessage::UploadFailed(username, filename) => {
+                self.client_channel
+                    .send(ClientOperation::UploadFailed(username, filename))
+                    .unwrap();
+            }
+        }
+    }
+
+    fn process_read(&mut self) {
+        if self.reader.buffer_len() > 0 {
+            self.extract_and_process_messages();
+        }
+
+        {
+            let stream = match self.stream.as_mut() {
+                Some(s) => s,
+                None => return,
+            };
+
+            match self.reader.read_from_socket(stream) {
+                Ok(()) => {}
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
+                Err(ref e) if e.kind() == io::ErrorKind::TimedOut => {
+                    let peer_lock = self.peer.read().unwrap();
+                    debug!(
+                        "Read operation timed out for peer actor {:}:{:}",
+                        peer_lock.host, peer_lock.port
+                    );
+                }
+                Err(e) => {
+                    let username = self.peer.read().unwrap().username.clone();
+                    error!(
+                        "[peer:{}] Error reading from peer: {} (kind: {:?}). Disconnecting.",
+                        username, e, e.kind()
+                    );
+                    self.disconnect_with_error(e);
+                    return;
+                }
+            }
+        }
+        self.extract_and_process_messages();
+    }
+
+    fn extract_and_process_messages(&mut self) {
+        let username = self.peer.read().unwrap().username.clone();
+        let mut extracted_count = 0;
+        loop {
+            match self.reader.extract_message() {
+                Ok(Some(mut message)) => {
+                    extracted_count += 1;
+                    trace!(
+                        "[peer:{}] ← Message #{}: {:?}",
+                        username,
+                        extracted_count,
+                        message
+                            .get_message_name(
+                                MessageType::Peer,
+                                message.get_message_code() as u32
+                            )
+                            .map_err(|e| e.to_string())
+                    );
+                    if let Some(ref dispatcher) = self.dispatcher {
+                        dispatcher.dispatch(&mut message);
+                    } else {
+                        warn!("[peer:{}] No dispatcher available!", username);
+                    }
+                }
+                Err(e) => {
+                    warn!(
+                        "[peer:{}] Error extracting message: {}. Disconnecting peer.",
+                        username, e
+                    );
+                    self.disconnect_with_error(e);
+                    return;
+                }
+                Ok(None) => {
+                    break;
+                }
+            }
+        }
+
+        self.process_dispatcher_messages();
+    }
+
+    fn send_message(&mut self, message: Message) {
+        let stream = match self.stream.as_mut() {
+            Some(s) => s,
+            None => {
+                error!("Cannot send message: stream is None");
+                return;
+            }
+        };
+
+        let username = self.peer.read().unwrap().username.clone();
+        trace!(
+            "[peer:{}] ➡ {:?}",
+            username,
+            message
+                .get_message_name(
+                    MessageType::Peer,
+                    u32::from_le_bytes(
+                        message.get_slice(0, 4).try_into().unwrap()
+                    )
+                )
+                .map_err(|e| e.to_string())
+        );
+
+        if let Err(e) = stream.write_all(&message.get_buffer()) {
+            error!(
+                "[peer:{}] Error writing message: {}. Disconnecting.",
+                username, e
+            );
+            self.disconnect_with_error(e);
+            return;
+        }
+
+        if let Err(e) = stream.flush() {
+            error!(
+                "[peer:{}] Error flushing stream: {}. Disconnecting.",
+                username, e
+            );
+            self.disconnect_with_error(e);
+        }
+    }
+
+    fn disconnect_with_error(&mut self, error: Error) {
+        let username = self.peer.read().unwrap().username.clone();
+        debug!("[peer:{}] disconnect", username);
+
+        self.stream.take();
+
+        if let Err(e) = self.client_channel.send(
+            ClientOperation::PeerDisconnected(username, Some(error.into())),
+        ) {
+            error!("Failed to send disconnect notification: {}", e);
+        }
+    }
+    fn disconnect(&mut self) {
+        let username = self.peer.read().unwrap().username.clone();
+        debug!("[peer:{}] disconnect", username);
+
+        self.stream.take();
+
+        if let Err(e) = self
+            .client_channel
+            .send(ClientOperation::PeerDisconnected(username, None))
+        {
+            error!("Failed to send disconnect notification: {}", e);
+        }
+    }
+
+    fn initiate_connection(&mut self) -> bool {
+        let peer = self.peer.read().unwrap();
+        let username = peer.username.clone();
+        let host = peer.host.clone();
+        let port = peer.port;
+        drop(peer);
+
+        let socket_addr =
+            format!("{}:{}", host, port).parse::<std::net::SocketAddr>();
+
+        match socket_addr {
+            Ok(addr) => {
+                // Use connect_timeout to prevent blocking the thread for too long
+                let timeout = Duration::from_secs(5);
+                match TcpStream::connect_timeout(&addr, timeout) {
+                    Ok(stream) => {
+                        if let Err(e) = stream.set_nonblocking(true) {
+                            error!(
+                                "[peer:{}] Failed to set non-blocking: {}",
+                                username, e
+                            );
+                            self.disconnect_with_error(e);
+                            return false;
+                        }
+                        stream.set_nodelay(true).ok();
+                        self.stream = Some(stream);
+                        self.connection_state = ConnectionState::Connecting {
+                            since: Instant::now(),
+                        };
+                        true
+                    }
+                    Err(e) => {
+                        self.disconnect_with_error(e);
+                        false
+                    }
+                }
+            }
+            Err(e) => {
+                error!(
+                    "[peer:{}] Invalid socket address {}:{} - {}",
+                    username, host, port, e
+                );
+                self.disconnect_with_error(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    e,
+                ));
+                false
+            }
+        }
+    }
+
+    fn check_connection_status(&mut self) {
+        let ConnectionState::Connecting { since } = self.connection_state
+        else {
+            return;
+        };
+
+        let username = self.peer.read().unwrap().username.clone();
+
+        if since.elapsed() > Duration::from_secs(20) {
+            error!("[peer:{}] Connection timeout after 20 seconds", username);
+            self.disconnect_with_error(io::Error::new(
+                io::ErrorKind::TimedOut,
+                "Connection timeout",
+            ));
+            return;
+        }
+
+        let Some(ref stream) = self.stream else {
+            return;
+        };
+
+        match stream.peer_addr() {
+            Ok(_) => {
+                self.connection_state = ConnectionState::Connected;
+                self.on_connection_established();
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::NotConnected => {}
+            Err(e) => {
+                error!("[peer:{}] Connection failed: {}", username, e);
+                self.disconnect_with_error(e);
+            }
+        }
+    }
+
+    fn on_connection_established(&mut self) {
+        let peer = self.peer.read().unwrap();
+        let username = peer.username.clone();
+        let token = peer.token;
+        drop(peer);
+
+        let Some(ref mut stream) = self.stream else {
+            return;
+        };
+
+        if let Some(token) = token {
+            let handshake_msg = MessageFactory::build_watch_user(token);
+            if let Err(e) = stream.write_all(&handshake_msg.get_data()) {
+                error!(
+                    "[peer:{}] Failed to send watch user handshake: {}",
+                    username, e
+                );
+                self.disconnect_with_error(e);
+                return;
+            }
+        }
+
+        self.initialize_dispatcher();
+
+        let queued = std::mem::take(&mut self.queued_messages);
+        for msg in queued {
+            self.handle_message(msg);
+        }
+
+        if let Some(ref handle) = self.self_handle {
+            handle.send(PeerMessage::ProcessRead).ok();
+        }
+
+        self.process_read();
+    }
+}
+
+impl Actor for PeerActor {
+    type Message = PeerMessage;
+
+    fn handle(&mut self, msg: Self::Message) {
+        self.handle_message(msg);
+    }
+
+    fn on_start(&mut self) {
+        if self.stream.is_none() {
+            self.initiate_connection();
+        } else {
+            self.connection_state = ConnectionState::Connected;
+            self.on_connection_established();
+        }
+    }
+
+    fn on_stop(&mut self) {
+        let username = self.peer.read().unwrap().username.clone();
+        trace!("[peer:{}] actor stopping", username);
+        self.disconnect();
+    }
+
+    fn tick(&mut self) {
+        match self.connection_state {
+            ConnectionState::Connecting { .. } => {
+                self.check_connection_status();
+            }
+            ConnectionState::Connected => {
+                if self.stream.is_some() {
+                    self.process_read();
+                }
+            }
+            ConnectionState::Disconnected => {}
+        }
+    }
+}

soulseek-rs-lib/src/actor/peer_registry.rs

@@ -0,0 +1,116 @@
+use crate::actor::peer_actor::{PeerActor, PeerMessage};
+use crate::actor::{ActorHandle, ActorSystem};
+use crate::client::ClientOperation;
+use crate::debug;
+use crate::message::MessageReader;
+use crate::peer::Peer;
+
+use std::collections::HashMap;
+use std::net::TcpStream;
+use std::sync::mpsc::Sender;
+use std::sync::{Arc, Mutex};
+
+pub struct PeerRegistry {
+    peers: Arc<Mutex<HashMap<String, ActorHandle<PeerMessage>>>>,
+    actor_system: Arc<ActorSystem>,
+    client_channel: Sender<ClientOperation>,
+}
+
+impl PeerRegistry {
+    pub fn new(
+        actor_system: Arc<ActorSystem>,
+        client_channel: Sender<ClientOperation>,
+    ) -> Self {
+        Self {
+            peers: Arc::new(Mutex::new(HashMap::new())),
+            actor_system,
+            client_channel,
+        }
+    }
+
+    pub fn register_peer(
+        &self,
+        peer: Peer,
+        stream: Option<TcpStream>,
+        reader: Option<MessageReader>,
+    ) -> Result<ActorHandle<PeerMessage>, String> {
+        let username = peer.username.clone();
+
+        let actor =
+            PeerActor::new(peer, stream, reader, self.client_channel.clone());
+
+        let handle =
+            self.actor_system.spawn_with_handle(actor, |actor, handle| {
+                actor.set_self_handle(handle);
+            });
+
+        let mut peers = self.peers.lock().unwrap();
+        peers.insert(username.clone(), handle.clone());
+
+        Ok(handle)
+    }
+
+    pub fn get_peer(&self, username: &str) -> Option<ActorHandle<PeerMessage>> {
+        let peers = self.peers.lock().unwrap();
+        peers.get(username).cloned()
+    }
+
+    pub fn remove_peer(
+        &self,
+        username: &str,
+    ) -> Option<ActorHandle<PeerMessage>> {
+        let mut peers = self.peers.lock().unwrap();
+        let handle = peers.remove(username);
+
+        if handle.is_some() {
+            debug!("[peer_registry] Removed peer actor for {}", username);
+        }
+
+        handle
+    }
+
+    pub fn get_all_usernames(&self) -> Vec<String> {
+        let peers = self.peers.lock().unwrap();
+        peers.keys().cloned().collect()
+    }
+
+    pub fn count(&self) -> usize {
+        let peers = self.peers.lock().unwrap();
+        peers.len()
+    }
+
+    pub fn contains(&self, username: &str) -> bool {
+        let peers = self.peers.lock().unwrap();
+        peers.contains_key(username)
+    }
+
+    pub fn send_to_peer(
+        &self,
+        username: &str,
+        message: PeerMessage,
+    ) -> Result<(), String> {
+        let handle = self.get_peer(username).ok_or_else(|| {
+            format!("Peer {} not found in registry", username)
+        })?;
+
+        handle.send(message)
+    }
+
+    pub fn queue_upload(
+        &self,
+        username: &str,
+        filename: String,
+    ) -> Result<(), String> {
+        self.send_to_peer(username, PeerMessage::QueueUpload(filename))
+    }
+}
+
+impl Clone for PeerRegistry {
+    fn clone(&self) -> Self {
+        Self {
+            peers: self.peers.clone(),
+            actor_system: self.actor_system.clone(),
+            client_channel: self.client_channel.clone(),
+        }
+    }
+}

soulseek-rs-lib/src/actor/server_actor.rs

@@ -0,0 +1,755 @@
+use crate::actor::{Actor, ActorHandle, ConnectionState};
+use crate::client::ClientOperation;
+use crate::dispatcher::MessageDispatcher;
+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;
+use crate::message::server::ParentMinSpeedHandler;
+use crate::message::server::ParentSpeedRatioHandler;
+use crate::message::server::PrivilegedUsersHandler;
+use crate::message::server::RoomListHandler;
+use crate::message::server::WishListIntervalHandler;
+use crate::message::{Handlers, MessageType};
+use crate::message::{Message, MessageReader};
+use crate::peer::ConnectionType;
+use crate::peer::Peer;
+
+use std::io::{self, Error, Write};
+use std::net::{TcpStream, ToSocketAddrs};
+use std::sync::mpsc::{Receiver, Sender};
+use std::sync::{Arc, RwLock};
+use std::time::{Duration, Instant};
+
+use crate::{debug, error, info, trace, warn, SoulseekRs};
+
+#[derive(Debug, Clone)]
+pub struct PeerAddress {
+    host: String,
+    port: u16,
+}
+
+impl PeerAddress {
+    pub fn new(host: String, port: u16) -> Self {
+        Self { host, port }
+    }
+
+    pub fn get_host(&self) -> &str {
+        &self.host
+    }
+
+    pub fn get_port(&self) -> u16 {
+        self.port
+    }
+}
+
+impl std::fmt::Display for PeerAddress {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}:{}", self.host, self.port)
+    }
+}
+
+#[derive(Debug)]
+pub struct Context {
+    pub logged_in: Option<bool>,
+    #[allow(dead_code)]
+    rooms: Rooms,
+}
+
+impl Default for Context {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Context {
+    pub fn new() -> Self {
+        Self {
+            #[allow(dead_code)]
+            rooms: Rooms::new(),
+            logged_in: Option::None,
+        }
+    }
+}
+#[derive(Debug, Clone)]
+pub struct UserMessage {
+    id: u32,
+    timestamp: u32,
+    username: String,
+    message: String,
+    new_message: bool,
+}
+impl UserMessage {
+    pub fn new(
+        id: u32,
+        timestamp: u32,
+        username: String,
+        message: String,
+        new_message: bool,
+    ) -> Self {
+        Self {
+            id,
+            timestamp,
+            username,
+            message,
+            new_message,
+        }
+    }
+    pub fn print(&self) {
+        debug!(
+            "Timestamp: {}. User: {}, Id: #{}, New message: {} Message: {}",
+            self.timestamp,
+            self.username,
+            self.id,
+            self.new_message,
+            self.message
+        );
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct Rooms {
+    pub public_rooms: Vec<Room>,
+    pub owned_private_rooms: Vec<Room>,
+    pub private_rooms: Vec<Room>,
+    pub operated_private_rooms: Vec<Room>,
+}
+impl Rooms {
+    fn new() -> Self {
+        Self {
+            public_rooms: Vec::new(),
+            owned_private_rooms: Vec::new(),
+            private_rooms: Vec::new(),
+            operated_private_rooms: Vec::new(),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn print(&self) {
+        info!("Public rooms ({}):", self.public_rooms.len());
+        for room in &self.public_rooms {
+            room.print();
+        }
+        info!("Owned private rooms ({}):", self.owned_private_rooms.len());
+        for room in &self.owned_private_rooms {
+            room.print();
+        }
+        info!("Private rooms ({}):", self.private_rooms.len());
+        for room in &self.private_rooms {
+            room.print();
+        }
+        info!(
+            "Operated private rooms ({}):",
+            self.operated_private_rooms.len()
+        );
+        for room in &self.operated_private_rooms {
+            room.print();
+        }
+    }
+}
+#[derive(Debug)]
+pub struct Room {
+    name: String,
+    number_of_users: i32,
+}
+impl Room {
+    #[allow(dead_code)]
+    pub fn new(name: String, number_of_users: i32) -> Self {
+        Self {
+            name,
+            number_of_users,
+        }
+    }
+    #[allow(dead_code)]
+    pub fn set_number_of_users(&mut self, number_of_users: i32) {
+        self.number_of_users = number_of_users;
+    }
+    pub fn print(&self) {
+        debug!(
+            "Room: {}, Number of users: {}",
+            self.name, self.number_of_users
+        );
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ServerMessage {
+    ProcessRead,
+    LoginStatus(bool),
+    SendMessage(Message),
+    Login {
+        username: String,
+        password: String,
+        response: std::sync::mpsc::Sender<Result<bool, SoulseekRs>>,
+    },
+    FileSearch {
+        token: u32,
+        query: String,
+    },
+    #[allow(dead_code)]
+    ConnectToPeer(Peer),
+    PierceFirewall(u32),
+    GetPeerAddress(String),
+    GetPeerAddressResponse {
+        username: String,
+        host: String,
+        port: u32,
+        obfuscation_type: u32,
+        obfuscated_port: u16,
+    },
+}
+
+pub struct ServerActor {
+    address: PeerAddress,
+    context: Arc<RwLock<Context>>,
+    listen_port: u32,
+    enable_listen: bool,
+    stream: Option<TcpStream>,
+    connection_state: ConnectionState,
+    reader: MessageReader,
+    client_channel: Sender<ClientOperation>,
+    self_handle: Option<ActorHandle<ServerMessage>>,
+    dispatcher: Option<MessageDispatcher<ServerMessage>>,
+    dispatcher_receiver: Option<Receiver<ServerMessage>>,
+    dispatcher_sender: Option<Sender<ServerMessage>>,
+    queued_messages: Vec<ServerMessage>,
+}
+
+impl ServerActor {
+    pub fn new(
+        address: PeerAddress,
+        client_channel: Sender<ClientOperation>,
+        listen_port: u32,
+        enable_listen: bool,
+    ) -> Self {
+        Self {
+            address,
+            context: Arc::new(RwLock::new(Context::new())),
+            listen_port,
+            enable_listen,
+            stream: None,
+            connection_state: ConnectionState::Disconnected,
+            dispatcher: None,
+            dispatcher_receiver: None,
+            dispatcher_sender: None,
+            reader: MessageReader::new(),
+            client_channel,
+            self_handle: None,
+            queued_messages: Vec::new(),
+        }
+    }
+
+    pub fn get_address(&self) -> &PeerAddress {
+        &self.address
+    }
+
+    pub fn get_sender(&self) -> Option<&Sender<ServerMessage>> {
+        self.dispatcher_sender.as_ref()
+    }
+
+    fn initiate_connection(&mut self) -> bool {
+        let host = self.address.host.clone();
+        let port = self.address.port;
+
+        let addr_str = format!("{}:{}", host, port);
+
+        let mut socket_addrs = match addr_str.to_socket_addrs() {
+            Ok(addrs) => addrs,
+            Err(e) => {
+                error!("[server] Failed to resolve address: {}", e);
+
+                self.disconnect_with_error(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    e,
+                ));
+                return false;
+            }
+        };
+
+        let socket_addr = socket_addrs.next();
+
+        match socket_addr {
+            Some(addr) => {
+                if let Ok(stream) = TcpStream::connect(addr) {
+                    if let Err(e) = stream.set_nonblocking(true) {
+                        error!("[server] Failed to set non-blocking: {}", e);
+                        self.disconnect_with_error(e);
+                        return false;
+                    }
+
+                    stream.set_nodelay(true).ok();
+
+                    self.stream = Some(stream);
+                    self.connection_state = ConnectionState::Connecting {
+                        since: Instant::now(),
+                    };
+                    true
+                } else {
+                    match TcpStream::connect(addr) {
+                        Ok(stream) => {
+                            if let Err(e) = stream.set_nonblocking(true) {
+                                error!(
+                                    "[server] Failed to set non-blocking: {}",
+                                    e
+                                );
+                                self.disconnect_with_error(e);
+                                return false;
+                            }
+                            stream.set_nodelay(true).ok();
+                            self.stream = Some(stream);
+                            self.connection_state =
+                                ConnectionState::Connecting {
+                                    since: Instant::now(),
+                                };
+                            true
+                        }
+                        Err(e) => {
+                            self.disconnect_with_error(e);
+                            false
+                        }
+                    }
+                }
+            }
+            None => {
+                let error_msg =
+                    format!("No socket addresses found for {}:{}", host, port);
+                error!("[server] {}", error_msg);
+                self.disconnect_with_error(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    error_msg,
+                ));
+                false
+            }
+        }
+    }
+
+    pub fn set_self_handle(&mut self, handle: ActorHandle<ServerMessage>) {
+        self.self_handle = Some(handle);
+    }
+
+    fn initialize_dispatcher(&mut self) {
+        let (dispatcher_sender, dispatcher_receiver) =
+            std::sync::mpsc::channel::<ServerMessage>();
+
+        self.dispatcher_receiver = Some(dispatcher_receiver);
+        self.dispatcher_sender = Some(dispatcher_sender.clone());
+
+        self.client_channel
+            .send(ClientOperation::SetServerSender(dispatcher_sender.clone()))
+            .unwrap();
+
+        let mut handlers = Handlers::new();
+
+        handlers.register_handler(LoginHandler);
+        handlers.register_handler(RoomListHandler);
+        handlers.register_handler(ExcludedSearchPhrasesHandler);
+        handlers.register_handler(PrivilegedUsersHandler);
+        handlers.register_handler(MessageUser);
+        handlers.register_handler(WishListIntervalHandler);
+        handlers.register_handler(ParentMinSpeedHandler);
+        handlers.register_handler(ParentSpeedRatioHandler);
+        handlers.register_handler(PrivilegedUsersHandler);
+        handlers.register_handler(FileSearchHandler);
+        handlers.register_handler(GetPeerAddressHandler);
+        handlers.register_handler(ConnectToPeerHandler);
+
+        self.dispatcher = Some(MessageDispatcher::new(
+            "server".into(),
+            dispatcher_sender,
+            handlers,
+        ));
+    }
+
+    fn process_dispatcher_messages(&mut self) {
+        let messages: Vec<ServerMessage> = self
+            .dispatcher_receiver
+            .as_ref()
+            .map_or_else(Vec::new, |receiver| {
+                let mut msgs = Vec::new();
+                while let Ok(msg) = receiver.try_recv() {
+                    msgs.push(msg);
+                }
+                msgs
+            });
+
+        messages
+            .iter()
+            .for_each(|msg| self.handle_message(msg.clone()));
+    }
+
+    pub fn login(
+        &mut self,
+        username: &str,
+        password: &str,
+    ) -> Result<bool, SoulseekRs> {
+        self.queue_message(MessageFactory::build_login_message(
+            username, password,
+        ));
+        let context = self.context.clone();
+        let mut logged_in;
+        let timeout = Duration::from_secs(5);
+        let start = Instant::now();
+
+        loop {
+            if start.elapsed() > timeout {
+                warn!("Timeout waiting for login response");
+                return Err(SoulseekRs::Timeout);
+            }
+
+            {
+                logged_in = context.read().unwrap().logged_in
+            }
+
+            if logged_in.is_some() {
+                break;
+            }
+        }
+
+        if logged_in.unwrap() {
+            info!("Logged in as {}", username);
+            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));
+            if self.enable_listen {
+                self.queue_message(
+                    MessageFactory::build_set_wait_port_message(
+                        self.listen_port,
+                    ),
+                );
+            }
+        }
+
+        Ok(logged_in.unwrap())
+    }
+
+    pub fn file_search(&mut self, token: u32, query: &str) {
+        self.queue_message(MessageFactory::build_file_search_message(
+            token, query,
+        ));
+    }
+
+    fn handle_message(&mut self, msg: ServerMessage) {
+        if !matches!(self.connection_state, ConnectionState::Connected) {
+            match &msg {
+                ServerMessage::ProcessRead => {
+                    // Always process read operations
+                }
+                _ => {
+                    // Queue all other messages when not connected
+                    self.queued_messages.push(msg);
+                    return;
+                }
+            }
+        }
+
+        match msg {
+            ServerMessage::ConnectToPeer(peer) => {
+                if let Some(op) = match peer.connection_type {
+                    ConnectionType::P | ConnectionType::F => {
+                        Some(ClientOperation::ConnectToPeer(peer.clone()))
+                    }
+                    ConnectionType::D => None,
+                } {
+                    self.client_channel.send(op).unwrap();
+                }
+            }
+            ServerMessage::LoginStatus(message) => {
+                self.context.write().unwrap().logged_in = Some(message);
+            }
+            ServerMessage::PierceFirewall(token) => {
+                self.send_message(
+                    MessageFactory::build_pierce_firewall_message(token),
+                );
+            }
+            ServerMessage::SendMessage(message) => {
+                self.send_message(message);
+            }
+            ServerMessage::GetPeerAddress(username) => {
+                self.send_message(MessageFactory::build_get_peer_address(
+                    &username,
+                ));
+            }
+            ServerMessage::GetPeerAddressResponse {
+                username,
+                host,
+                port,
+                obfuscation_type,
+                obfuscated_port,
+            } => {
+                debug!(
+                    "[server] Received GetPeerAddress response for {}: {}:{} (obf_type: {}, obf_port: {})"
+                    , username, host, port, obfuscation_type, obfuscated_port
+                );
+
+                if let Err(e) = self.client_channel.send(
+                    ClientOperation::GetPeerAddressResponse {
+                        username,
+                        host,
+                        port,
+                        obfuscation_type,
+                        obfuscated_port,
+                    },
+                ) {
+                    error!("[server] Error forwarding GetPeerAddress response to client: {}", e);
+                }
+            }
+            ServerMessage::ProcessRead => {
+                self.process_read();
+            }
+            ServerMessage::Login {
+                username,
+                password,
+                response,
+            } => {
+                self.queue_message(MessageFactory::build_login_message(
+                    &username, &password,
+                ));
+
+                let start = std::time::Instant::now();
+                let timeout = Duration::from_secs(5);
+
+                let context = self.context.clone();
+                std::thread::spawn(move || loop {
+                    if start.elapsed() >= timeout {
+                        let _ = response.send(Err(SoulseekRs::Timeout));
+                        break;
+                    }
+
+                    if let Some(logged_in) = context.read().unwrap().logged_in {
+                        let result = if logged_in {
+                            Ok(true)
+                        } else {
+                            Err(SoulseekRs::AuthenticationFailed)
+                        };
+                        let _ = response.send(result);
+                        break;
+                    }
+
+                    std::thread::sleep(Duration::from_millis(100));
+                });
+            }
+            ServerMessage::FileSearch { token, query } => {
+                self.file_search(token, &query);
+            }
+        }
+    }
+
+    fn process_read(&mut self) {
+        if self.reader.buffer_len() > 0 {
+            self.extract_and_process_messages();
+        }
+
+        {
+            let stream = match self.stream.as_mut() {
+                Some(s) => s,
+                None => return,
+            };
+
+            match self.reader.read_from_socket(stream) {
+                Ok(()) => {}
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
+                Err(ref e) if e.kind() == io::ErrorKind::TimedOut => {
+                    debug!("[server] Read operation timed out",);
+                }
+                Err(e) => {
+                    error!(
+                        "[server] Error reading from server: {} (kind: {:?}). Disconnecting.",
+                         e, e.kind()
+                    );
+                    self.disconnect_with_error(e);
+                    return;
+                }
+            }
+        }
+        self.extract_and_process_messages();
+    }
+
+    fn extract_and_process_messages(&mut self) {
+        let mut extracted_count = 0;
+        loop {
+            match self.reader.extract_message() {
+                Ok(Some(mut message)) => {
+                    extracted_count += 1;
+                    trace!(
+                        "[server] ← Message #{}: {:?}",
+                        extracted_count,
+                        message
+                            .get_message_name(
+                                MessageType::Server,
+                                message.get_message_code() as u32
+                            )
+                            .map_err(|e| e.to_string())
+                    );
+                    if let Some(ref dispatcher) = self.dispatcher {
+                        dispatcher.dispatch(&mut message);
+                    } else {
+                        warn!("[server] No dispatcher available!",);
+                    }
+                }
+                Err(e) => {
+                    warn!(
+                        "[server] Error extracting message: {}. Disconnecting.",
+                        e
+                    );
+                    self.disconnect_with_error(e);
+                    return;
+                }
+                Ok(None) => {
+                    break;
+                }
+            }
+        }
+
+        self.process_dispatcher_messages();
+    }
+
+    fn queue_message(&mut self, message: Message) {
+        if let Some(sender) = &self.dispatcher_sender {
+            match sender.send(ServerMessage::SendMessage(message)) {
+                Ok(_) => {}
+                Err(e) => error!("Failed to send: {}", e),
+            }
+        } else {
+            self.queued_messages
+                .push(ServerMessage::SendMessage(message));
+        }
+    }
+
+    fn send_message(&mut self, message: Message) {
+        let stream = match self.stream.as_mut() {
+            Some(s) => s,
+            None => {
+                error!("[server] Cannot send message: stream is None");
+                return;
+            }
+        };
+
+        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())
+        );
+
+        if let Err(e) = stream.write_all(&message.get_buffer()) {
+            error!("[server] Error writing message: {}. Disconnecting.", e);
+            self.disconnect_with_error(e);
+            return;
+        }
+
+        if let Err(e) = stream.flush() {
+            error!("[server] Error flushing stream: {}. Disconnecting.", e);
+            self.disconnect_with_error(e);
+        }
+    }
+
+    fn disconnect_with_error(&mut self, _error: Error) {
+        debug!("[server] disconnect");
+
+        self.stream.take();
+    }
+
+    fn disconnect(&mut self) {
+        debug!("[server] disconnected");
+
+        self.stream.take();
+    }
+
+    fn check_connection_status(&mut self) {
+        let ConnectionState::Connecting { since } = self.connection_state
+        else {
+            return;
+        };
+
+        if since.elapsed() > Duration::from_secs(20) {
+            error!("[server] Connection timeout after 20 seconds");
+            self.disconnect_with_error(io::Error::new(
+                io::ErrorKind::TimedOut,
+                "Connection timeout",
+            ));
+            return;
+        }
+
+        let Some(ref stream) = self.stream else {
+            return;
+        };
+
+        match stream.peer_addr() {
+            Ok(_) => {
+                self.connection_state = ConnectionState::Connected;
+                self.on_connection_established();
+            }
+            Err(ref e) if e.kind() == io::ErrorKind::NotConnected => {}
+            Err(e) => {
+                error!("[server] Connection failed: {}", e);
+                self.disconnect_with_error(e);
+            }
+        }
+    }
+
+    fn on_connection_established(&mut self) {
+        let Some(_) = self.stream else {
+            panic!("Stream should be available here")
+        };
+
+        self.initialize_dispatcher();
+
+        let queued = std::mem::take(&mut self.queued_messages);
+        for msg in queued {
+            self.handle_message(msg);
+        }
+
+        if let Some(ref handle) = self.self_handle {
+            handle.send(ServerMessage::ProcessRead).ok();
+        }
+
+        self.process_read();
+    }
+}
+
+impl Actor for ServerActor {
+    type Message = ServerMessage;
+
+    fn handle(&mut self, msg: Self::Message) {
+        self.handle_message(msg);
+    }
+
+    fn on_start(&mut self) {
+        if self.stream.is_none() {
+            self.initiate_connection();
+        } else {
+            self.connection_state = ConnectionState::Connected;
+            self.on_connection_established();
+        }
+    }
+
+    fn on_stop(&mut self) {
+        trace!("[server] actor stopping");
+        self.disconnect();
+    }
+
+    fn tick(&mut self) {
+        match self.connection_state {
+            ConnectionState::Connecting { .. } => {
+                self.check_connection_status();
+            }
+            ConnectionState::Connected => {
+                if self.stream.is_some() {
+                    self.process_read();
+                }
+            }
+            ConnectionState::Disconnected => {}
+        }
+    }
+}

soulseek-rs-lib/src/client.rs

@@ -0,0 +1,690 @@
+use crate::actor::server_actor::{PeerAddress, ServerActor, ServerMessage};
+use crate::actor::ActorHandle;
+use crate::types::{DownloadResult, DownloadStatus};
+use crate::{
+    actor::{peer_registry::PeerRegistry, ActorSystem},
+    error::{Result, SoulseekRs},
+    peer::{ConnectionType, DownloadPeer, NewPeer, Peer},
+    types::{Download, FileSearchResult},
+    utils::{md5, thread_pool::ThreadPool},
+    Transfer,
+};
+use std::{
+    collections::HashMap,
+    net::TcpStream,
+    sync::{
+        mpsc::{Receiver, Sender},
+        RwLock,
+    },
+    thread::{self, sleep},
+};
+use std::{
+    sync::{mpsc, Arc},
+    time::{Duration, Instant},
+};
+
+use crate::{debug, error, info, trace};
+const DEFALT_LISTEN_PORT: u32 = 2234;
+
+#[derive(Debug)]
+
+pub enum ClientOperation {
+    NewPeer(NewPeer),
+    ConnectToPeer(Peer),
+    SearchResult(FileSearchResult),
+    PeerDisconnected(String, Option<SoulseekRs>),
+    PierceFireWall(Peer),
+    DownloadFromPeer(u32, Peer, bool),
+    UpdateDownloadTokens(Transfer, String),
+    GetPeerAddressResponse {
+        username: String,
+        host: String,
+        port: u32,
+        obfuscation_type: u32,
+        obfuscated_port: u16,
+    },
+    UploadFailed(String, String),
+    SetServerSender(Sender<ServerMessage>),
+}
+pub struct ClientContext {
+    pub peer_registry: Option<PeerRegistry>,
+    sender: Option<Sender<ClientOperation>>,
+    server_sender: Option<Sender<ServerMessage>>,
+    search_results: Vec<FileSearchResult>,
+    pub download_tokens: HashMap<u32, Download>,
+    actor_system: Arc<ActorSystem>,
+}
+impl Default for ClientContext {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl ClientContext {
+    #[must_use]
+    pub fn new() -> Self {
+        let max_threads = thread::available_parallelism()
+            .map(|n| n.get())
+            .unwrap_or(8);
+
+        let thread_pool = Arc::new(ThreadPool::new(max_threads));
+        let actor_system = Arc::new(ActorSystem::new(thread_pool.clone()));
+
+        Self {
+            peer_registry: None,
+            sender: None,
+            server_sender: None,
+            search_results: Vec::new(),
+            download_tokens: HashMap::new(),
+            actor_system,
+        }
+    }
+}
+pub struct Client {
+    enable_listen: bool,
+    listen_port: u32,
+    address: PeerAddress,
+    username: String,
+    password: String,
+    server_handle: Option<ActorHandle<ServerMessage>>,
+    context: Arc<RwLock<ClientContext>>,
+}
+
+impl Client {
+    pub fn new(
+        address: PeerAddress,
+        username: String,
+        password: String,
+        enable_listen: bool,
+        listen_port: Option<u32>,
+    ) -> Self {
+        crate::utils::logger::init();
+        Self {
+            enable_listen,
+            listen_port: listen_port.unwrap_or(DEFALT_LISTEN_PORT),
+            address,
+            username,
+            password,
+            context: Arc::new(RwLock::new(ClientContext::new())),
+            server_handle: None,
+        }
+    }
+    pub fn with_defaults(
+        address: PeerAddress,
+        username: String,
+        password: String,
+    ) -> Self {
+        Self::new(address, username, password, false, None)
+    }
+
+    pub fn connect(&mut self) {
+        let (sender, message_reader): (
+            Sender<ClientOperation>,
+            Receiver<ClientOperation>,
+        ) = mpsc::channel();
+
+        let mut ctx = self.context.write().unwrap();
+        ctx.sender = Some(sender.clone());
+        let peer_registry =
+            PeerRegistry::new(ctx.actor_system.clone(), sender.clone());
+        ctx.peer_registry = Some(peer_registry);
+
+        let server_actor = ServerActor::new(
+            self.address.clone(),
+            sender,
+            self.listen_port,
+            self.enable_listen,
+        );
+
+        self.server_handle = Some(ctx.actor_system.spawn_with_handle(
+            server_actor,
+            |actor, handle| {
+                actor.set_self_handle(handle);
+            },
+        ));
+
+        Self::listen_to_client_operations(
+            message_reader,
+            self.context.clone(),
+            self.username.clone(),
+        );
+    }
+
+    pub fn login(&self) -> Result<bool> {
+        info!("Logging in as {}", self.username);
+        if let Some(handle) = &self.server_handle {
+            let (tx, rx) = std::sync::mpsc::channel();
+            let _ = handle.send(ServerMessage::Login {
+                username: self.username.clone(),
+                password: self.password.clone(),
+                response: tx,
+            });
+
+            match rx.recv() {
+                Ok(result) => result,
+                Err(_) => Err(SoulseekRs::Timeout),
+            }
+        } else {
+            Err(SoulseekRs::NotConnected)
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn remove_peer(&self, username: &str) {
+        let context = self.context.read().unwrap();
+        if let Some(ref registry) = context.peer_registry {
+            if let Some(handle) = registry.remove_peer(username) {
+                let _ = handle.stop();
+            }
+        }
+    }
+
+    pub fn search(
+        &self,
+        query: &str,
+        timeout: Duration,
+    ) -> Result<Vec<FileSearchResult>> {
+        info!("Searching for {}", query);
+        if let Some(handle) = &self.server_handle {
+            let hash = md5::md5(query);
+            let token = u32::from_str_radix(&hash[0..5], 16)?;
+            let _ = handle.send(ServerMessage::FileSearch {
+                token,
+                query: query.to_string(),
+            });
+        } else {
+            return Err(SoulseekRs::NotConnected);
+        }
+
+        let start = Instant::now();
+        loop {
+            sleep(Duration::from_millis(500));
+            if start.elapsed() >= timeout {
+                break;
+            }
+        }
+        Ok(self.context.read().unwrap().search_results.clone())
+    }
+
+    pub fn download(
+        &self,
+        filename: String,
+        username: String,
+        size: u64,
+        download_directory: String,
+    ) -> Result<crate::types::DownloadResult> {
+        info!("[client] Downloading {} from {}", filename, username);
+        let start_time = Instant::now();
+
+        let hash = md5::md5(&filename);
+        let token = u32::from_str_radix(&hash[0..5], 16)?;
+
+        let (download_sender, download_receivier): (
+            Sender<DownloadStatus>,
+            Receiver<DownloadStatus>,
+        ) = mpsc::channel();
+
+        let download = Download {
+            username: username.clone(),
+            filename: filename.clone(),
+            token,
+            size,
+            download_directory,
+            sender: download_sender,
+        };
+
+        let mut context = self.context.write().unwrap();
+        context.download_tokens.insert(token, download.clone());
+
+        let download_initiated =
+            if let Some(ref registry) = context.peer_registry {
+                registry
+                    .queue_upload(&username, download.filename.clone())
+                    .is_ok()
+            } else {
+                false
+            };
+
+        drop(context);
+
+        if !download_initiated {
+            return Ok(DownloadResult {
+                filename,
+                username,
+                status: DownloadStatus::Failed,
+                elapsed_time: start_time.elapsed(),
+            });
+        }
+
+        let status = download_receivier.recv().unwrap();
+
+        Ok(DownloadResult {
+            filename,
+            username,
+            status,
+            elapsed_time: start_time.elapsed(),
+        })
+    }
+
+    fn process_failed_uploads(
+        client_context: Arc<RwLock<ClientContext>>,
+        username: &str,
+        filename: Option<&str>,
+    ) {
+        let context = client_context.read().unwrap();
+        let download_tokens = &context.download_tokens;
+        let failed_downloads: Vec<_> = download_tokens
+            .iter()
+            .filter(|(_, download)| {
+                download.username == username
+                    && (filename.is_none_or(|f| download.filename == *f))
+            })
+            .map(|(token, download)| {
+                download.sender.send(DownloadStatus::Failed).unwrap();
+                *token
+            })
+            .collect();
+
+        failed_downloads.iter().for_each(|token| {
+            client_context
+                .write()
+                .unwrap()
+                .download_tokens
+                .remove(token);
+        });
+    }
+
+    fn listen_to_client_operations(
+        reader: Receiver<ClientOperation>,
+        client_context: Arc<RwLock<ClientContext>>,
+        own_username: String,
+    ) {
+        thread::spawn(move || loop {
+            match reader.recv() {
+                Ok(operation) => {
+                    match operation {
+                        ClientOperation::ConnectToPeer(peer) => {
+                            let client_context_clone = client_context.clone();
+                            let own_username_clone = own_username.clone();
+
+                            thread::spawn(move || {
+                                Self::connect_to_peer(
+                                    peer,
+                                    client_context_clone,
+                                    own_username_clone,
+                                    None,
+                                );
+                            });
+                        }
+                        ClientOperation::SearchResult(file_search) => {
+                            trace!("[client] SearchResult {:?}", file_search);
+                            client_context
+                                .write()
+                                .unwrap()
+                                .search_results
+                                .push(file_search.clone());
+                        }
+                        ClientOperation::PeerDisconnected(username, error) => {
+                            let context = client_context.read().unwrap();
+                            if let Some(ref registry) = context.peer_registry {
+                                if let Some(handle) =
+                                    registry.remove_peer(&username)
+                                {
+                                    let _ = handle.stop();
+                                }
+                            }
+                            if let Some(error) = error {
+                                error!(
+                                                "[client] Peer {} disconnected with error: {:?}",
+                                                username, error
+                                            );
+                                Self::process_failed_uploads(
+                                    client_context.clone(),
+                                    &username,
+                                    None,
+                                );
+                            }
+                        }
+                        ClientOperation::PierceFireWall(peer) => {
+                            Self::pierce_firewall(
+                                peer,
+                                client_context.clone(),
+                                own_username.clone(),
+                            );
+                        }
+                        ClientOperation::DownloadFromPeer(
+                            token,
+                            peer,
+                            allowed,
+                        ) => {
+                            let maybe_download = {
+                                let client_context =
+                                    client_context.read().unwrap();
+                                client_context
+                                    .download_tokens
+                                    .get(&token)
+                                    .cloned()
+                            };
+                            let own_username = own_username.clone();
+                            let client_context_clone = client_context.clone();
+
+                            trace!(
+                            "[client] DownloadFromPeer token: {} peer: {:?}",
+                            token,
+                            peer
+                        );
+                            match maybe_download {
+                                Some(download) => {
+                                    thread::spawn(move || {
+                                        let download_peer = DownloadPeer::new(
+                                            download.username.clone(),
+                                            peer.host.clone(),
+                                            peer.port,
+                                            token,
+                                            allowed,
+                                            own_username,
+                                        );
+                                        let filename: Option<&str> = download
+                                            .filename
+                                            .split('\\')
+                                            .next_back();
+                                        match filename {
+                                                                        Some(filename) => {
+                                                                            match download_peer.download_file(
+                                                                                client_context_clone,
+                                                                                Some(download.clone()),
+                                                                                None
+                                                                            ) {
+                                                                                Ok((download, filename)) => {
+                                                                                    download.sender.send(DownloadStatus::Completed).unwrap();
+                                                                                    info!("Successfully downloaded {} bytes to {}", download.size, filename);
+                                                                                }
+                                                                                Err(e) => {
+                                                                                    download.sender.send(DownloadStatus::Failed).unwrap();
+                                                                                    error!(
+                                                                                        "Failed to download file '{}' from {}:{} (token: {}) - Error: {}", 
+                                                                                        filename, peer.host, peer.port, download.token, e
+                                                                                    );
+                                                                                }
+                                                                            }
+                                                                        }
+                                                                        None => error!("Cant find filename to save download: {:?}", download.filename),
+                                                                    }
+                                    });
+                                }
+                                None => {
+                                    error!(
+                                        "Can't find download with token {:?}",
+                                        token
+                                    );
+                                }
+                            };
+                        }
+                        ClientOperation::NewPeer(new_peer) => {
+                            let peer_exists = client_context
+                                .read()
+                                .unwrap()
+                                .peer_registry
+                                .as_ref()
+                                .map(|r| r.contains(&new_peer.username))
+                                .unwrap_or(false);
+
+                            if peer_exists {
+                                debug!(
+                                    "Already connected to {}",
+                                    new_peer.username
+                                );
+                            } else if let Some(server_sender) =
+                                &client_context.read().unwrap().server_sender
+                            {
+                                server_sender
+                                    .send(ServerMessage::GetPeerAddress(
+                                        new_peer.username.clone(),
+                                    ))
+                                    .unwrap();
+                            }
+
+                            let addr = new_peer.tcp_stream.peer_addr().unwrap();
+                            let host = addr.ip().to_string();
+                            let port: u32 = addr.port().into();
+
+                            let peer = Peer {
+                                username: new_peer.username.clone(),
+                                connection_type: new_peer.connection_type,
+                                host,
+                                port,
+                                token: Some(new_peer.token),
+                                privileged: None,
+                                obfuscated_port: None,
+                                unknown: None,
+                            };
+
+                            Self::connect_to_peer(
+                                peer,
+                                client_context.clone(),
+                                own_username.clone(),
+                                Some(new_peer.tcp_stream),
+                            );
+                        }
+                        ClientOperation::GetPeerAddressResponse {
+                            username,
+                            host,
+                            port,
+                            obfuscation_type,
+                            obfuscated_port,
+                        } => {
+                            debug!(
+                                                            "Received peer address for {}: {}:{} (obf_type: {}, obf_port: {})",
+                                                            username, host, port, obfuscation_type, obfuscated_port
+                                                        );
+
+                            let peer_exists = client_context
+                                .read()
+                                .unwrap()
+                                .peer_registry
+                                .as_ref()
+                                .map(|r| r.contains(&username))
+                                .unwrap_or(false);
+
+                            if peer_exists {
+                                // don't know if i should update? and or reconnect the peer
+                                // debug!(
+                                //     "existing peer: {:?}, new peer details:
+                                //     username: {},
+                                //     host: {},
+                                //     port: {}
+                                //     obfuscation_type: {}
+                                //     obfuscated_port: {}",
+                                //     peer,
+                                //     username,
+                                //     host,
+                                //     port,
+                                //     obfuscation_type,
+                                //     obfuscated_port,
+                                // );
+                            } else {
+                                let peer = Peer::new(
+                                    username,
+                                    ConnectionType::P,
+                                    host,
+                                    port,
+                                    None,
+                                    0,
+                                    obfuscation_type.try_into().unwrap(),
+                                    obfuscated_port.try_into().unwrap(),
+                                );
+                                let client_context_clone =
+                                    client_context.clone();
+                                let own_username_clone = own_username.clone();
+
+                                thread::spawn(move || {
+                                    Self::connect_to_peer(
+                                        peer,
+                                        client_context_clone,
+                                        own_username_clone,
+                                        None,
+                                    );
+                                });
+                            }
+                        }
+                        ClientOperation::UpdateDownloadTokens(
+                            transfer,
+                            username,
+                        ) => {
+                            let mut context = client_context.write().unwrap();
+
+                            let key_to_remove = context
+                                .download_tokens
+                                .iter()
+                                .find_map(|(key, d)| {
+                                    if d.username == username
+                                        && d.filename == transfer.filename
+                                    {
+                                        Some((*key, d.clone()))
+                                    } else {
+                                        None
+                                    }
+                                });
+
+                            if let Some((key, download)) = key_to_remove {
+                                trace!(
+                                                "[client] UpdateDownloadTokens found {key}, transfer: {:?}",
+                                                transfer
+                                            );
+
+                                context.download_tokens.insert(
+                                    transfer.token,
+                                    Download {
+                                        username: username.clone(),
+                                        filename: transfer.filename,
+                                        token: transfer.token,
+                                        size: transfer.size,
+                                        download_directory: download
+                                            .download_directory,
+                                        sender: download.sender.clone(),
+                                    },
+                                );
+                                context.download_tokens.remove(&key);
+                            }
+                        }
+                        ClientOperation::UploadFailed(username, filename) => {
+                            Self::process_failed_uploads(
+                                client_context.clone(),
+                                &username,
+                                Some(&filename),
+                            );
+                        }
+                        ClientOperation::SetServerSender(sender) => {
+                            client_context.write().unwrap().server_sender =
+                                Some(sender);
+                            debug!("[client] Server sender initialized");
+                        }
+                    }
+                }
+                Err(e) => {
+                    error!("[client] Channel recv error: {:?}", e);
+                    break;
+                }
+            }
+        });
+    }
+
+    fn connect_to_peer(
+        peer: Peer,
+        client_context: Arc<RwLock<ClientContext>>,
+        own_username: String,
+        stream: Option<TcpStream>,
+    ) {
+        let client_context = client_context.clone();
+
+        let peer_clone = peer.clone();
+        trace!("[client] connecting to {}, with connection_type: {}, and token {:?}", peer.username, peer.connection_type, peer.token);
+        match peer.connection_type {
+            ConnectionType::P => {
+                let username = peer.username.clone();
+
+                let context = client_context.read().unwrap();
+                if let Some(ref registry) = context.peer_registry {
+                    match registry.register_peer(peer_clone, stream, None) {
+                        Ok(_) => (),
+                        Err(e) => {
+                            trace!(
+                                "Failed to spawn peer actor for {:?}: {:?}",
+                                username,
+                                e
+                            );
+                        }
+                    }
+                } else {
+                    trace!("PeerRegistry not initialized");
+                }
+            }
+
+            ConnectionType::F => {
+                trace!(
+                    "[client] downloading from: {}, {:?}",
+                    peer.username,
+                    peer.token
+                );
+                let download_peer = DownloadPeer::new(
+                    peer.username,
+                    peer.host,
+                    peer.port,
+                    peer.token.unwrap(),
+                    false,
+                    own_username.clone(),
+                );
+
+                match download_peer.download_file(
+                    client_context.clone(),
+                    None,
+                    None,
+                ) {
+                    Ok((download, filename)) => {
+                        trace!(
+                            "[client] downloaded {} bytes {:?} ",
+                            filename,
+                            download.size
+                        );
+                        download
+                            .sender
+                            .send(DownloadStatus::Completed)
+                            .unwrap();
+                    }
+                    Err(e) => {
+                        trace!("[client] failed to download: {}", e);
+                    }
+                }
+            }
+            ConnectionType::D => {
+                error!("ConnectionType::D not implemented")
+            }
+        }
+    }
+    fn pierce_firewall(
+        peer: Peer,
+        client_context: Arc<RwLock<ClientContext>>,
+        own_username: String,
+    ) {
+        debug!("Piercing firewall for peer: {:?}", peer);
+
+        let context = client_context.read().unwrap();
+        if let Some(server_sender) = &context.server_sender {
+            if let Some(token) = peer.token {
+                match server_sender.send(ServerMessage::PierceFirewall(token)) {
+                    Ok(_) => (),
+                    Err(e) => {
+                        error!("Failed to send PierceFirewall message: {}", e)
+                    }
+                }
+            } else {
+                error!("No token available for PierceFirewall");
+            }
+        } else {
+            error!("No server sender available for PierceFirewall");
+        }
+
+        drop(context);
+        Self::connect_to_peer(peer, client_context, own_username, None);
+    }
+}

soulseek-rs-lib/src/dispatcher.rs

@@ -0,0 +1,39 @@
+use crate::message::{handlers::Handlers, Message};
+use std::sync::mpsc::Sender;
+
+use crate::warn;
+
+pub struct MessageDispatcher<Op> {
+    owner_name: String,
+    sender: Sender<Op>,
+    handlers: Handlers<Op>,
+}
+
+impl<Op> MessageDispatcher<Op> {
+    pub fn new(
+        owner_name: String,
+        sender: Sender<Op>,
+        handlers: Handlers<Op>,
+    ) -> Self {
+        MessageDispatcher {
+            owner_name,
+            sender,
+            handlers,
+        }
+    }
+
+    pub fn dispatch(&self, message: &mut Message) {
+        let code = message.get_message_code();
+
+        if let Some(handler) = self.handlers.get_handler(code) {
+            message.set_pointer(8);
+            handler.handle(message, self.sender.clone());
+        } else {
+            warn!(
+                "[{}:dispatcher] No handler found for message code: {}",
+                self.owner_name,
+                message.get_message_code()
+            );
+        }
+    }
+}

soulseek-rs-lib/src/error.rs

@@ -0,0 +1,74 @@
+use std::{error::Error, fmt};
+
+/// Custom error type for the Soulseek download library
+#[derive(Debug)]
+pub enum SoulseekRs {
+    NetworkError(std::io::Error),
+    /// Authentication failed during login
+    AuthenticationFailed,
+    /// Error parsing messages or data
+    ParseError(String),
+    /// Operation timed out
+    Timeout,
+    /// Connection was closed unexpectedly
+    ConnectionClosed,
+    /// Invalid message format or content
+    InvalidMessage(String),
+    /// Server not connected
+    NotConnected,
+    /// Compression/decompression error
+    CompressionError(String),
+}
+
+impl fmt::Display for SoulseekRs {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SoulseekRs::NetworkError(err) => {
+                write!(f, "Network error: {}", err)
+            }
+            SoulseekRs::AuthenticationFailed => {
+                write!(f, "Authentication failed")
+            }
+            SoulseekRs::ParseError(msg) => write!(f, "Parse error: {}", msg),
+            SoulseekRs::Timeout => write!(f, "Operation timed out"),
+            SoulseekRs::ConnectionClosed => write!(f, "Connection closed"),
+            SoulseekRs::InvalidMessage(msg) => {
+                write!(f, "Invalid message: {}", msg)
+            }
+            SoulseekRs::NotConnected => write!(f, "Not connected to server"),
+            SoulseekRs::CompressionError(msg) => {
+                write!(f, "Compression error: {}", msg)
+            }
+        }
+    }
+}
+
+impl Error for SoulseekRs {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            SoulseekRs::NetworkError(err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl From<std::io::Error> for SoulseekRs {
+    fn from(err: std::io::Error) -> Self {
+        SoulseekRs::NetworkError(err)
+    }
+}
+
+impl From<std::num::ParseIntError> for SoulseekRs {
+    fn from(err: std::num::ParseIntError) -> Self {
+        SoulseekRs::ParseError(format!("Integer parse error: {}", err))
+    }
+}
+
+impl From<String> for SoulseekRs {
+    fn from(err: String) -> Self {
+        SoulseekRs::CompressionError(err)
+    }
+}
+
+/// Result type alias for the Soulseek library
+pub type Result<T> = std::result::Result<T, SoulseekRs>;

soulseek-rs-lib/src/lib.rs

@@ -0,0 +1,27 @@
+// Core modules
+pub mod actor;
+pub mod client;
+pub mod dispatcher;
+pub mod error;
+pub mod message;
+pub mod peer;
+pub mod types;
+#[macro_use]
+pub mod utils;
+
+// Prelude module for commonly used items
+pub mod prelude {
+    pub use crate::actor::server_actor::PeerAddress;
+    pub use crate::types::{
+        DownloadResult, DownloadStatus, File, FileSearchResult, Transfer,
+    };
+    pub use crate::{debug, error, info, trace, warn};
+}
+
+// Re-export commonly used types
+pub use actor::server_actor::PeerAddress;
+pub use client::Client;
+pub use error::{Result, SoulseekRs};
+pub use types::{
+    DownloadResult, DownloadStatus, File, FileSearchResult, Transfer,
+};

soulseek-rs-lib/src/message/handlers.rs

@@ -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)
+    }
+}

soulseek-rs-lib/src/message/message_reader.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/message/mod.rs

@@ -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"
+    );
+}

soulseek-rs-lib/src/message/peer/file_search_response.rs

@@ -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);
+}

soulseek-rs-lib/src/message/peer/get_share_file_list.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/peer/mod.rs

@@ -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;

soulseek-rs-lib/src/message/peer/peer_init.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/peer/place_in_queue_response.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/peer/transfer_request.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/peer/transfer_response.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/peer/upload_failed.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/message/server/connect_to_peer.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/server/excluded_search_phrases.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/message/server/file_search.rs

@@ -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
+        );
+    }
+}

soulseek-rs-lib/src/message/server/get_peer_address.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/server/login.rs

@@ -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());
+//     );
+// }

soulseek-rs-lib/src/message/server/message_factory.rs

@@ -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())
+}

soulseek-rs-lib/src/message/server/message_user.rs

@@ -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());
+// }
+// // }

soulseek-rs-lib/src/message/server/mod.rs

@@ -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;

soulseek-rs-lib/src/message/server/parent_min_speed.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/message/server/parent_speed_ratio.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/message/server/privileged_users.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/message/server/room_list.rs

@@ -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();
+    }
+}

soulseek-rs-lib/src/message/server/wish_list_interval.rs

@@ -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);
+    }
+}

soulseek-rs-lib/src/peer/download_peer.rs

@@ -0,0 +1,458 @@
+use std::env;
+use std::fs;
+use std::io::{self, Read, Write};
+use std::net::TcpStream;
+use std::net::ToSocketAddrs;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+
+use crate::client::ClientContext;
+use crate::message::server::MessageFactory;
+use crate::trace;
+use crate::types::Download;
+
+const START_DOWNLOAD: [u8; 8] =
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+const READ_BUFFER_SIZE: usize = 8192;
+
+#[derive(Debug)]
+pub enum DownloadError {
+    ConnectionFailed(io::Error),
+    InvalidAddress(String),
+    HandshakeFailed(io::Error),
+    StreamReadError(io::Error),
+    StreamWriteError(io::Error),
+    TokenNotFound(u32),
+    DownloadInfoMissing(u32),
+    FileWriteError(io::Error),
+    PathResolutionError(String),
+    InvalidTokenBytes,
+    LockPoisoned,
+}
+
+impl std::fmt::Display for DownloadError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ConnectionFailed(e) => write!(f, "Connection failed: {}", e),
+            Self::InvalidAddress(addr) => {
+                write!(f, "Invalid address: {}", addr)
+            }
+            Self::HandshakeFailed(e) => write!(f, "Handshake failed: {}", e),
+            Self::StreamReadError(e) => write!(f, "Stream read error: {}", e),
+            Self::StreamWriteError(e) => write!(f, "Stream write error: {}", e),
+            Self::TokenNotFound(token) => {
+                write!(f, "Token not found: {}", token)
+            }
+            Self::DownloadInfoMissing(token) => {
+                write!(f, "Download info missing for token: {}", token)
+            }
+            Self::FileWriteError(e) => write!(f, "File write error: {}", e),
+            Self::PathResolutionError(msg) => {
+                write!(f, "Path resolution error: {}", msg)
+            }
+            Self::InvalidTokenBytes => {
+                write!(f, "Invalid token bytes received")
+            }
+            Self::LockPoisoned => write!(f, "Lock poisoned"),
+        }
+    }
+}
+
+impl std::error::Error for DownloadError {}
+
+impl From<io::Error> for DownloadError {
+    fn from(error: io::Error) -> Self {
+        Self::StreamReadError(error)
+    }
+}
+
+struct FileManager;
+
+impl FileManager {
+    fn expand_path(path: &str) -> PathBuf {
+        if let Some(stripped) = path.strip_prefix('~') {
+            if let Ok(home) = env::var("HOME") {
+                PathBuf::from(home).join(stripped.trim_start_matches('/'))
+            } else {
+                PathBuf::from(path)
+            }
+        } else {
+            PathBuf::from(path)
+        }
+    }
+
+    fn extract_filename_from_path(full_path: &str) -> &str {
+        full_path
+            .split(['/', '\\'])
+            .next_back()
+            .unwrap_or(full_path)
+    }
+
+    fn create_download_path_from_filename(
+        output_directory: PathBuf,
+        filename: &str,
+    ) -> PathBuf {
+        let filename_only = Self::extract_filename_from_path(filename);
+        output_directory.join(filename_only)
+    }
+}
+
+struct StreamProcessor {
+    total_bytes: usize,
+    received: bool,
+    buffer: Vec<u8>,
+}
+
+impl StreamProcessor {
+    fn new() -> Self {
+        Self {
+            total_bytes: 0,
+            received: false,
+            buffer: Vec::new(),
+        }
+    }
+
+    fn process_data_chunk(&mut self, data: &[u8]) {
+        self.buffer.extend_from_slice(data);
+        self.total_bytes += data.len();
+    }
+
+    fn should_continue(&self, expected_size: Option<usize>) -> bool {
+        if let Some(size) = expected_size {
+            self.total_bytes < size
+        } else {
+            true
+        }
+    }
+}
+
+pub struct DownloadPeer {
+    username: String,
+    host: String,
+    port: u32,
+    #[allow(dead_code)]
+    own_username: String,
+    token: u32,
+    no_pierce: bool,
+}
+
+impl DownloadPeer {
+    #[must_use]
+    pub fn new(
+        username: String,
+        host: String,
+        port: u32,
+        token: u32,
+        no_pierce: bool,
+        own_username: String,
+    ) -> Self {
+        Self {
+            username,
+            host,
+            port,
+            own_username,
+            token,
+            no_pierce,
+        }
+    }
+
+    fn establish_connection(&self) -> Result<TcpStream, DownloadError> {
+        let socket_address = format!("{}:{}", self.host, self.port)
+            .to_socket_addrs()
+            .map_err(DownloadError::ConnectionFailed)?
+            .next()
+            .ok_or_else(|| {
+                DownloadError::InvalidAddress(format!(
+                    "{}:{}",
+                    self.host, self.port
+                ))
+            })?;
+
+        let stream = TcpStream::connect_timeout(
+            &socket_address,
+            Duration::from_secs(20),
+        )
+        .map_err(DownloadError::ConnectionFailed)?;
+
+        stream
+            .set_read_timeout(Some(Duration::from_secs(30)))
+            .map_err(DownloadError::ConnectionFailed)?;
+        stream
+            .set_write_timeout(Some(Duration::from_secs(5)))
+            .map_err(DownloadError::ConnectionFailed)?;
+        stream
+            .set_nodelay(true)
+            .map_err(DownloadError::ConnectionFailed)?;
+
+        Ok(stream)
+    }
+
+    fn perform_handshake(
+        &self,
+        stream: &mut TcpStream,
+    ) -> Result<(), DownloadError> {
+        trace!(
+            "[download_peer:{}] performing handshake no_pierce: {}",
+            self.username,
+            self.no_pierce
+        );
+
+        if !self.no_pierce {
+            let message =
+                MessageFactory::build_pierce_firewall_message(self.token);
+            stream
+                .write_all(&message.get_buffer())
+                .map_err(DownloadError::HandshakeFailed)?;
+            trace!(
+                "[download_peer:{}] sending pierce firewall message token: {}: {:?}",
+                self.username,
+                self.token,
+                &message.get_buffer()
+            );
+            stream.flush().map_err(DownloadError::HandshakeFailed)?;
+        }
+        Ok(())
+    }
+
+    fn handle_pierce_firewall_response(
+        &self,
+        data: &[u8],
+        stream: &mut TcpStream,
+        client_context: &Arc<RwLock<ClientContext>>,
+    ) -> Result<Download, DownloadError> {
+        let token_bytes =
+            data.get(0..4).ok_or(DownloadError::InvalidTokenBytes)?;
+        let token_array: [u8; 4] = token_bytes
+            .try_into()
+            .map_err(|_| DownloadError::InvalidTokenBytes)?;
+        let token_u32 = u32::from_le_bytes(token_array);
+
+        trace!(
+            "[download_peer:{}] got token: {} from data chunk",
+            self.username,
+            token_u32
+        );
+
+        stream
+            .write_all(&START_DOWNLOAD)
+            .map_err(DownloadError::StreamWriteError)?;
+
+        let client_guard = client_context
+            .read()
+            .map_err(|_| DownloadError::LockPoisoned)?;
+        let download_info =
+            client_guard.download_tokens.get(&token_u32).cloned();
+        drop(client_guard);
+
+        download_info.ok_or(DownloadError::TokenNotFound(token_u32))
+    }
+
+    fn read_download_stream(
+        &self,
+        stream: &mut TcpStream,
+        client_context: &Arc<RwLock<ClientContext>>,
+        mut download: Option<Download>,
+    ) -> Result<(Vec<u8>, Download), DownloadError> {
+        let mut processor = StreamProcessor::new();
+        let mut read_buffer = [1u8; READ_BUFFER_SIZE];
+
+        trace!(
+            "[download_peer:{}] Starting to read data from peer",
+            self.username
+        );
+
+        if download.is_some() {
+            stream
+                .write_all(&START_DOWNLOAD)
+                .map_err(DownloadError::StreamWriteError)?;
+        }
+
+        loop {
+            match stream.read(&mut read_buffer) {
+                Ok(0) => {
+                    trace!(
+                        "[download_peer:{}] connection closed by peer. bytes read: {}",
+                        self.username,
+                        processor.total_bytes
+                    );
+                    break;
+                }
+                Ok(bytes_read) => {
+                    let data = &read_buffer[..bytes_read];
+
+                    if !self.no_pierce && !processor.received {
+                        let new_download = self
+                            .handle_pierce_firewall_response(
+                                data,
+                                stream,
+                                client_context,
+                            )?;
+                        trace!(
+                            "[download_peer:{}] got download info for token: {} - filename: {}",
+                            self.username,
+                            self.token,
+                            new_download.filename
+                        );
+                        download = Some(new_download);
+                        processor.received = true;
+                        continue;
+                    }
+
+                    processor.process_data_chunk(data);
+
+                    let expected_size = download
+                        .as_ref()
+                        .ok_or(DownloadError::DownloadInfoMissing(self.token))?
+                        .size as usize;
+
+                    if !processor.should_continue(Some(expected_size)) {
+                        break;
+                    }
+                }
+                Err(e) => {
+                    return Err(DownloadError::StreamReadError(e));
+                }
+            }
+        }
+
+        trace!(
+            "[download_peer:{}] finished reading data from peer",
+            self.username
+        );
+
+        let download =
+            download.ok_or(DownloadError::DownloadInfoMissing(self.token))?;
+
+        Ok((processor.buffer, download))
+    }
+
+    fn resolve_download_path(
+        &self,
+        download: &Download,
+    ) -> Result<String, DownloadError> {
+        let download_directory = &download.download_directory;
+        let mut expanded_path = FileManager::expand_path(download_directory);
+
+        if !expanded_path.is_dir() {
+            expanded_path = expanded_path
+                .parent()
+                .ok_or_else(|| {
+                    DownloadError::PathResolutionError(format!(
+                        "Cannot resolve parent directory for: {}",
+                        expanded_path.display()
+                    ))
+                })?
+                .to_path_buf();
+        }
+
+        let final_path = FileManager::create_download_path_from_filename(
+            expanded_path,
+            &download.filename,
+        );
+
+        final_path
+            .to_str()
+            .ok_or_else(|| {
+                DownloadError::PathResolutionError(format!(
+                    "Path contains invalid UTF-8: {}",
+                    final_path.display()
+                ))
+            })
+            .map(String::from)
+    }
+
+    fn save_downloaded_file(
+        &self,
+        path: &str,
+        data: &[u8],
+    ) -> Result<(), DownloadError> {
+        if let Some(parent) = Path::new(path).parent() {
+            fs::create_dir_all(parent)
+                .map_err(DownloadError::FileWriteError)?;
+        }
+
+        fs::write(path, data).map_err(DownloadError::FileWriteError)?;
+
+        Ok(())
+    }
+
+    pub fn download_file(
+        self,
+        client_context: Arc<RwLock<ClientContext>>,
+        download: Option<Download>,
+        stream: Option<TcpStream>,
+    ) -> Result<(Download, String), DownloadError> {
+        trace!(
+            "[download_peer:{}] download_file: download is present?: {:?}, stream is present?: {:?}, no_pierce: {}",
+            self.username,
+            download.is_some(),
+            stream.is_some(),
+            self.no_pierce
+        );
+
+        let mut stream = match stream {
+            Some(s) => s,
+            None => self.establish_connection()?,
+        };
+
+        trace!("[download_peer:{}] connected", self.username);
+
+        self.perform_handshake(&mut stream)?;
+        trace!("[download_peer:{}] handshake completed", self.username);
+
+        let (buffer, download) =
+            self.read_download_stream(&mut stream, &client_context, download)?;
+
+        let final_path = self.resolve_download_path(&download)?;
+        self.save_downloaded_file(&final_path, &buffer)?;
+
+        trace!(
+            "[download_peer:{}] download completed successfully: {} bytes, saved to: {}",
+            self.username,
+            buffer.len(),
+            final_path
+        );
+
+        Ok((download, final_path))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{DownloadPeer, FileManager};
+
+    #[test]
+    fn test_establish_connection_invalid_address() {
+        let download_peer = DownloadPeer::new(
+            "user".to_string(),
+            "invalid-host".to_string(),
+            9999,
+            123,
+            false,
+            "own_user".to_string(),
+        );
+        let result = download_peer.establish_connection();
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_extract_filename_from_path() {
+        assert_eq!(
+            FileManager::extract_filename_from_path("/path/to/file.mp3"),
+            "file.mp3"
+        );
+        assert_eq!(
+            FileManager::extract_filename_from_path("C:\\path\\to\\file.mp3"),
+            "file.mp3"
+        );
+        assert_eq!(
+            FileManager::extract_filename_from_path("@@bhfrv\\Soulseek Downloads\\complete\\Beatport Top Deep House (2021)\\michel test file.mp3"),
+            "michel test file.mp3"
+        );
+        assert_eq!(
+            FileManager::extract_filename_from_path("file.mp3"),
+            "file.mp3"
+        );
+    }
+}

soulseek-rs-lib/src/peer/listen.rs

@@ -0,0 +1,275 @@
+use std::io;
+use std::net::{TcpListener, TcpStream};
+use std::sync::mpsc::Sender;
+use std::sync::{Arc, RwLock};
+use std::thread;
+
+use crate::client::{ClientContext, ClientOperation};
+
+use crate::message::{Message, MessageReader};
+use crate::peer::{ConnectionType, DownloadPeer, Peer};
+use crate::types::Download;
+use crate::{debug, error, info, trace, DownloadStatus};
+
+const PEER_INIT_MESSAGE_CODE: u8 = 1;
+
+#[derive(Clone)]
+struct ConnectionContext {
+    #[allow(dead_code)]
+    client_sender: Sender<ClientOperation>,
+    client_context: Arc<RwLock<ClientContext>>,
+    own_username: String,
+}
+
+struct PeerInitData {
+    username: String,
+    connection_type: ConnectionType,
+    token: u32,
+}
+
+fn read_peer_init_message(
+    stream: &mut TcpStream,
+    reader: &mut MessageReader,
+) -> io::Result<Message> {
+    loop {
+        reader.read_from_socket(stream)?;
+
+        if let Ok(Some(msg)) = reader.extract_message() {
+            return Ok(msg);
+        }
+    }
+}
+
+fn parse_peer_init_message(mut message: Message) -> Option<PeerInitData> {
+    message.set_pointer(4);
+    let message_code = message.read_int8();
+
+    if message_code != PEER_INIT_MESSAGE_CODE {
+        return None;
+    }
+
+    Some(PeerInitData {
+        username: message.read_string(),
+        connection_type: message.read_string().parse().unwrap(),
+        token: message.read_int32(),
+    })
+}
+
+fn parse_token_from_buffer(buffer: &[u8], username: &str) -> Option<u32> {
+    let token_bytes = buffer.get(0..4)?;
+    let token = u32::from_le_bytes(
+        token_bytes
+            .try_into()
+            .unwrap_or_else(|_| panic!("[listener:{}] slice with incorrect length, can't extract transfer_token", username)),
+    );
+    Some(token)
+}
+
+fn extract_download_from_buffer(
+    reader: &mut MessageReader,
+    client_context: &Arc<RwLock<ClientContext>>,
+    username: &str,
+    peer_ip: &str,
+    peer_port: u16,
+) -> Option<Download> {
+    if reader.buffer_len() == 0 {
+        return None;
+    }
+    let buffer = reader.get_buffer();
+    let token = parse_token_from_buffer(&buffer, username)?;
+    trace!(
+        "[listener:{}] got transfer_token: {} from data chunk",
+        username,
+        token
+    );
+
+    let context = client_context.read().unwrap();
+    let download = context.download_tokens.get(&token).cloned();
+
+    if download.is_none() {
+        let download_tokens: Vec<u32> =
+            context.download_tokens.keys().cloned().collect();
+        trace!("[listener:{peer_ip}:{peer_port}] download token not found: {:?}, download tokens: {:?}", token, download_tokens);
+    }
+
+    download
+}
+
+fn handle_peer_connection(
+    peer: Peer,
+    stream: TcpStream,
+    reader: MessageReader,
+    context: &ConnectionContext,
+    _peer_ip: &str,
+    _peer_port: u16,
+) {
+    let client_context = context.client_context.read().unwrap();
+    if let Some(ref registry) = client_context.peer_registry {
+        match registry.register_peer(peer.clone(), Some(stream), Some(reader)) {
+            Ok(_) => (),
+            Err(e) => {
+                error!(
+                    "Failed to spawn peer actor for {:?}: {:?}",
+                    peer.username, e
+                );
+            }
+        }
+    } else {
+        error!("PeerRegistry not initialized");
+    }
+}
+
+fn handle_file_connection(
+    peer: Peer,
+    stream: TcpStream,
+    mut reader: MessageReader,
+    token: u32,
+    context: &ConnectionContext,
+    peer_ip: &str,
+    peer_port: u16,
+) {
+    trace!(
+        "[client] DownloadFromPeer token: {} peer: {:?}",
+        token,
+        peer
+    );
+
+    let download = extract_download_from_buffer(
+        &mut reader,
+        &context.client_context,
+        &peer.username,
+        peer_ip,
+        peer_port,
+    );
+
+    let download_peer = DownloadPeer::new(
+        format!("{}:direct", peer.username),
+        peer.host.clone(),
+        peer.port,
+        token,
+        true,
+        context.own_username.clone(),
+    );
+
+    match download_peer.download_file(
+        context.client_context.clone(),
+        download,
+        Some(stream),
+    ) {
+        Ok((download, filename)) => {
+            download.sender.send(DownloadStatus::Completed).unwrap();
+            info!(
+                "Successfully downloaded {} bytes to {}",
+                download.size, filename
+            );
+        }
+        Err(e) => {
+            error!(
+                "Failed to download file from {}:{} (token: {}) - Error: {}",
+                peer.host, peer.port, token, e
+            );
+        }
+    }
+}
+
+fn handle_incoming_connection(stream: TcpStream, context: ConnectionContext) {
+    let Ok(peer_addr) = stream.peer_addr() else {
+        error!("[listener] failed to get peer address");
+        return;
+    };
+
+    let peer_ip = peer_addr.ip().to_string();
+    let peer_port = peer_addr.port();
+    let mut stream = stream;
+    let mut reader = MessageReader::new();
+
+    let Ok(message) = read_peer_init_message(&mut stream, &mut reader) else {
+        error!(
+            "[listener:{peer_ip}:{peer_port}] Failed to read peer init message"
+        );
+        return;
+    };
+
+    let Some(init_data) = parse_peer_init_message(message) else {
+        error!("[listener:{peer_ip}:{peer_port}] Invalid or unknown peer init message");
+        return;
+    };
+
+    debug!(
+        "[listener:{peer_ip}:{peer_port}] peerInit (0)  username: {} connection_type: {} token: {}",
+        init_data.username, init_data.connection_type, init_data.token
+    );
+
+    let peer = Peer::new(
+        format!("{}:direct", init_data.username),
+        // init_data.username.clone(),
+        init_data.connection_type.clone(),
+        peer_ip.clone(),
+        peer_port.into(),
+        None,
+        0,
+        0,
+        0,
+    );
+
+    match init_data.connection_type {
+        ConnectionType::P => handle_peer_connection(
+            peer, stream, reader, &context, &peer_ip, peer_port,
+        ),
+
+        ConnectionType::F => {
+            thread::spawn(move || {
+                trace!(
+                    "[listener:{peer_ip}:{peer_port}] handling file connection in thread"
+                );
+                handle_file_connection(
+                    peer,
+                    stream,
+                    reader,
+                    init_data.token,
+                    &context,
+                    &peer_ip,
+                    peer_port,
+                )
+            });
+        }
+        ConnectionType::D => {
+            debug!("[listener:{peer_ip}:{peer_port}] connection type is D, not supported yet, closing connection. ");
+        }
+    }
+}
+
+pub struct Listen {}
+
+impl Listen {
+    pub fn start(
+        port: u32,
+        client_sender: Sender<ClientOperation>,
+        client_context: Arc<RwLock<ClientContext>>,
+        own_username: String,
+    ) {
+        info!("[listener] starting listener on port {port}");
+
+        let listener = TcpListener::bind(format!("0.0.0.0:{port}"))
+            .expect("Failed to bind listener to port");
+
+        let context = ConnectionContext {
+            client_sender,
+            client_context,
+            own_username,
+        };
+
+        for stream in listener.incoming() {
+            let Ok(stream) = stream else {
+                error!(
+                    "[listener] Failed to accept connection: {}",
+                    stream.unwrap_err()
+                );
+                continue;
+            };
+
+            let context = context.clone();
+            handle_incoming_connection(stream, context);
+        }
+    }
+}

soulseek-rs-lib/src/peer/mod.rs

@@ -0,0 +1,199 @@
+mod download_peer;
+pub mod listen;
+
+// Export actor types
+pub use crate::actor::peer_actor::{PeerActor, PeerMessage};
+pub use crate::actor::peer_registry::PeerRegistry;
+
+pub use download_peer::DownloadPeer;
+
+use crate::message::Message;
+use core::fmt;
+use std::{net::TcpStream, str::FromStr};
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct NewPeer {
+    pub username: String,
+    pub connection_type: ConnectionType,
+    pub token: u32,
+    pub tcp_stream: TcpStream,
+}
+impl NewPeer {
+    pub fn new_from_message(
+        message: &mut Message,
+        tcp_stream: TcpStream,
+    ) -> Self {
+        let username = message.read_string();
+        let connection_type = message.read_string().parse().unwrap();
+        let token = message.read_int32();
+
+        Self {
+            username,
+            connection_type,
+            token,
+            tcp_stream,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ConnectionType {
+    P,
+    F,
+    D,
+}
+
+#[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 {}
+
+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),
+        }
+    }
+}
+
+impl fmt::Display for ConnectionType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let s = match self {
+            ConnectionType::P => "P",
+            ConnectionType::F => "F",
+            ConnectionType::D => "D",
+        };
+        write!(f, "{}", s)
+    }
+}
+
+#[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: Option<u8>,
+    pub unknown: Option<u8>,
+    pub obfuscated_port: Option<u8>,
+}
+impl Peer {
+    #[allow(clippy::too_many_arguments, dead_code)]
+    pub fn new(
+        username: String,
+        connection_type: ConnectionType,
+        host: String,
+        port: u32,
+        token: Option<u32>,
+        privileged: u8,
+        unknown: u8,
+        obfuscated_port: u8,
+    ) -> Self {
+        Self {
+            username,
+            connection_type,
+            host,
+            port,
+            token,
+            privileged: Some(privileged),
+            unknown: Some(unknown),
+            obfuscated_port: Some(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: Some(privileged),
+            unknown: Some(unknown),
+            obfuscated_port: Some(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.231.27");
+    assert_eq!(peer.port, 2234);
+    assert_eq!(peer.token, Some(1658546));
+    assert_eq!(peer.privileged, Some(0));
+    assert_eq!(peer.unknown, Some(0));
+    assert_eq!(peer.obfuscated_port, Some(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);
+
+    println!("code: {}", message.get_message_code_u32());
+
+    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.193.128.137");
+    assert_eq!(peer.port, 2235);
+    assert_eq!(peer.token, Some(4154));
+    assert_eq!(peer.privileged, Some(0));
+    assert_eq!(peer.unknown, Some(1));
+    assert_eq!(peer.obfuscated_port, Some(0));
+}

soulseek-rs-lib/src/types.rs

@@ -0,0 +1,126 @@
+use std::{collections::HashMap, sync::mpsc::Sender};
+
+use crate::{error::Result, message::Message, utils::zlib::deflate};
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct File {
+    pub username: String,
+    pub name: String,
+    pub size: u64,
+    pub attribs: HashMap<u32, u32>,
+}
+pub struct UploadFailed {
+    pub filename: String,
+}
+impl UploadFailed {
+    pub fn new_from_message(message: &mut Message) -> Self {
+        let filename = message.read_string();
+
+        Self { filename }
+    }
+}
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct FileSearchResult {
+    pub token: u32,
+    pub files: Vec<File>,
+    pub slots: u8,
+    pub speed: u32,
+    pub username: String,
+}
+
+impl FileSearchResult {
+    pub fn new_from_message(message: &mut Message) -> Result<Self> {
+        let pointer = message.get_pointer();
+        let size = message.get_size();
+        let data: Vec<u8> = message.get_slice(pointer, size);
+        let deflated = deflate(&data)?;
+        let mut message = Message::new_with_data(deflated);
+
+        let username = message.read_string();
+        let token = message.read_int32();
+        let n_files = message.read_int32();
+        let mut files: Vec<File> = Vec::new();
+        for _ in 0..n_files {
+            message.read_int8();
+            let name = message.read_string();
+            let size = message.read_int64();
+            message.read_string();
+            let n_attribs = message.read_int32();
+            let mut attribs: HashMap<u32, u32> = HashMap::new();
+
+            for _ in 0..n_attribs {
+                attribs.insert(message.read_int32(), message.read_int32());
+            }
+            files.push(File {
+                username: username.clone(),
+                name,
+                size,
+                attribs,
+            });
+        }
+        let slots = message.read_int8();
+        let speed = message.read_int32();
+
+        Ok(Self {
+            token,
+            files,
+            slots,
+            speed,
+            username,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct Transfer {
+    pub direction: u32,
+    pub token: u32,
+    pub filename: String,
+    pub size: u64,
+}
+#[derive(Debug, Clone)]
+pub struct Download {
+    pub username: String,
+    pub filename: String,
+    pub token: u32,
+    pub size: u64,
+    pub download_directory: String,
+    pub sender: Sender<DownloadStatus>,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct DownloadResult {
+    pub filename: String,
+    pub username: String,
+    pub status: DownloadStatus,
+    pub elapsed_time: std::time::Duration,
+}
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub enum DownloadStatus {
+    Pending,
+    InProgress,
+    Completed,
+    Failed,
+    TimedOut,
+}
+impl Transfer {
+    pub fn new_from_message(message: &mut Message) -> Self {
+        let direction = message.read_int32();
+        let token = message.read_int32();
+        let filename = message.read_string();
+        let size = message.read_int64();
+
+        Self {
+            direction,
+            token,
+            filename,
+            size,
+        }
+    }
+}

soulseek-rs-lib/src/utils/logger.rs

@@ -0,0 +1,149 @@
+use std::env;
+use std::sync::Once;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum LogLevel {
+    Error = 0,
+    Warn = 1,
+    Info = 2,
+    Debug = 3,
+    Trace = 4,
+}
+
+static INIT: Once = Once::new();
+static mut LOG_LEVEL: LogLevel = LogLevel::Warn;
+
+pub fn init() {
+    INIT.call_once(|| {
+        let level = env::var("LOG_LEVEL")
+            .or_else(|_| env::var("RUST_LOG"))
+            .unwrap_or_else(|_| "WARN".to_string())
+            .to_uppercase();
+
+        unsafe {
+            LOG_LEVEL = match level.as_str() {
+                "ERROR" => LogLevel::Error,
+                "WARN" => LogLevel::Warn,
+                "INFO" => LogLevel::Info,
+                "DEBUG" => LogLevel::Debug,
+                "TRACE" => LogLevel::Trace,
+                "VERBOSE" => LogLevel::Debug, // Map VERBOSE to DEBUG
+                _ => LogLevel::Warn,          // Default to WARN
+            };
+        }
+    });
+}
+
+pub fn log(level: LogLevel, message: &str) {
+    unsafe {
+        if level <= LOG_LEVEL {
+            let level_str = match level {
+                LogLevel::Error => "\x1b[31mERROR\x1b[0m", // Red
+                LogLevel::Warn => "\x1b[33mWARN\x1b[0m",   // Yellow
+                LogLevel::Info => "\x1b[32mINFO\x1b[0m",   // Green
+                LogLevel::Debug => "\x1b[34mDEBUG\x1b[0m", // Blue
+                LogLevel::Trace => "\x1b[35mTRACE\x1b[0m", // Magenta
+            };
+
+            let now = std::time::SystemTime::now();
+            let datetime = now.duration_since(std::time::UNIX_EPOCH).unwrap();
+            let secs = datetime.as_secs();
+            let subsec_millis = datetime.subsec_millis();
+
+            // Format as YYYY-MM-DD HH:MM:SS.mmm
+            let days_since_epoch = secs / 86400;
+            let days_since_1970 = days_since_epoch as i32;
+
+            // Calculate year (approximately)
+            let mut year = 1970;
+            let mut remaining_days = days_since_1970;
+
+            while remaining_days >= 365 {
+                let is_leap =
+                    (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
+                let days_in_year = if is_leap { 366 } else { 365 };
+                if remaining_days >= days_in_year {
+                    remaining_days -= days_in_year;
+                    year += 1;
+                } else {
+                    break;
+                }
+            }
+
+            // Calculate month and day (simplified)
+            let month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+            let is_leap =
+                (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
+            let mut month = 1;
+            let mut day = remaining_days + 1;
+
+            for &days_in_month in &month_days {
+                let actual_days = if month == 2 && is_leap {
+                    29
+                } else {
+                    days_in_month
+                };
+                if day > actual_days {
+                    day -= actual_days;
+                    month += 1;
+                } else {
+                    break;
+                }
+            }
+
+            // Calculate time of day
+            let seconds_in_day = secs % 86400;
+            let hours = seconds_in_day / 3600;
+            let minutes = (seconds_in_day % 3600) / 60;
+            let seconds = seconds_in_day % 60;
+
+            eprintln!(
+                "[{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}] [{}] {}",
+                year,
+                month,
+                day,
+                hours,
+                minutes,
+                seconds,
+                subsec_millis,
+                level_str,
+                message
+            );
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! error {
+    ($($arg:tt)*) => {
+        $crate::utils::logger::log($crate::utils::logger::LogLevel::Error, &format!($($arg)*))
+    };
+}
+
+#[macro_export]
+macro_rules! warn {
+    ($($arg:tt)*) => {
+        $crate::utils::logger::log($crate::utils::logger::LogLevel::Warn, &format!($($arg)*))
+    };
+}
+
+#[macro_export]
+macro_rules! info {
+    ($($arg:tt)*) => {
+        $crate::utils::logger::log($crate::utils::logger::LogLevel::Info, &format!($($arg)*))
+    };
+}
+
+#[macro_export]
+macro_rules! debug {
+    ($($arg:tt)*) => {
+        $crate::utils::logger::log($crate::utils::logger::LogLevel::Debug, &format!($($arg)*))
+    };
+}
+
+#[macro_export]
+macro_rules! trace {
+    ($($arg:tt)*) => {
+        $crate::utils::logger::log($crate::utils::logger::LogLevel::Trace, &format!($($arg)*))
+    };
+}

soulseek-rs-lib/src/utils/md5.rs

@@ -0,0 +1,474 @@
+use std::convert::TryInto;
+// The MD5 Message-Digest Algorithm, written in Rust.
+// Implemented by michael dimovich (@mdimovich)
+//
+// The purpose of this code is to act as a learning resource
+// for the md5 message digest algorithm. I wanted to provide
+// a straightforward walk-through of the md5 algorithm using
+// Rust.
+//
+// This code was implemented using the original md5 message digest
+// RFC, written by R. Rivest in April 1992.
+//
+// For more information about the md5 algorithm, or the original C
+// source code implementation, please reference RFC 1321.
+//
+// (source: https://datatracker.ietf.org/doc/html/rfc1321)
+
+/**
+* This function is specified in the rfc as a way to generate the
+* table that we use in rounds 1-4 as part of the hashing operation.
+* The function is specified as:
+* K[i] = floor(2^32 * abs(sin(i+1)))
+*/
+fn table_construction_function(i: u32) -> u32 {
+    let x: f64 = i as f64;
+    let sin_eval = x.sin().abs();
+    // note: 4294967296 == 2^32
+    (4294967296.0 * sin_eval) as u32
+}
+
+/**
+* 4 auxiliary functions that take 3 32-bit
+* integers as input and return 1 32 bit integer as output.
+*
+* these bitwise operations are the crux of the md5 hashing
+* algorithm, and they are performed a number of times to end
+* up with our final result.
+*/
+fn f(x: u32, y: u32, z: u32) -> u32 {
+    x & y | !x & z
+}
+
+fn g(x: u32, y: u32, z: u32) -> u32 {
+    x & z | y & !z
+}
+
+fn h(x: u32, y: u32, z: u32) -> u32 {
+    x ^ y ^ z
+}
+
+fn i(x: u32, y: u32, z: u32) -> u32 {
+    y ^ (x | !z)
+}
+
+// utility function to convert a vector of type T with size N into an array of type T with size N.
+fn vec_to_array<T, const N: usize>(v: Vec<T>) -> [T; N] {
+    v.try_into().unwrap_or_else(|_v: Vec<T>| {
+        panic!("error converting vector to array - sizes don't match")
+    })
+}
+
+/**
+* Round 1 function is specified as 16 operations using the following:
+* Let [abcd, k s i] denote the operation -
+* a = b + ((a + f(b,c,d) + x[k] + table[i]) <<< s);
+* where x[k] is a 32 bit chunk of our original message,
+* table[i] is an entry generated by our sine function, s is an unsigned
+* integer, and a,b,c,d are our 32 bit registers we perform operations on.
+*/
+fn round_one_operations(
+    mut a: u32,
+    mut b: u32,
+    mut c: u32,
+    mut d: u32,
+    table: &[u32],
+    x: &[u32],
+) -> [u32; 4] {
+    let _ = x;
+    let _ = table;
+    macro_rules! round1 {
+        ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i: expr ) => {
+            $a = $b.wrapping_add(
+                ($a.wrapping_add(f($b, $c, $d))
+                    .wrapping_add(x[$k])
+                    .wrapping_add(table[$i]))
+                .rotate_left($s),
+            )
+        };
+    }
+
+    round1!(a, b, c, d, 0, 7, 1);
+    round1!(d, a, b, c, 1, 12, 2);
+    round1!(c, d, a, b, 2, 17, 3);
+    round1!(b, c, d, a, 3, 22, 4);
+
+    round1!(a, b, c, d, 4, 7, 5);
+    round1!(d, a, b, c, 5, 12, 6);
+    round1!(c, d, a, b, 6, 17, 7);
+    round1!(b, c, d, a, 7, 22, 8);
+
+    round1!(a, b, c, d, 8, 7, 9);
+    round1!(d, a, b, c, 9, 12, 10);
+    round1!(c, d, a, b, 10, 17, 11);
+    round1!(b, c, d, a, 11, 22, 12);
+
+    round1!(a, b, c, d, 12, 7, 13);
+    round1!(d, a, b, c, 13, 12, 14);
+    round1!(c, d, a, b, 14, 17, 15);
+    round1!(b, c, d, a, 15, 22, 16);
+
+    [a, b, c, d]
+}
+
+/**
+* Round 2 is equivalent to round 1, except we swap out our f function for g as such:
+* a = b + ((a + g(b,c,d) + x[k] + table[i]) <<< s);
+*/
+fn round_two_operations(
+    mut a: u32,
+    mut b: u32,
+    mut c: u32,
+    mut d: u32,
+    table: &[u32],
+    x: &[u32],
+) -> [u32; 4] {
+    macro_rules! round2 {
+        ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i:expr) => {
+            $a = $b.wrapping_add(
+                ($a.wrapping_add(g($b, $c, $d))
+                    .wrapping_add(x[$k])
+                    .wrapping_add(table[$i]))
+                .rotate_left($s),
+            )
+        };
+    }
+
+    round2!(a, b, c, d, 1, 5, 17);
+    round2!(d, a, b, c, 6, 9, 18);
+    round2!(c, d, a, b, 11, 14, 19);
+    round2!(b, c, d, a, 0, 20, 20);
+
+    round2!(a, b, c, d, 5, 5, 21);
+    round2!(d, a, b, c, 10, 9, 22);
+    round2!(c, d, a, b, 15, 14, 23);
+    round2!(b, c, d, a, 4, 20, 24);
+
+    round2!(a, b, c, d, 9, 5, 25);
+    round2!(d, a, b, c, 14, 9, 26);
+    round2!(c, d, a, b, 3, 14, 27);
+    round2!(b, c, d, a, 8, 20, 28);
+
+    round2!(a, b, c, d, 13, 5, 29);
+    round2!(d, a, b, c, 2, 9, 30);
+    round2!(c, d, a, b, 7, 14, 31);
+    round2!(b, c, d, a, 12, 20, 32);
+
+    [a, b, c, d]
+}
+
+/**
+* Round 3 is equivalent to round 1, except we swap out our f function for h as such:
+* a = b + ((a + h(b,c,d) + x[k] + table[i]) <<< s);
+*/
+fn round_three_operations(
+    mut a: u32,
+    mut b: u32,
+    mut c: u32,
+    mut d: u32,
+    table: &[u32],
+    x: &[u32],
+) -> [u32; 4] {
+    macro_rules! round3 {
+        ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i:expr  ) => {
+            $a = $b.wrapping_add(
+                ($a.wrapping_add(h($b, $c, $d))
+                    .wrapping_add(x[$k])
+                    .wrapping_add(table[$i]))
+                .rotate_left($s),
+            )
+        };
+    }
+
+    round3!(a, b, c, d, 5, 4, 33);
+    round3!(d, a, b, c, 8, 11, 34);
+    round3!(c, d, a, b, 11, 16, 35);
+    round3!(b, c, d, a, 14, 23, 36);
+
+    round3!(a, b, c, d, 1, 4, 37);
+    round3!(d, a, b, c, 4, 11, 38);
+    round3!(c, d, a, b, 7, 16, 39);
+    round3!(b, c, d, a, 10, 23, 40);
+
+    round3!(a, b, c, d, 13, 4, 41);
+    round3!(d, a, b, c, 0, 11, 42);
+    round3!(c, d, a, b, 3, 16, 43);
+    round3!(b, c, d, a, 6, 23, 44);
+
+    round3!(a, b, c, d, 9, 4, 45);
+    round3!(d, a, b, c, 12, 11, 46);
+    round3!(c, d, a, b, 15, 16, 47);
+    round3!(b, c, d, a, 2, 23, 48);
+
+    [a, b, c, d]
+}
+
+/**
+* Round 4 is equivalent to round 1, except we swap out our f function for h as such:
+* a = b + ((a + i(b,c,d) + x[k] + table[i]) <<< s);
+*/
+fn round_four_operations(
+    mut a: u32,
+    mut b: u32,
+    mut c: u32,
+    mut d: u32,
+    table: &[u32],
+    x: &[u32],
+) -> [u32; 4] {
+    macro_rules! round4 {
+        ( $a:ident, $b:ident, $c:ident, $d:ident, $k:expr, $s:expr, $i:expr ) => {
+            $a = $b.wrapping_add(
+                ($a.wrapping_add(i($b, $c, $d))
+                    .wrapping_add(x[$k])
+                    .wrapping_add(table[$i]))
+                .rotate_left($s),
+            )
+        };
+    }
+
+    round4!(a, b, c, d, 0, 6, 49);
+    round4!(d, a, b, c, 7, 10, 50);
+    round4!(c, d, a, b, 14, 15, 51);
+    round4!(b, c, d, a, 5, 21, 52);
+
+    round4!(a, b, c, d, 12, 6, 53);
+    round4!(d, a, b, c, 3, 10, 54);
+    round4!(c, d, a, b, 10, 15, 55);
+    round4!(b, c, d, a, 1, 21, 56);
+
+    round4!(a, b, c, d, 8, 6, 57);
+    round4!(d, a, b, c, 15, 10, 58);
+    round4!(c, d, a, b, 6, 15, 59);
+    round4!(b, c, d, a, 13, 21, 60);
+
+    round4!(a, b, c, d, 4, 6, 61);
+    round4!(d, a, b, c, 11, 10, 62);
+    round4!(c, d, a, b, 2, 15, 63);
+    round4!(b, c, d, a, 9, 21, 64);
+
+    [a, b, c, d]
+}
+
+/**
+* utility function to iterate over our slice of u8 ints
+* and convert into a vector of unsigned 32 bit ints
+*/
+fn convert_u8_chunk_to_u32(chunk: &mut [u8]) -> Vec<u32> {
+    let mut x: Vec<u32> = Vec::new();
+
+    let mut count = 0;
+    let mut temporary_vec: Vec<u8> = Vec::new();
+    // iterate over our block and take
+    // our 8 bit ints and convert them to
+    // 32 bit integers
+    for item in chunk {
+        temporary_vec.push(*item);
+        count += 1;
+        if count == 4 {
+            let temp_arr: [u8; 4] = vec_to_array(temporary_vec.clone());
+            let value = u32::from_ne_bytes(temp_arr);
+            x.push(value);
+            count = 0;
+            temporary_vec.clear();
+        }
+    }
+    x
+}
+
+fn compute_md5_digest(mut v: Vec<u8>) -> String {
+    // as described in the rfc,
+    // 4 32-bit words initialized as fixed constants.
+    let mut word_a = 0x67452301u32;
+    let mut word_b = 0xefcdab89u32;
+    let mut word_c = 0x98badcfeu32;
+    let mut word_d = 0x10325476u32;
+
+    // construct the 64 element constant table.
+    let table = construct_value_table();
+
+    // let M[0 .. N-1] = words of resulting message, where N is multiple of 16
+    for chunk in v.chunks_exact_mut(64) {
+        let x = convert_u8_chunk_to_u32(chunk);
+
+        // set all values of a,b,c,d to aa,bb,cc, and dd respectively.
+        // this is to save the initial values.
+        let word_aa = word_a;
+        let word_bb = word_b;
+        let word_cc = word_c;
+        let word_dd = word_d;
+
+        // execute round 1
+        let result =
+            round_one_operations(word_a, word_b, word_c, word_d, &table, &x);
+        word_a = result[0];
+        word_b = result[1];
+        word_c = result[2];
+        word_d = result[3];
+
+        // execute round 2
+        let result =
+            round_two_operations(word_a, word_b, word_c, word_d, &table, &x);
+
+        word_a = result[0];
+        word_b = result[1];
+        word_c = result[2];
+        word_d = result[3];
+
+        // execute round 3
+        let result =
+            round_three_operations(word_a, word_b, word_c, word_d, &table, &x);
+        word_a = result[0];
+        word_b = result[1];
+        word_c = result[2];
+        word_d = result[3];
+
+        // execute round 4
+        let result =
+            round_four_operations(word_a, word_b, word_c, word_d, &table, &x);
+        word_a = result[0];
+        word_b = result[1];
+        word_c = result[2];
+        word_d = result[3];
+
+        // at end of loop iteration, add original word
+        // to the current word value
+        word_a = word_a.wrapping_add(word_aa);
+        word_b = word_b.wrapping_add(word_bb);
+        word_c = word_c.wrapping_add(word_cc);
+        word_d = word_d.wrapping_add(word_dd);
+    }
+
+    // format and return the final result, which
+    // is a 128-bit digest string.
+    let message_digest = format!(
+        "{:08x}{:08x}{:08x}{:08x}",
+        word_a.swap_bytes(),
+        word_b.swap_bytes(),
+        word_c.swap_bytes(),
+        word_d.swap_bytes()
+    );
+    message_digest
+}
+
+/*
+* BIT PADDING STEP
+* 1. Append a 1 bit to the end of original message.
+* 2. Until the bit length of the data is 64 bits
+*    short of being a multiple of 512, append 0's
+*    to the data.
+* 3. With the last 64 bits, append the length in 64 bits
+*    (in lower-order bits first).
+*/
+fn bit_padding(input: &str) -> Vec<u8> {
+    let mut input_vector: Vec<u8> = convert_str_to_vec(input);
+    let bit_length: u64 = (input.len() as u64) * 8u64; // todo - add support for > 2^64 bit size
+
+    // 128_u8 is the equivalent of padding 1 as an unsigned 8-bit integer
+    // with lower-order bits first
+    input_vector.push(128_u8);
+    //check if bit length % 512 is 448 (64 less than 512)
+    while (input_vector.len() * 8) % 512 != 448 {
+        input_vector.push(0_u8); // push in another 8-bit 0 padded value until the correct
+                                 // result is reached;
+    }
+
+    let length_bits_as_u8_array = split_u64_to_u8_array(bit_length);
+    input_vector.extend(length_bits_as_u8_array);
+
+    input_vector
+}
+
+fn split_u64_to_u8_array(s: u64) -> [u8; 8] {
+    [
+        s as u8,
+        (s >> 8) as u8,
+        (s >> 16) as u8,
+        (s >> 24) as u8,
+        (s >> 32) as u8,
+        (s >> 40) as u8,
+        (s >> 48) as u8,
+        (s >> 56) as u8,
+    ]
+}
+
+fn construct_value_table() -> Vec<u32> {
+    let mut t: Vec<u32> = Vec::new();
+    t.push(0x00000000);
+    for i in 1..=64 {
+        t.push(table_construction_function(i));
+    }
+    t
+}
+
+// this should only work with utf-8 encoding and not full unicode support
+// due to multi-byte unicode chars
+fn convert_str_to_vec(input: &str) -> Vec<u8> {
+    let mut byte_vec: Vec<u8> = Vec::new();
+    byte_vec.extend(input.as_bytes());
+    byte_vec
+}
+
+/**
+* A Basic Overview of this MD5 Implementation:
+* 1. Take in a command line string and convert into
+*    a vector of unsigned 8 bit ints (Vec<u8>)
+* 2. Pad the message with a single 1, followed by n 0's,
+*    such that the message length in bits % 512 is equal to 448
+* 3. Pad the last 64 bits with a little-endian representation
+*    of the original message length.
+* 4. Convert our vector of unsigned 8-bit integers into
+*    blocks of 32 bit unsigned ints (u32).
+* 5. Using the 4 auxiliary functions described in rfc 1321,
+*    begin a series of 64 bitwise operations on each 512 bit
+*    block of our message.
+* 6. Once we are done, combine our 4 32 bit registers used to
+*    during our bitwise operations to retrieve our message digest.
+*    (This is a simplification, but describes the core functionality)
+*/
+pub fn md5(input: &str) -> String {
+    let input_vec = bit_padding(input);
+    compute_md5_digest(input_vec)
+}
+#[test]
+fn a_correct_hash() {
+    assert_eq!("0cc175b9c0f1b6a831c399e269772661", md5("a"));
+}
+
+#[test]
+fn empty_string_correct_hash() {
+    assert_eq!("d41d8cd98f00b204e9800998ecf8427e", md5(""));
+}
+
+#[test]
+fn abc_correct_hash() {
+    assert_eq!("900150983cd24fb0d6963f7d28e17f72", md5("abc"));
+}
+
+#[test]
+fn message_digest_correct_hash() {
+    assert_eq!("f96b697d7cb7938d525a2f31aaf161d0", md5("message digest"));
+}
+
+#[test]
+fn lowercase_alphabet_correct_hash() {
+    assert_eq!(
+        "c3fcd3d76192e4007dfb496cca67e13b",
+        md5("abcdefghijklmnopqrstuvwxyz")
+    )
+}
+
+#[test]
+fn all_alphanumeric_correct_hash() {
+    let alpha_num_str =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+    assert_eq!("d174ab98d277d9f5a5611c2c9f419d9f", md5(alpha_num_str));
+}
+
+#[test]
+fn repeated_numbers_correct_hash() {
+    let repeated_number_str =
+        "12345678901234567890123456789012345678901234567890123456789012345678901234567890";
+
+    assert_eq!("57edf4a22be3c955ac49da2e2107b67a", md5(repeated_number_str));
+}

soulseek-rs-lib/src/utils/mod.rs

@@ -0,0 +1,8 @@
+#[macro_use]
+pub mod logger;
+pub mod md5;
+pub mod thread_pool;
+pub mod zlib;
+
+// Re-export commonly used items
+pub use md5::md5;

soulseek-rs-lib/src/utils/thread_pool.rs

@@ -0,0 +1,132 @@
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{mpsc, Arc, Mutex};
+use std::thread;
+
+type Job = Box<dyn FnOnce() + Send + 'static>;
+
+enum Message {
+    NewJob(Job),
+    Terminate,
+}
+
+pub struct ThreadPool {
+    workers: Vec<Worker>,
+    sender: Option<mpsc::Sender<Message>>,
+    active_threads: Arc<AtomicUsize>,
+}
+
+impl ThreadPool {
+    pub fn new(size: usize) -> ThreadPool {
+        assert!(size > 0);
+
+        let (sender, receiver) = mpsc::channel();
+        let receiver = Arc::new(Mutex::new(receiver));
+        let active_threads = Arc::new(AtomicUsize::new(0));
+        let mut workers = Vec::with_capacity(size);
+
+        for id in 0..size {
+            workers.push(Worker::new(
+                id,
+                Arc::clone(&receiver),
+                Arc::clone(&active_threads),
+                size,
+            ));
+        }
+
+        ThreadPool {
+            workers,
+            sender: Some(sender),
+            active_threads,
+        }
+    }
+
+    pub fn execute<F>(&self, f: F)
+    where
+        F: FnOnce() + Send + 'static,
+    {
+        let job = Box::new(f);
+        if let Some(ref sender) = self.sender {
+            sender.send(Message::NewJob(job)).unwrap();
+        }
+    }
+
+    pub fn thread_count(&self) -> usize {
+        self.workers.len()
+    }
+
+    pub fn active_thread_count(&self) -> usize {
+        self.active_threads.load(Ordering::SeqCst)
+    }
+}
+
+impl Drop for ThreadPool {
+    fn drop(&mut self) {
+        // Send termination message to all workers
+        if let Some(sender) = self.sender.take() {
+            for _ in &self.workers {
+                sender.send(Message::Terminate).unwrap();
+            }
+        }
+
+        // Wait for all workers to finish
+        for worker in &mut self.workers {
+            if let Some(thread) = worker.thread.take() {
+                thread.join().unwrap();
+            }
+        }
+    }
+}
+
+struct Worker {
+    _id: usize,
+    thread: Option<thread::JoinHandle<()>>,
+}
+
+impl Worker {
+    fn new(
+        id: usize,
+        receiver: Arc<Mutex<mpsc::Receiver<Message>>>,
+        _active_threads: Arc<AtomicUsize>,
+        _total_threads: usize,
+    ) -> Worker {
+        let thread = thread::spawn(move || loop {
+            let message = receiver.lock().unwrap().recv();
+            match message {
+                Ok(Message::NewJob(job)) => {
+                    // let active =
+                    //     active_threads.fetch_add(1, Ordering::SeqCst) + 1;
+                    // trace!(
+                    //     "Thread {} started job (active: {}/{})",
+                    //     id,
+                    //     active,
+                    //     total_threads
+                    // );
+
+                    job();
+
+                    // let active =
+                    // active_threads.fetch_sub(1, Ordering::SeqCst) - 1;
+                    // trace!(
+                    //     "Thread {} finished job (active: {}/{})",
+                    //     id,
+                    //     active,
+                    //     total_threads
+                    // );
+                }
+                Ok(Message::Terminate) => {
+                    // Received termination signal
+                    break;
+                }
+                Err(_) => {
+                    // Channel disconnected
+                    break;
+                }
+            }
+        });
+
+        Worker {
+            _id: id,
+            thread: Some(thread),
+        }
+    }
+}

soulseek-rs-lib/src/utils/zlib.rs

@@ -0,0 +1,465 @@
+//https://www.rfc-editor.org/rfc/rfc1950
+
+struct BitReader {
+    mem: Vec<u8>,
+    pos: usize,
+    b: u8,
+    numbits: i32,
+}
+
+impl BitReader {
+    fn new(mem: Vec<u8>) -> Self {
+        Self {
+            mem,
+            pos: 0,
+            b: 0,
+            numbits: 0,
+        }
+    }
+
+    fn read_byte(&mut self) -> std::result::Result<u8, String> {
+        self.numbits = 0; // discard unread bits
+        if self.pos >= self.mem.len() {
+            return Err("End of data".to_string());
+        }
+        let b = self.mem[self.pos];
+        self.pos += 1;
+        Ok(b)
+    }
+
+    fn read_bit(&mut self) -> std::result::Result<u8, String> {
+        if self.numbits <= 0 {
+            self.b = self.read_byte()?;
+            self.numbits = 8;
+        }
+        self.numbits -= 1;
+        // shift bit out of byte
+        let bit = self.b & 1;
+        self.b >>= 1;
+        Ok(bit)
+    }
+
+    fn read_bits(&mut self, n: usize) -> std::result::Result<u32, String> {
+        let mut o = 0u32;
+        for i in 0..n {
+            o |= (self.read_bit()? as u32) << i;
+        }
+        Ok(o)
+    }
+
+    fn read_bytes(&mut self, n: usize) -> std::result::Result<u32, String> {
+        // read bytes as an integer in little-endian
+        let mut o = 0u32;
+        for i in 0..n {
+            o |= (self.read_byte()? as u32) << (8 * i);
+        }
+        Ok(o)
+    }
+}
+
+use crate::error::{Result, SoulseekRs};
+
+pub fn deflate(input: &[u8]) -> Result<Vec<u8>> {
+    let mut r = BitReader::new(input.to_vec());
+    let cmf = r.read_byte()?;
+    let cm = cmf & 15; // Compression method
+    if cm != 8 {
+        // only CM=8 is supported
+        return Err(SoulseekRs::CompressionError("invalid CM".to_string()));
+    }
+    let cinfo = (cmf >> 4) & 15; // Compression info
+    if cinfo > 7 {
+        return Err(SoulseekRs::CompressionError("invalid CINFO".to_string()));
+    }
+    let flg = r.read_byte()?;
+    if !((cmf as u32) * 256 + (flg as u32)).is_multiple_of(31) {
+        return Err(SoulseekRs::CompressionError(
+            "CMF+FLG checksum failed".to_string(),
+        ));
+    }
+    let fdict = (flg >> 5) & 1; // preset dictionary?
+    if fdict != 0 {
+        return Err(SoulseekRs::CompressionError(
+            "preset dictionary not supported".to_string(),
+        ));
+    }
+    let out = inflate(&mut r).map_err(SoulseekRs::CompressionError)?; // decompress DEFLATE data
+    let _adler32 = r.read_bytes(4)?; // Adler-32 checksum (for this exercise, we ignore it)
+    Ok(out)
+}
+
+fn inflate(r: &mut BitReader) -> std::result::Result<Vec<u8>, String> {
+    let mut bfinal = 0;
+    let mut out = Vec::new();
+    while bfinal == 0 {
+        bfinal = r.read_bit()?;
+        let btype = r.read_bits(2)?;
+        match btype {
+            0 => inflate_block_no_compression(r, &mut out)?,
+            1 => inflate_block_fixed(r, &mut out)?,
+            2 => inflate_block_dynamic(r, &mut out)?,
+            _ => return Err("invalid BTYPE".to_string()),
+        }
+    }
+    Ok(out)
+}
+
+fn inflate_block_no_compression(
+    r: &mut BitReader,
+    o: &mut Vec<u8>,
+) -> std::result::Result<(), String> {
+    let len = r.read_bytes(2)?;
+    let _nlen = r.read_bytes(2)?;
+    for _ in 0..len {
+        o.push(r.read_byte()?);
+    }
+    Ok(())
+}
+
+#[derive(Clone)]
+struct Node {
+    symbol: Option<u32>,
+    left: Option<Box<Node>>,
+    right: Option<Box<Node>>,
+}
+
+impl Node {
+    fn new() -> Self {
+        Self {
+            symbol: None,
+            left: None,
+            right: None,
+        }
+    }
+}
+
+struct HuffmanTree {
+    root: Node,
+}
+
+impl HuffmanTree {
+    fn new() -> Self {
+        Self { root: Node::new() }
+    }
+
+    fn insert(&mut self, codeword: u32, n: usize, symbol: u32) {
+        // Insert an entry into the tree mapping `codeword` of len `n` to `symbol`
+        let mut node = &mut self.root;
+        for i in (0..n).rev() {
+            let b = (codeword >> i) & 1;
+            if b != 0 {
+                if node.right.is_none() {
+                    node.right = Some(Box::new(Node::new()));
+                }
+                node = node.right.as_mut().unwrap();
+            } else {
+                if node.left.is_none() {
+                    node.left = Some(Box::new(Node::new()));
+                }
+                node = node.left.as_mut().unwrap();
+            }
+        }
+        node.symbol = Some(symbol);
+    }
+}
+
+fn decode_symbol(
+    r: &mut BitReader,
+    t: &HuffmanTree,
+) -> std::result::Result<u32, String> {
+    let mut node = &t.root;
+    while node.left.is_some() || node.right.is_some() {
+        let b = r.read_bit()?;
+        node = if b != 0 {
+            node.right.as_ref().unwrap()
+        } else {
+            node.left.as_ref().unwrap()
+        };
+    }
+    node.symbol.ok_or("No symbol found".to_string())
+}
+
+const LENGTH_EXTRA_BITS: [usize; 29] = [
+    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5,
+    5, 5, 5, 0,
+];
+const LENGTH_BASE: [u32; 29] = [
+    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
+    67, 83, 99, 115, 131, 163, 195, 227, 258,
+];
+const DISTANCE_EXTRA_BITS: [usize; 30] = [
+    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10,
+    11, 11, 12, 12, 13, 13,
+];
+const DISTANCE_BASE: [u32; 30] = [
+    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513,
+    769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577,
+];
+
+fn inflate_block_data(
+    r: &mut BitReader,
+    literal_length_tree: &HuffmanTree,
+    distance_tree: &HuffmanTree,
+    out: &mut Vec<u8>,
+) -> std::result::Result<(), String> {
+    loop {
+        let sym = decode_symbol(r, literal_length_tree)?;
+        if sym <= 255 {
+            // Literal byte
+            out.push(sym as u8);
+        } else if sym == 256 {
+            // End of block
+            return Ok(());
+        } else {
+            // <length, backward distance> pair
+            let sym_idx = (sym - 257) as usize;
+            if sym_idx >= LENGTH_EXTRA_BITS.len() {
+                return Err("Invalid length symbol".to_string());
+            }
+            let length =
+                r.read_bits(LENGTH_EXTRA_BITS[sym_idx])? + LENGTH_BASE[sym_idx];
+            let dist_sym = decode_symbol(r, distance_tree)?;
+            if dist_sym as usize >= DISTANCE_EXTRA_BITS.len() {
+                return Err("Invalid distance symbol".to_string());
+            }
+            let dist = r.read_bits(DISTANCE_EXTRA_BITS[dist_sym as usize])?
+                + DISTANCE_BASE[dist_sym as usize];
+            if dist as usize > out.len() {
+                return Err("Distance too large".to_string());
+            }
+            for _ in 0..length {
+                let idx = out.len() - dist as usize;
+                let byte = out[idx];
+                out.push(byte);
+            }
+        }
+    }
+}
+
+fn bl_list_to_tree(bl: &[usize], alphabet: &[u32]) -> HuffmanTree {
+    let max_bits = *bl.iter().max().unwrap_or(&0);
+    let mut bl_count = vec![0; max_bits + 1];
+    for &bitlen in bl {
+        if bitlen != 0 {
+            bl_count[bitlen] += 1;
+        }
+    }
+
+    let mut next_code = vec![0; max_bits + 1];
+    for bits in 2..=max_bits {
+        next_code[bits] = (next_code[bits - 1] + bl_count[bits - 1]) << 1;
+    }
+
+    let mut t = HuffmanTree::new();
+    for (i, &bitlen) in bl.iter().enumerate() {
+        if bitlen != 0 && i < alphabet.len() {
+            t.insert(next_code[bitlen], bitlen, alphabet[i]);
+            next_code[bitlen] += 1;
+        }
+    }
+    t
+}
+
+const CODE_LENGTH_CODES_ORDER: [usize; 19] = [
+    16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15,
+];
+
+fn decode_trees(
+    r: &mut BitReader,
+) -> std::result::Result<(HuffmanTree, HuffmanTree), String> {
+    // The number of literal/length codes
+    let hlit = r.read_bits(5)? + 257;
+
+    // The number of distance codes
+    let hdist = r.read_bits(5)? + 1;
+
+    // The number of code length codes
+    let hclen = r.read_bits(4)? + 4;
+
+    // Read code lengths for the code length alphabet
+    let mut code_length_tree_bl = vec![0; 19];
+    for i in 0..hclen as usize {
+        code_length_tree_bl[CODE_LENGTH_CODES_ORDER[i]] =
+            r.read_bits(3)? as usize;
+    }
+
+    // Construct code length tree
+    let code_length_alphabet: Vec<u32> = (0..19).collect();
+    let code_length_tree =
+        bl_list_to_tree(&code_length_tree_bl, &code_length_alphabet);
+
+    // Read literal/length + distance code length list
+    let mut bl = Vec::new();
+    while bl.len() < (hlit + hdist) as usize {
+        let sym = decode_symbol(r, &code_length_tree)?;
+        if sym <= 15 {
+            // literal value
+            bl.push(sym as usize);
+        } else if sym == 16 {
+            // copy the previous code length 3..6 times.
+            // the next 2 bits indicate repeat length ( 0 = 3, ..., 3 = 6 )
+            if bl.is_empty() {
+                return Err("No previous code length".to_string());
+            }
+            let prev_code_length = bl[bl.len() - 1];
+            let repeat_length = r.read_bits(2)? + 3;
+            for _ in 0..repeat_length {
+                bl.push(prev_code_length);
+            }
+        } else if sym == 17 {
+            // repeat code length 0 for 3..10 times. (3 bits of length)
+            let repeat_length = r.read_bits(3)? + 3;
+            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;
+            bl.resize(bl.len() + repeat_length as usize, 0);
+        } else {
+            return Err("Invalid symbol".to_string());
+        }
+    }
+
+    // Construct trees
+    let literal_length_alphabet: Vec<u32> = (0..286).collect();
+    let literal_length_tree =
+        bl_list_to_tree(&bl[..hlit as usize], &literal_length_alphabet);
+
+    let distance_alphabet: Vec<u32> = (0..30).collect();
+    let distance_tree =
+        bl_list_to_tree(&bl[hlit as usize..], &distance_alphabet);
+
+    Ok((literal_length_tree, distance_tree))
+}
+
+fn inflate_block_dynamic(
+    r: &mut BitReader,
+    o: &mut Vec<u8>,
+) -> std::result::Result<(), String> {
+    let (literal_length_tree, distance_tree) = decode_trees(r)?;
+    inflate_block_data(r, &literal_length_tree, &distance_tree, o)
+}
+
+fn inflate_block_fixed(
+    r: &mut BitReader,
+    o: &mut Vec<u8>,
+) -> std::result::Result<(), String> {
+    let mut bl = Vec::new();
+    bl.extend(vec![8; 144]); // 0-143: 8 bits
+    bl.extend(vec![9; 112]); // 144-255: 9 bits
+    bl.extend(vec![7; 24]); // 256-279: 7 bits
+    bl.extend(vec![8; 8]); // 280-287: 8 bits
+
+    let literal_length_alphabet: Vec<u32> = (0..286).collect();
+    let literal_length_tree = bl_list_to_tree(&bl, &literal_length_alphabet);
+
+    let bl_dist = vec![5; 30];
+    let distance_alphabet: Vec<u32> = (0..30).collect();
+    let distance_tree = bl_list_to_tree(&bl_dist, &distance_alphabet);
+
+    inflate_block_data(r, &literal_length_tree, &distance_tree, o)
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    fn test_bitreader_read_bits() {
+        let data = vec![0b11010010, 0b10110101];
+        let mut reader = BitReader::new(data);
+
+        assert_eq!(reader.read_bits(3).unwrap(), 0b010); // First 3 bits: 010
+        assert_eq!(reader.read_bits(5).unwrap(), 0b11010); // Next 5 bits: 11010
+    }
+
+    #[test]
+    fn test_bitreader_read_bytes() {
+        let data = vec![0x12, 0x34, 0x56, 0x78];
+        let mut reader = BitReader::new(data);
+
+        assert_eq!(reader.read_bytes(2).unwrap(), 0x3412); // Little-endian: 0x3412
+        assert_eq!(reader.read_bytes(2).unwrap(), 0x7856); // Little-endian: 0x7856
+    }
+
+    #[test]
+    fn test_extract_header_success() {
+        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());
+    }
+
+    #[test]
+    fn test_extract_header_fail_to_short() {
+        let data = vec![120]; // Too short
+        let mut reader = BitReader::new(data);
+        let result = reader.read_byte();
+        assert!(result.is_ok());
+        let result = reader.read_byte();
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_deflate() {
+        // Test data from the original test - this should work with our new implementation
+        let data = vec![
+            120, 156, 203, 72, 205, 201, 201, 87, 8, 207, 47, 202, 73, 1, 0,
+            24, 11, 4, 93,
+        ];
+        let result = deflate(&data);
+        assert!(result.is_ok());
+        let decompressed = result.unwrap();
+        assert_eq!(decompressed, b"hello World");
+    }
+
+    #[test]
+    fn test_deflate2() {
+        let data = vec![
+            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,
+        ];
+        let expect = vec![
+            7, 0, 0, 0, 100, 111, 100, 105, 103, 97, 110, 109, 43, 148, 52, 2,
+            0, 0, 0, 1, 79, 0, 0, 0, 64, 64, 114, 108, 100, 113, 110, 92, 99,
+            111, 109, 112, 108, 101, 116, 101, 92, 67, 97, 110, 99, 105, 111,
+            110, 101, 115, 92, 84, 114, 117, 115, 115, 101, 108, 45, 49, 57,
+            55, 57, 45, 71, 111, 110, 101, 32, 70, 111, 114, 32, 84, 104, 101,
+            32, 87, 101, 101, 107, 101, 110, 100, 45, 49, 54, 98, 105, 116, 45,
+            52, 52, 44, 49, 75, 104, 122, 46, 102, 108, 97, 99, 132, 250, 207,
+            2, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 112, 1, 0, 0, 4,
+            0, 0, 0, 68, 172, 0, 0, 5, 0, 0, 0, 16, 0, 0, 0, 1, 110, 0, 0, 0,
+            64, 64, 114, 108, 100, 113, 110, 92, 99, 111, 109, 112, 108, 101,
+            116, 101, 92, 83, 105, 110, 103, 108, 101, 115, 32, 87, 101, 101,
+            107, 32, 51, 53, 32, 50, 48, 50, 52, 92, 70, 101, 114, 114, 101,
+            99, 107, 32, 68, 97, 119, 110, 44, 32, 77, 97, 118, 101, 114, 105,
+            99, 107, 32, 83, 97, 98, 114, 101, 32, 38, 32, 78, 101, 119, 32,
+            77, 97, 99, 104, 105, 110, 101, 32, 45, 32, 70, 111, 114, 32, 84,
+            104, 101, 32, 87, 101, 101, 107, 101, 110, 100, 32, 40, 50, 48, 50,
+            52, 41, 46, 102, 108, 97, 99, 169, 15, 42, 1, 0, 0, 0, 0, 0, 0, 0,
+            0, 3, 0, 0, 0, 1, 0, 0, 0, 169, 0, 0, 0, 4, 0, 0, 0, 68, 172, 0, 0,
+            5, 0, 0, 0, 16, 0, 0, 0, 0, 228, 149, 1, 0, 46, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0,
+        ]
+        .to_vec();
+        let result = deflate(&data);
+
+        assert!(result.is_ok());
+        let decompressed = result.unwrap();
+
+        assert_eq!(decompressed, expect);
+    }
+}