126 lines
3.0 KiB
Rust
126 lines
3.0 KiB
Rust
use crate::{
|
|
bytebuf::{packet_id::Packet, ByteBuffer},
|
|
ClientPacket, Property, VarInt,
|
|
};
|
|
|
|
pub struct CLoginDisconnect<'a> {
|
|
reason: &'a str,
|
|
}
|
|
|
|
impl<'a> CLoginDisconnect<'a> {
|
|
pub fn new(reason: &'a str) -> Self {
|
|
Self { reason }
|
|
}
|
|
}
|
|
|
|
impl<'a> Packet for CLoginDisconnect<'a> {
|
|
const PACKET_ID: VarInt = 0x00;
|
|
}
|
|
|
|
impl<'a> ClientPacket for CLoginDisconnect<'a> {
|
|
fn write(&self, bytebuf: &mut ByteBuffer) {
|
|
bytebuf.put_string(&serde_json::to_string_pretty(&self.reason).unwrap());
|
|
}
|
|
}
|
|
|
|
pub struct CEncryptionRequest<'a> {
|
|
server_id: &'a str, // 20
|
|
public_key: &'a [u8],
|
|
verify_token: &'a [u8],
|
|
should_authenticate: bool,
|
|
}
|
|
|
|
impl<'a> CEncryptionRequest<'a> {
|
|
pub fn new(
|
|
server_id: &'a str,
|
|
public_key: &'a [u8],
|
|
verify_token: &'a [u8],
|
|
should_authenticate: bool,
|
|
) -> Self {
|
|
Self {
|
|
server_id,
|
|
public_key,
|
|
verify_token,
|
|
should_authenticate,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Packet for CEncryptionRequest<'a> {
|
|
const PACKET_ID: VarInt = 0x01;
|
|
}
|
|
|
|
impl<'a> ClientPacket for CEncryptionRequest<'a> {
|
|
fn write(&self, bytebuf: &mut ByteBuffer) {
|
|
bytebuf.put_string(self.server_id);
|
|
bytebuf.put_var_int(self.public_key.len() as VarInt);
|
|
bytebuf.put_slice(self.public_key);
|
|
bytebuf.put_var_int(self.verify_token.len() as VarInt);
|
|
bytebuf.put_slice(self.verify_token);
|
|
bytebuf.put_bool(self.should_authenticate);
|
|
}
|
|
}
|
|
|
|
pub struct CSetCompression {
|
|
threshold: VarInt,
|
|
}
|
|
|
|
pub struct CLoginSuccess<'a> {
|
|
pub uuid: uuid::Uuid,
|
|
pub username: String, // 16
|
|
pub properties: &'a [Property],
|
|
pub strict_error_handling: bool,
|
|
}
|
|
|
|
impl<'a> CLoginSuccess<'a> {
|
|
pub fn new(
|
|
uuid: uuid::Uuid,
|
|
username: String,
|
|
properties: &'a [Property],
|
|
strict_error_handling: bool,
|
|
) -> Self {
|
|
Self {
|
|
uuid,
|
|
username,
|
|
properties,
|
|
strict_error_handling,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Packet for CLoginSuccess<'a> {
|
|
const PACKET_ID: VarInt = 0x02;
|
|
}
|
|
|
|
impl<'a> ClientPacket for CLoginSuccess<'a> {
|
|
fn write(&self, bytebuf: &mut ByteBuffer) {
|
|
bytebuf.put_uuid(self.uuid);
|
|
bytebuf.put_string(&self.username);
|
|
bytebuf.put_list::<Property>(self.properties, |p, v| {
|
|
p.put_string(&v.name);
|
|
p.put_string(&v.value);
|
|
// has signature ?
|
|
// todo: for some reason we get "got too many bytes error when using a signature"
|
|
p.put_bool(false);
|
|
// p.put_option(&v.signature, |p,v| p.put_string(v));
|
|
});
|
|
bytebuf.put_bool(self.strict_error_handling);
|
|
}
|
|
}
|
|
|
|
impl CSetCompression {
|
|
pub fn new(threshold: VarInt) -> Self {
|
|
Self { threshold }
|
|
}
|
|
}
|
|
|
|
impl Packet for CSetCompression {
|
|
const PACKET_ID: VarInt = 0x03;
|
|
}
|
|
|
|
impl ClientPacket for CSetCompression {
|
|
fn write(&self, bytebuf: &mut ByteBuffer) {
|
|
bytebuf.put_var_int(self.threshold);
|
|
}
|
|
}
|