diff --git a/src/main.rs b/src/main.rs
index 605474e..dd6ba85 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -29,72 +29,57 @@ fn main() -> std::io::Result<()> {
         std::thread::spawn({
             move || {
                 let mut stream = encryption::handshake(stream.unwrap(), rsa);
+                let mut last_activity = Instant::now();
 
-                println!("{:?}", stream.read());
+                match methods::Session::new(stream.clone(), database) {
+                    Ok((session, res)) => {
+                        stream.send(res);
 
-                stream.send("Daddy OMG!!!");
+                        loop {
+                            match stream.read() {
+                                None => {
+                                    // Client disconnected
+                                    println!("[MOJANG] {} disconnected", session.local_player.name);
+                                    methods::player::logout(&session).unwrap();
+                                    println!("[MOJANG] {} went offline", session.local_player.name);
+                                    break;
+                                }
+                                Some(request_string) => {
+                                    last_activity = Instant::now();
+                                    let (method, params) = parser::parse(&request_string).unwrap();
+                                    let response = session.handle_request(&method, &params);
 
-                println!("OMG sent")
-                // let mut reader = BufReader::new(stream.try_clone().unwrap());
-                // let mut last_activity = Instant::now();
+                                    stream.send(match response {
+                                        Ok(response) => response.to_string(),
+                                        Err(e) => format!("!{e}"),
+                                    });
+                                }
+                                // Err(e) => {
+                                //     println!(
+                                //         "[ERROR] Read error for {}: {}",
+                                //         session.local_player.name, e
+                                //     );
+                                //     break;
+                                // }
+                            };
 
-                // match methods::Session::new(&mut reader, database) {
-                //     Ok((session, res)) => {
-                //         writeln!(stream, "{res}").unwrap();
-                //         stream.flush().unwrap();
-
-                //         loop {
-                //             let mut request_string = String::new();
-                //             match reader.read_line(&mut request_string) {
-                //                 Ok(0) => {
-                //                     // Client disconnected
-                //                     println!("[MOJANG] {} disconnected", session.local_player.name);
-                //                     methods::player::logout(&session).unwrap();
-                //                     println!("[MOJANG] {} went offline", session.local_player.name);
-                //                     break;
-                //                 }
-                //                 Ok(_) => {
-                //                     last_activity = Instant::now();
-                //                     let (method, params) = parser::parse(&request_string).unwrap();
-                //                     let response = session.handle_request(&method, &params);
-                //                     writeln!(
-                //                         stream,
-                //                         "{}",
-                //                         match response {
-                //                             Ok(response) => response.to_string(),
-                //                             Err(e) => format!("!{e}"),
-                //                         }
-                //                     )
-                //                     .unwrap();
-                //                 }
-                //                 Err(e) => {
-                //                     println!(
-                //                         "[ERROR] Read error for {}: {}",
-                //                         session.local_player.name, e
-                //                     );
-                //                     break;
-                //                 }
-                //             };
-
-                //             // Check for inactivity
-                //             if last_activity.elapsed() > Duration::from_secs(60) {
-                //                 println!(
-                //                     "[MOJANG] {} inactive for too long",
-                //                     session.local_player.name
-                //                 );
-                //                 methods::player::logout(&session).unwrap();
-                //                 println!("[MOJANG] {} went offline", session.local_player.name);
-                //                 break;
-                //             }
-                //         }
-                //     }
-                //     Err(e) => {
-                //         stream.write_all(format!("!{e}").as_bytes()).unwrap();
-                //         stream
-                //             .shutdown(std::net::Shutdown::Both)
-                //             .expect("shutdown call failed");
-                //     }
-                // }
+                            // Check for inactivity
+                            if last_activity.elapsed() > Duration::from_secs(60) {
+                                println!(
+                                    "[MOJANG] {} inactive for too long",
+                                    session.local_player.name
+                                );
+                                methods::player::logout(&session).unwrap();
+                                println!("[MOJANG] {} went offline", session.local_player.name);
+                                break;
+                            }
+                        }
+                    }
+                    Err(e) => {
+                        // stream.write_all(format!("!{e}").as_bytes()).unwrap();
+                        stream.close();
+                    }
+                }
             }
         });
     }
diff --git a/src/methods/mod.rs b/src/methods/mod.rs
index d18685e..14d9004 100644
--- a/src/methods/mod.rs
+++ b/src/methods/mod.rs
@@ -12,6 +12,7 @@ use std::{
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    encryption::ETcp,
     parser::ParamMap,
     response::{PlayerResponse, Response, Result},
 };
@@ -30,24 +31,15 @@ pub struct Session {
 
 impl Session {
     pub fn new(
-        reader: &mut BufReader<TcpStream>,
+        mut stream: ETcp,
         database: Arc<crate::database::Database>,
     ) -> Result<(Self, Response)> {
         let (token_send, token_recv) =
             mpsc::channel::<std::result::Result<String, crate::response::Error>>();
 
-        let reader_clone = reader
-            .get_ref()
-            .try_clone()
-            .map_err(|_| crate::response::Error::InvalidHandshake)?;
-        std::thread::spawn(move || {
-            let mut reader = BufReader::new(reader_clone);
-            let mut session_token = String::new();
-            if reader.read_line(&mut session_token).is_ok() {
-                token_send.send(Ok(session_token))
-            } else {
-                token_send.send(Err(crate::response::Error::InvalidHandshake))
-            }
+        std::thread::spawn(move || match stream.read() {
+            Some(session_token) => token_send.send(Ok(session_token)),
+            _ => token_send.send(Err(crate::response::Error::InvalidHandshake)),
         });
 
         match token_recv.recv_timeout(std::time::Duration::from_secs(20)) {