more writing and reading primary types

src/lib.rs

@@ -100,11 +100,44 @@ pub trait DataBufferReader {
             Err(_) => Err(ProtocolError::StringParseError)
         }
     }
-
     fn read_unsigned_short(&mut self) -> Result<u16, ProtocolError> {
-        let bytes = self.read_bytes(2)?;
-        let bytes = [bytes[0], bytes[1]];
-        Ok(u16::from_be_bytes(bytes))
+        match self.read_bytes(2)?.try_into() {
+            Ok(i) => Ok(u16::from_be_bytes(i)),
+            Err(_) => Err(ProtocolError::ReadError),
+        }
+    }
+    fn read_boolean(&mut self) -> Result<bool, ProtocolError> {
+        Ok(self.read_byte()? == 0x01)
+    }
+    fn read_short(&mut self) -> Result<i16, ProtocolError> {
+        match self.read_bytes(2)?.try_into() {
+            Ok(i) => Ok(i16::from_be_bytes(i)),
+            Err(_) => Err(ProtocolError::ReadError),
+        }
+    }
+    fn read_long(&mut self) -> Result<i64, ProtocolError> {
+        match self.read_bytes(8)?.try_into() {
+            Ok(i) => Ok(i64::from_be_bytes(i)),
+            Err(_) => Err(ProtocolError::ReadError),
+        }
+    }
+    fn read_float(&mut self) -> Result<f32, ProtocolError> {
+        match self.read_bytes(4)?.try_into() {
+            Ok(i) => Ok(f32::from_be_bytes(i)),
+            Err(_) => Err(ProtocolError::ReadError),
+        }
+    }
+    fn read_double(&mut self) -> Result<f64, ProtocolError> {
+        match self.read_bytes(8)?.try_into() {
+            Ok(i) => Ok(f64::from_be_bytes(i)),
+            Err(_) => Err(ProtocolError::ReadError),
+        }
+    }
+    fn read_int(&mut self) -> Result<i32, ProtocolError> {
+        match self.read_bytes(4)?.try_into() {
+            Ok(i) => Ok(i32::from_be_bytes(i)),
+            Err(_) => Err(ProtocolError::ReadError),
+        }
     }
 
     fn read_usize_varint(&mut self) -> Result<usize, ProtocolError> { read_varint!(usize, self) }
@@ -127,7 +160,7 @@ pub trait DataBufferWriter {
     fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), ProtocolError>;
     fn write_byte(&mut self, byte: u8) -> Result<(), ProtocolError>;
 
-    fn write_string(&mut self, val: String) -> Result<(), ProtocolError> {
+    fn write_string(&mut self, val: &str) -> Result<(), ProtocolError> {
         let bytes = val.as_bytes();
 
         self.write_usize_varint(bytes.len())?;
@@ -139,6 +172,42 @@ pub trait DataBufferWriter {
             Err(_) => Err(ProtocolError::UnsignedShortError),
         }
     }
+    fn write_boolean(&mut self, val: bool) -> Result<(), ProtocolError> {
+        match self.write_byte(if val { 0x01 } else { 0x00 }) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(ProtocolError::UnsignedShortError),
+        }
+    }
+    fn write_short(&mut self, val: i16) -> Result<(), ProtocolError> {
+        match self.write_bytes(&val.to_be_bytes()) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(ProtocolError::UnsignedShortError),
+        }
+    }
+    fn write_long(&mut self, val: i64) -> Result<(), ProtocolError> {
+        match self.write_bytes(&val.to_be_bytes()) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(ProtocolError::UnsignedShortError),
+        }
+    }
+    fn write_float(&mut self, val: f32) -> Result<(), ProtocolError> {
+        match self.write_bytes(&val.to_be_bytes()) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(ProtocolError::UnsignedShortError),
+        }
+    }
+    fn write_double(&mut self, val: f64) -> Result<(), ProtocolError> {
+        match self.write_bytes(&val.to_be_bytes()) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(ProtocolError::UnsignedShortError),
+        }
+    }
+    fn write_int(&mut self, val: i32) -> Result<(), ProtocolError> {
+        match self.write_bytes(&val.to_be_bytes()) {
+            Ok(_) => Ok(()),
+            Err(_) => Err(ProtocolError::UnsignedShortError),
+        }
+    }
 
     fn write_usize_varint(&mut self, val: usize) -> Result<(), ProtocolError> { write_varint!(usize, self, val) }
     fn write_u8_varint(&mut self, val: u8) -> Result<(), ProtocolError> { write_varint!(u8, self, val) }
@@ -275,6 +344,10 @@ impl MinecraftConnection<TcpStream> {
             compress_threashold: 0
         })
     }
+
+    pub fn close(&mut self) {
+        let _ = self.stream.shutdown(std::net::Shutdown::Both);
+    }
 }
 
 impl<T: Read + Write> DataBufferReader for MinecraftConnection<T> {

src/main.rs

@@ -1,42 +1,34 @@
-use rust_mc_proto::{Packet, ProtocolError, MCConnTcp, DataBufferReader, DataBufferWriter};
+use std::{net::TcpListener, sync::Arc, thread};
 
-fn send_handshake(conn: &mut MCConnTcp,
-                protocol_version: u16,
-                server_address: &str,
-                server_port: u16,
-                next_state: u8) -> Result<(), ProtocolError> {
-    let mut packet = Packet::empty(0x00);
+use rust_mc_proto::{DataBufferReader, DataBufferWriter, MCConn, MCConnTcp, MinecraftConnection, Packet, ProtocolError};
 
-    packet.write_u16_varint(protocol_version)?;
-    packet.write_string(server_address.to_string())?;
-    packet.write_unsigned_short(server_port)?;
-    packet.write_u8_varint(next_state)?;
+/*
 
-    conn.write_packet(&packet)?;
+    Example of simple server that sends motd 
+    to client like an vanilla minecraft server
 
-    Ok(())
-}
+*/
 
-fn send_status_request(conn: &mut MCConnTcp) -> Result<(), ProtocolError> {
-    let packet = Packet::empty(0x00);
-    conn.write_packet(&packet)?;
+fn accept_client(mut conn: MCConnTcp) {
+    loop { 
+        let packet = match conn.read_packet() {
+            Ok(p) => p,
+            Err(_) => { break },
+        };
 
-    Ok(())
-}
-
-fn read_status_response(conn: &mut MCConnTcp) -> Result<String, ProtocolError> {
-    let mut packet = conn.read_packet()?;
-
-    packet.read_string()
+        dbg!(packet);
+    }
 }
 
 fn main() {
-    let mut conn = MCConnTcp::connect("localhost:25566").unwrap();
+    let listener = TcpListener::bind("localhost:25565").unwrap();
 
-    send_handshake(&mut conn, 765, "localhost", 25565, 1).unwrap();
-    send_status_request(&mut conn).unwrap();
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
 
-    let motd = read_status_response(&mut conn).unwrap();
 
-    println!("Motd: {}", motd);
+        thread::spawn(move || {
+            accept_client(MinecraftConnection::new(stream));
+        });
+    }
 }