garentyler/composition
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rust fmt

Browse Source
This commit is contained in:
ElementG9 2020-05-26 16:24:49 -06:00
parent ef86b059c5
commit 7be571f198
2 changed files with 80 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
src/mctypes.rs
View File

@ -64,13 +64,11 @@ impl MCBoolean {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCByte {
pub value: i8 // -128 to 127
pub value: i8, // -128 to 127
}
impl From<i8> for MCByte {
fn from(v: i8) -> MCByte {
MCByte {
value: v
}
MCByte { value: v }
}
}
#[allow(dead_code)]
@ -80,7 +78,7 @@ impl MCByte {
}
pub fn from_bytes(v: Vec<u8>) -> MCByte {
MCByte {
value: get_bytes(v, 1)[0] as i8
value: get_bytes(v, 1)[0] as i8,
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -90,13 +88,11 @@ impl MCByte {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCUnsignedByte {
pub value: u8 // 0 to 255
pub value: u8, // 0 to 255
}
impl From<u8> for MCUnsignedByte {
fn from(v: u8) -> MCUnsignedByte {
MCUnsignedByte {
value: v
}
MCUnsignedByte { value: v }
}
}
#[allow(dead_code)]
@ -106,7 +102,7 @@ impl MCUnsignedByte {
}
pub fn from_bytes(v: Vec<u8>) -> MCUnsignedByte {
MCUnsignedByte {
value: get_bytes(v, 1)[0]
value: get_bytes(v, 1)[0],
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -116,13 +112,11 @@ impl MCUnsignedByte {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCShort {
pub value: i16 // -32768 to 32767
pub value: i16, // -32768 to 32767
}
impl From<i16> for MCShort {
fn from(v: i16) -> MCShort {
MCShort {
value: v
}
MCShort { value: v }
}
}
#[allow(dead_code)]
@ -137,7 +131,7 @@ impl MCShort {
let mut a = [0u8; 2];
a.copy_from_slice(&get_bytes(v, 2));
MCShort {
value: i16::from_be_bytes(a)
value: i16::from_be_bytes(a),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -147,13 +141,11 @@ impl MCShort {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCUnsignedShort {
pub value: u16 // 0 to 65535
pub value: u16, // 0 to 65535
}
impl From<u16> for MCUnsignedShort {
fn from(v: u16) -> MCUnsignedShort {
MCUnsignedShort {
value: v
}
MCUnsignedShort { value: v }
}
}
#[allow(dead_code)]
@ -168,7 +160,7 @@ impl MCUnsignedShort {
let mut a = [0u8; 2];
a.copy_from_slice(&get_bytes(v, 2));
MCUnsignedShort {
value: u16::from_be_bytes(a)
value: u16::from_be_bytes(a),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -178,13 +170,11 @@ impl MCUnsignedShort {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCInt {
pub value: i32 // -2147483648 to 2147483647
pub value: i32, // -2147483648 to 2147483647
}
impl From<i32> for MCInt {
fn from(v: i32) -> MCInt {
MCInt {
value: v
}
MCInt { value: v }
}
}
#[allow(dead_code)]
@ -200,7 +190,7 @@ impl MCInt {
let mut a = [0u8; 4];
a.copy_from_slice(&get_bytes(v, 4));
MCInt {
value: i32::from_be_bytes(a)
value: i32::from_be_bytes(a),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -210,13 +200,11 @@ impl MCInt {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCLong {
pub value: i64 // -9223372036854775808 to 9223372036854775807
pub value: i64, // -9223372036854775808 to 9223372036854775807
}
impl From<i64> for MCLong {
fn from(v: i64) -> MCLong {
MCLong {
value: v
}
MCLong { value: v }
}
}
#[allow(dead_code)]
@ -232,7 +220,7 @@ impl MCLong {
let mut a = [0u8; 8];
a.copy_from_slice(&get_bytes(v, 8));
MCLong {
value: i64::from_be_bytes(a)
value: i64::from_be_bytes(a),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -242,13 +230,11 @@ impl MCLong {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCFloat {
pub value: f32 // 32-bit floating point number
pub value: f32, // 32-bit floating point number
}
impl From<f32> for MCFloat {
fn from(v: f32) -> MCFloat {
MCFloat {
value: v
}
MCFloat { value: v }
}
}
#[allow(dead_code)]
@ -264,7 +250,7 @@ impl MCFloat {
let mut a = [0u8; 4];
a.copy_from_slice(&get_bytes(v, 4));
MCFloat {
value: f32::from_be_bytes(a)
value: f32::from_be_bytes(a),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -274,13 +260,11 @@ impl MCFloat {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCDouble {
pub value: f64 // 64-bit floating point number
pub value: f64, // 64-bit floating point number
}
impl From<f64> for MCDouble {
fn from(v: f64) -> MCDouble {
MCDouble {
value: v
}
MCDouble { value: v }
}
}
#[allow(dead_code)]
@ -296,7 +280,7 @@ impl MCDouble {
let mut a = [0u8; 8];
a.copy_from_slice(&get_bytes(v, 8));
MCDouble {
value: f64::from_be_bytes(a)
value: f64::from_be_bytes(a),
}
}
pub fn to_bytes(&self) -> Vec<u8> {
@ -306,21 +290,17 @@ impl MCDouble {
#[allow(dead_code)]
#[derive(Debug, Copy, Clone)]
pub struct MCVarInt {
pub value: i32 // Variable length 32-bit integer
pub value: i32, // Variable length 32-bit integer
}
impl From<i32> for MCVarInt {
fn from(v: i32) -> MCVarInt {
MCVarInt {
value: v
}
MCVarInt { value: v }
}
}
#[allow(dead_code)]
impl MCVarInt {
pub fn new(i: i32) -> MCVarInt {
MCVarInt {
value: i
}
MCVarInt { value: i }
}
pub fn from_stream(t: &mut TcpStream) -> std::io::Result<MCVarInt> {
let mut numRead = 0;
@ -337,9 +317,7 @@ impl MCVarInt {
return Err(io_error("MCVarInt is too big"));
}
}
Ok(MCVarInt {
value: result
})
Ok(MCVarInt { value: result })
}
pub fn from_bytes(_: Vec<u8>) -> MCVarInt {
panic!("Cannot construct MCVarInt from raw bytes");
@ -368,7 +346,7 @@ impl std::fmt::Display for MCVarInt {
#[allow(dead_code)]
#[derive(Debug)]
pub struct MCString {
pub value: String
pub value: String,
}
#[allow(dead_code)]
impl MCString {
@ -381,7 +359,7 @@ impl MCString {
let value = String::from_utf8(bytes);
if value.is_ok() {
Ok(MCString {
value: value.unwrap()
value: value.unwrap(),
})
} else {
return Err(io_error("MCString contains invalid utf-8"));
@ -393,7 +371,7 @@ impl MCString {
pub fn to_bytes(&self) -> Vec<u8> {
let mut out = Vec::new();
let length = MCVarInt {
value: self.value.len() as i32
value: self.value.len() as i32,
};
for b in length.to_bytes() {
out.push(b);
@ -407,21 +385,19 @@ impl MCString {
impl From<&str> for MCString {
fn from(s: &str) -> MCString {
MCString {
value: s.to_owned()
value: s.to_owned(),
}
}
}
impl From<String> for MCString {
fn from(s: String) -> MCString {
MCString {
value: s.clone()
}
MCString { value: s.clone() }
}
}
impl Clone for MCString {
fn clone(&self) -> Self {
MCString {
value: self.value.clone()
value: self.value.clone(),
}
}
}

95
src/net.rs
View File

@ -2,16 +2,16 @@ pub static SERVER_LISTENER_ADDRESS: &str = "127.0.0.1:25565";
pub static SOCKET_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(5);
extern crate serde;
extern crate serde_json;
use crate::mctypes::*;
use serde::Serialize;
use serde_json::json;
use std::io::prelude::*;
use std::net::{TcpStream, TcpListener};
use std::net::{TcpListener, TcpStream};
use std::thread;
use crate::mctypes::*;
pub struct MCPacket {
pub id: MCVarInt,
pub data: Vec<u8>
pub data: Vec<u8>,
}
#[allow(dead_code)]
impl MCPacket {
@ -33,10 +33,7 @@ impl MCPacket {
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut bytes = Vec::new();
for b in MCVarInt::new((
self.id.to_bytes().len() +
self.data.len()
) as i32).to_bytes() {
for b in MCVarInt::new((self.id.to_bytes().len() + self.data.len()) as i32).to_bytes() {
bytes.push(b);
}
for b in self.id.to_bytes() {
@ -55,7 +52,7 @@ pub enum GameState {
Status,
Login,
Play,
Closed
Closed,
}
#[allow(dead_code)]
pub struct GameConnection {
@ -71,22 +68,24 @@ pub fn start_listener() -> std::io::Result<()> {
// Spawn a new thread for each connection.
for stream in listener.incoming() {
let stream = stream?;
thread::Builder::new().name(format!("GameConnection {}", stream.peer_addr().unwrap())).spawn(move || -> std::io::Result<()> {
if crate::DEBUG_LOGGING {
println!("Client connected at {}", stream.peer_addr().unwrap());
}
stream
.set_read_timeout(Some(SOCKET_TIMEOUT))
.expect("set_read_timeout call failed");
stream
.set_write_timeout(Some(SOCKET_TIMEOUT))
.expect("set_write_timeout call failed");
handle_client(GameConnection {
stream: stream,
state: GameState::Handshake,
thread::Builder::new()
.name(format!("GameConnection {}", stream.peer_addr().unwrap()))
.spawn(move || -> std::io::Result<()> {
if crate::DEBUG_LOGGING {
println!("Client connected at {}", stream.peer_addr().unwrap());
}
stream
.set_read_timeout(Some(SOCKET_TIMEOUT))
.expect("set_read_timeout call failed");
stream
.set_write_timeout(Some(SOCKET_TIMEOUT))
.expect("set_write_timeout call failed");
handle_client(GameConnection {
stream: stream,
state: GameState::Handshake,
})?;
Ok(())
})?;
Ok(())
})?;
}
Ok(())
}
@ -94,30 +93,29 @@ pub fn handle_client(mut gc: GameConnection) -> std::io::Result<()> {
loop {
let (packet_length, packet_id) = MCPacket::read_header(&mut gc.stream)?;
if crate::DEBUG_LOGGING {
println!("Packet Length: {}, Packet ID: {}", packet_length.value, packet_id.value);
println!(
"Packet Length: {}, Packet ID: {}",
packet_length.value, packet_id.value
);
}
match gc.state {
GameState::Handshake => {
match packet_id.value {
0x00 => {
handshake(&mut gc)?;
},
_ => {
if crate::DEBUG_LOGGING {
println!("Unknown packet id {} in Handshake", packet_id);
}
GameState::Handshake => match packet_id.value {
0x00 => {
handshake(&mut gc)?;
}
_ => {
if crate::DEBUG_LOGGING {
println!("Unknown packet id {} in Handshake", packet_id);
}
}
},
GameState::Login => {
match packet_id.value {
0x00 => {
login(&mut gc)?;
},
_ => {
if crate::DEBUG_LOGGING {
println!("Unknown packet id {} in Login", packet_id);
}
GameState::Login => match packet_id.value {
0x00 => {
login(&mut gc)?;
}
_ => {
if crate::DEBUG_LOGGING {
println!("Unknown packet id {} in Login", packet_id);
}
}
},
@ -146,12 +144,13 @@ pub fn handle_client(mut gc: GameConnection) -> std::io::Result<()> {
}
// No favicon for now.
// "favicon": "data:image/png;base64,<data>"
}).to_string();
})
.to_string();
packet.write(MCVarInt::new(json_response.len() as i32).to_bytes());
packet.write(MCString::from(json_response.clone()).to_bytes());
gc.stream.write(&packet.to_bytes())?;
println!("=== SENT SERVER RESPONSE ===\n{}", json_response);
},
}
_ => {
if crate::DEBUG_LOGGING {
println!("Unknown packet id {} in Status", packet_id);
@ -183,11 +182,9 @@ pub fn handshake(gc: &mut GameConnection) -> std::io::Result<()> {
}
};
if crate::DEBUG_LOGGING {
println!("Handshake: Protocol Version: {}, Server Address: {}:{}, Next State: {:?}",
protocol_version.value,
server_address.value,
server_port.value,
next_state
println!(
"Handshake: Protocol Version: {}, Server Address: {}:{}, Next State: {:?}",
protocol_version.value, server_address.value, server_port.value, next_state
);
}
gc.state = next_state;