infrarust 1.0.1

A Rust adaptation of the Infrared Minecraft proxy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::io::{self, Read, Write};

use crate::network::packet::{Packet, PacketCodec};
use crate::protocol::types::{Boolean, ProtocolRead, ProtocolString, ProtocolWrite, VarInt};
use log::debug;
use serde::Deserialize;
use uuid::Uuid;

#[derive(Debug, Deserialize, Clone)]
pub struct Property {
    pub name: ProtocolString,
    pub value: ProtocolString,
    pub signature: Option<ProtocolString>,
}

impl ProtocolWrite for Property {
    fn write_to<W: Write>(&self, writer: &mut W) -> io::Result<usize> {
        let mut written = 0;
        written += self.name.write_to(writer)?;
        written += self.value.write_to(writer)?;
        written += Boolean(self.signature.is_some()).write_to(writer)?;
        if let Some(ref sig) = self.signature {
            written += sig.write_to(writer)?;
        }
        Ok(written)
    }
}

#[derive(Debug, Clone)]
pub struct ClientBoundLoginSuccess {
    pub uuid: Uuid,
    pub username: ProtocolString,
    pub properties: Vec<Property>,
}

impl From<&ClientBoundLoginSuccess> for Packet {
    fn from(login: &ClientBoundLoginSuccess) -> Self {
        // Create new packet with ID 0x02 (Login Success)
        let mut packet = Packet::new(0x02);

        packet.data.extend_from_slice(login.uuid.as_bytes());
        packet.encode(&login.username).unwrap();
        packet
            .encode(&VarInt(login.properties.len() as i32))
            .unwrap();

        // Write each property

        //TODO: Check if I've implemented this correctly
        // for prop in login.properties.clone() {
        //     packet.encode(&prop.name).unwrap();
        //     packet.encode(&prop.value).unwrap();
        //     packet.encode(&Boolean(prop.signature.is_some())).unwrap();
        //     if let Some(sig) = prop.signature {
        //         packet.encode(&sig).unwrap();
        //     }
        // }

        packet
    }
}

impl TryFrom<&Packet> for ClientBoundLoginSuccess {
    type Error = io::Error;

    fn try_from(packet: &Packet) -> Result<Self, Self::Error> {
        let mut cursor = io::Cursor::new(&packet.data);
        debug!(
            "Parsing login success packet of length {}",
            packet.data.len()
        );

        // Read UUID
        let mut uuid_bytes = [0u8; 16];
        cursor.read_exact(&mut uuid_bytes)?;
        let uuid = Uuid::from_bytes(uuid_bytes);
        debug!("Read UUID: {:?}", uuid);

        // Read username
        let (username, _) = ProtocolString::read_from(&mut cursor)?;
        debug!("Read username: {}", username.0);

        // Read properties count
        let (VarInt(count), _) = VarInt::read_from(&mut cursor)?;
        debug!("Reading {} properties", count);

        let mut properties = Vec::with_capacity(count as usize);
        for i in 0..count {
            let (name, _) = ProtocolString::read_from(&mut cursor)?;
            let (value, _) = ProtocolString::read_from(&mut cursor)?;
            let (Boolean(has_sig), _) = Boolean::read_from(&mut cursor)?;

            let signature = if has_sig {
                let (sig, _) = ProtocolString::read_from(&mut cursor)?;
                Some(sig)
            } else {
                None
            };

            debug!(
                "Read property {}: name={}, value={}, has_sig={}",
                i, name.0, value.0, has_sig
            );

            properties.push(Property {
                name,
                value,
                signature,
            });
        }

        Ok(Self {
            uuid,
            username,
            properties,
        })
    }
}