Cmdline chat

src/connect.rs

@@ -7,9 +7,8 @@ use varint_rs::{VarintReader, VarintWriter};
 
 use crate::{
     Connected, Server, Status,
-    error::ChatError,
+    error::{ChatError, Result},
-    error::Result,
+    readers::{read_packet, read_plugin_msg, read_string, try_read_plugin_msg},
-    readers::{read_packet, read_plugin_msg, read_string},
     status::ServerType,
     writers::{write_packet, write_plugin_msg, write_string},
 };
@@ -200,27 +199,19 @@ impl Server<Status> {
                     Ok(())
                 })?;
 
-                // Serrver FluidIdmap
+                // Server Mod registried
-                read_plugin_msg(&mut stream, "FORGE", |packet| {
+                while try_read_plugin_msg(&mut stream, |channel, packet| {
-                    let discriminant = VarintReader::read(packet)?;
+                    dbg!(channel);
-                    assert_eq!(discriminant, 2);
+                    if channel != "FML|HS" {
-                    Ok(())
+                        Ok(true)
-                })?;
+                    } else {
-
+                        let discriminant = VarintReader::read(packet)?;
-                // HandshakeAck pendingcomplete
+                        assert_eq!(discriminant, 255);
-                write_plugin_msg(&mut stream, "FML|HS", |body| {
+                        let phrase = VarintReader::read(packet)?;
-                    body.write_all(&[0xFF, 0x04])?;
+                        assert_eq!(phrase, 3);
-                    Ok(())
+                        Ok(false)
-                })?;
+                    }
-
+                })? {}
-                // Server HandshakeAck complete
-                read_plugin_msg(&mut stream, "FML|HS", |packet| {
-                    let discriminant = VarintReader::read(packet)?;
-                    assert_eq!(discriminant, 255);
-                    let phrase = VarintReader::read(packet)?;
-                    assert_eq!(phrase, 3);
-                    Ok(())
-                })?;
 
                 // HandshakeAck complete
                 write_plugin_msg(&mut stream, "FML|HS", |body| {

src/error.rs

@@ -1,11 +1,15 @@
 use serde_json::Value;
-use std::{io, result::Result as StdResult, string::FromUtf8Error};
+use std::{
+    env::VarError, io, num::ParseIntError, result::Result as StdResult, string::FromUtf8Error,
+};
 
 #[derive(Debug)]
 pub enum ChatError {
     IoError(io::Error),
     FromUtf8Error(FromUtf8Error),
+    ParseIntError(ParseIntError),
     JsonError(JsonError),
+    VarError(VarError),
 }
 
 #[derive(Debug)]
@@ -35,6 +39,18 @@ impl From<JsonError> for ChatError {
     }
 }
 
+impl From<VarError> for ChatError {
+    fn from(value: VarError) -> Self {
+        Self::VarError(value)
+    }
+}
+
+impl From<ParseIntError> for ChatError {
+    fn from(value: ParseIntError) -> Self {
+        Self::ParseIntError(value)
+    }
+}
+
 impl From<serde_json::Error> for JsonError {
     fn from(value: serde_json::Error) -> Self {
         Self::SerdeError(value)

src/main.rs

@@ -57,14 +57,7 @@ impl Server<Disconnected> {
 }
 
 fn main() -> Result<()> {
-    let server = Server::new("localhost".to_string(), 25565)?;
+    let addr = std::env::var("ADDR")?;
-    dbg!(&server);
+    let port: u16 = std::env::var("PORT")?.parse()?;
-
+    Server::new(addr, port)?.status()?.connect()?.run()
-    let server = server.status()?;
-    dbg!(&server);
-
-    let server = server.connect()?;
-    dbg!(&server);
-
-    server.run()
 }

src/readers.rs

@@ -45,3 +45,23 @@ pub fn read_plugin_msg<T, F: Fn(&mut &[u8]) -> Result<T>>(
         read_body(&mut packet)
     })
 }
+
+pub fn try_read_plugin_msg<T, F: Fn(&str, &mut &[u8]) -> Result<T>>(
+    stream: &mut TcpStream,
+    read_body: F,
+) -> Result<T> {
+    read_packet(stream, |packet| {
+        let id = packet.read_usize_varint()?;
+        assert!(id == 63);
+
+        let channel_read = read_string(packet)?;
+        let mut buf = [0u8; 2];
+        packet.read_exact(&mut buf)?;
+        let len = u16::from_be_bytes(buf);
+        let mut buf = vec![0u8; len as usize];
+        packet.read_exact(&mut buf)?;
+
+        let mut packet = &buf[..];
+        read_body(&channel_read, &mut packet)
+    })
+}

src/run.rs

@@ -1,15 +1,17 @@
 use std::{
-    io::{Read as _, Write as _},
+    io::{Read as _, Write as _, stdin, stdout},
-    net::TcpStream,
+    net::{Shutdown, TcpStream},
 };
 
-use varint_rs::{VarintReader, VarintWriter as _};
+use serde_json::json;
+use varint_rs::{VarintReader, VarintWriter};
 
 use crate::{
     Connected, Server,
     error::Result,
     readers::{read_packet, read_string},
     text::Message,
+    writers::{write_packet, write_string},
 };
 
 pub enum Packet {
@@ -24,22 +26,36 @@ impl Server<Connected> {
         let Self {
             mut stream,
             lang,
-            state: Connected { .. },
+            state: Connected { username, .. },
             ..
         } = self;
-        loop {
+        let mut recv_stream = stream.try_clone().unwrap();
-            let packet = read_packet(&mut stream, parse_packet)?;
+        std::thread::spawn(move || -> Result<()> {
-            match packet {
+            loop {
-                Packet::KeepAlive(id) => handle_keepalive(&mut stream, id)?,
+                let packet = read_packet(&mut recv_stream, parse_packet)?;
-                Packet::Chat(m) => {
+                match packet {
-                    for m in m {
+                    Packet::KeepAlive(id) => handle_keepalive(&mut recv_stream, id)?,
-                        println!("{}", m.format(&lang))
+                    Packet::Chat(m) => {
+                        for m in m {
+                            println!("{}", m.format(&lang))
+                        }
                     }
+                    Packet::Disconnect => break,
+                    Packet::Other(_, _) => {}
                 }
-                Packet::Disconnect => break,
-                Packet::Other(_, _) => {}
             }
+            Ok(())
+        });
+        for line in stdin().lines() {
+            print!("\x1b[1F\x1b[0K");
+            let line = &line?;
+            write_packet(&mut stream, move |buf| {
+                buf.write_usize_varint(0x01)?;
+                write_string(buf, line)?;
+                Ok(())
+            })?;
         }
+        stream.shutdown(Shutdown::Both)?;
         Ok(())
     }
 }