alex/valence
1
0
Fork 0
mirror of https://github.com/italicsjenga/valence.git synced 2024-12-23 06:21:31 +11:00
Code Issues Packages Projects Releases Wiki Activity

new packet inspector (#369)

Browse source 
## Description

Describe the changes you've made. Link to any issues this PR fixes or
addresses.
... changes... wel, lets see... uuhhmmm, i rewrote the entire packet
inspector :)

(also dont mind the snarkyness of that sentence, im tired)

closes #346
This commit is contained in:
AviiNL 2023-06-17 14:40:51 +02:00 committed by GitHub
parent 2ed5a8840d
commit 8712fea19e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
25 changed files with 2261 additions and 2556 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
Cargo.toml
View file

@ -1,6 +1,6 @@
[workspace]
members = ["crates/*", "tools/*"]
exclude = ["rust-mc-bot", "tools/stresser", "tools/packet_inspector"]
exclude = ["rust-mc-bot", "tools/stresser"]
resolver = "2"
[workspace.package]
@ -19,7 +19,9 @@ async-trait = "0.1.60"
atty = "0.2.14"
base64 = "0.21.0"
bevy_app = { version = "0.10.1", default-features = false }
bevy_ecs = { version = "0.10.1", default-features = false, features = ["trace"] }
bevy_ecs = { version = "0.10.1", default-features = false, features = [
"trace",
] }
bevy_hierarchy = { version = "0.10.1", default-features = false }
bevy_mod_debugdump = "0.7.0"
bitfield-struct = "0.3.1"
@ -30,9 +32,10 @@ cfb8 = "0.8.1"
clap = { version = "4.0.30", features = ["derive"] }
criterion = "0.4.0"
directories = "5.0.0"
eframe = { version = "0.21.0", default-features = false }
egui = "0.21.0"
enum-map = "2.4.2"
eframe = { version = "0.22.0", default-features = false }
egui = "0.22.0"
egui_dock = "0.6"
enum-map = "2.5.0"
flate2 = "1.0.24"
flume = "0.10.14"
fs_extra = "1.2.0"
@ -40,6 +43,8 @@ glam = "0.23.0"
heck = "0.4.0"
hmac = "0.12.1"
indexmap = "1.9.3"
image = "0.24.6"
itertools = "0.10.5"
lru = "0.10.0"
noise = "0.8.2"
num = "0.4.0"

64
tools/packet_inspector/Cargo.toml
View file

@ -5,32 +5,50 @@ edition.workspace = true
description = "A simple Minecraft proxy for inspecting packets."
[features]
default = ["syntax_highlighting"]
syntax_highlighting = ["syntect"]
default = ["gui"]
gui = [
"image",
"syntect",
"serde",
"egui",
"eframe",
"egui_dock",
"itertools",
"enum-map",
]
cli = ["clap"]
[dependencies]
anyhow.workspace = true
atty.workspace = true
bytes.workspace = true
clap.workspace = true
directories.workspace = true
eframe = { workspace = true, default-features = false, features = [
"default_fonts", # Embed the default egui fonts.
"glow", # Use the glow rendering backend. Alternative: "wgpu".
anyhow = { workspace = true }
bytes = { workspace = true }
flate2 = { workspace = true }
flume = { workspace = true }
tokio = { workspace = true, features = ["full"] }
tracing = { workspace = true }
valence = { workspace = true }
time = { workspace = true, features = ["local-offset"] }
image = { workspace = true, optional = true }
tracing-subscriber = { workspace = true }
egui = { workspace = true, optional = true }
eframe = { workspace = true, optional = true, features = [
"persistence",
"wgpu",
] }
egui.workspace = true
enum-map.workspace = true
owo-colors.workspace = true
regex.workspace = true
rfd.workspace = true
serde = { workspace = true, features = ["derive"] }
syntect = { workspace = true, optional = true, default-features = false, features = [
egui_dock = { workspace = true, optional = true, features = ["serde"] }
itertools = { workspace = true, optional = true }
enum-map = { workspace = true, optional = true, features = ["serde"] }
syntect = { workspace = true, default-features = false, optional = true, features = [
"default-fancy",
] }
time = { workspace = true, features = ["local-offset"] }
tokio.workspace = true
toml.workspace = true
tracing-subscriber.workspace = true
valence_nbt = { workspace = true, features = ["preserve_order"] }
valence.workspace = true
serde = { workspace = true, optional = true, features = ["derive"] }
clap = { workspace = true, optional = true, features = ["derive"] }
[build-dependencies]
syn = "2.0.18"
anyhow = "1.0.71"
heck = "0.4.1"
proc-macro2 = "1.0.60"
quote = "1.0.28"
serde = { version = "1.0.164", features = ["derive"] }
serde_json = "1.0.96"

77
tools/packet_inspector/README.md
View file

@ -19,70 +19,37 @@ cargo r -r --example conway
```
Next up, we need to run the proxy server, this can be done in 2 different ways,
either using the GUI application (default) or using the `--nogui` flag to log
the packets to a terminal instance.
either using the GUI application (default) or by using the `cli` feature gate.
To launch in a Gui environment, simply run `packet_inspector`.
```sh
cargo r -r -p packet_inspector
```
To Launch in a Cli environment, build `packet_inspector` with the default
features disabled, and supplying the `cli` feature. note that you **must**
supply the listener and server addresses as arguments.
```bash
cargo r -r -p packet_inspector --no-default-features --features cli -- 127.0.0.1:25566 127.0.0.1:25565
```
To assist, `--help` will produce the following:
```
A simple Minecraft proxy for inspecting packets.
Usage: packet_inspector [OPTIONS] [CLIENT_ADDR] [SERVER_ADDR]
Usage: packet_inspector <LISTENER_ADDR> <SERVER_ADDR>
Arguments:
[CLIENT_ADDR] The socket address to listen for connections on. This is the address clients should connect to
[SERVER_ADDR] The socket address the proxy will connect to. This is the address of the server
Options:
-m, --max-connections <MAX_CONNECTIONS>
The maximum number of connections allowed to the proxy. By default, there is no limit
--nogui
Disable the GUI. Logging to stdout
-i, --include-filter <INCLUDE_FILTER>
Only show packets that match the filter
-e, --exclude-filter <EXCLUDE_FILTER>
Hide packets that match the filter. Note: Only in effect if nogui is set
-h, --help
Print help
-V, --version
Print version
<LISTENER_ADDR> The socket address to listen for connections on. This is the address clients should connect to
<SERVER_ADDR> The socket address the proxy will connect to. This is the address of the server
```
To launch in a Gui environment, simply launch `packet_inspector[.exe]` (or
`cargo r -r -p packet_inspector` to run from source). The gui will prompt you
for the `CLIENT_ADDR` and `SERVER_ADDR` if they have not been supplied via the
command line arguments.
In a terminal only environment, use the `--nogui` option and supply
`CLIENT_ADDR` and `SERVER_ADDR` as arguments.
```bash
cargo r -r -p packet_inspector -- --nogui 127.0.0.1:25566 127.0.0.1:25565
```
The client must connect to `localhost:25566`. You should see the packets in
`stdout` when running in `--nogui`, or you should see packets streaming in on
the Gui.
The `-i` and `-e` flags accept a regex to filter packets according to their
name. The `-i` regex includes matching packets while the `-e` regex excludes
matching packets. Do note that `-e` only applies in `--nogui` environment, as
the Gui has a "packet selector" to enable/disable packets dynamically. The `-i`
parameter value will be included in the `Filter` input field on the Gui.
For instance, if you only want to print the packets `Foo`, `Bar`, and `Baz`, you
can use a regex such as `^(Foo|Bar|Baz)$` with the `-i` flag.
```sh
cargo r -r -p packet_inspector -- --nogui 127.0.0.1:25566 127.0.0.1:25565 -i '^(Foo|Bar|Baz)$'
```
Packets are printed to `stdout` while errors are printed to `stderr`. If you
only want to see errors in your terminal, direct `stdout` elsewhere.
```sh
cargo r -r -p packet_inspector -- --nogui 127.0.0.1:25566 127.0.0.1:25565 > log.txt
```
The client can now connect to `localhost:25566`. You should see the packets in
`stdout` when running in cli mode, or you should see packets streaming in on the
Gui.
## Quick start with Vanilla Server via Docker
@ -107,7 +74,7 @@ docker exec -i mc rcon-cli
In a separate terminal, start the packet inspector.
```sh
cargo r -r -p packet_inspector -- --nogui 127.0.0.1:25566 127.0.0.1:25565
cargo r -r -p packet_inspector --no-default-features --features cli -- 127.0.0.1:25566 127.0.0.1:25565
```
Open Minecraft and connect to `localhost:25566`.

226
tools/packet_inspector/build.rs Normal file
View file

@ -0,0 +1,226 @@
use std::{collections::HashMap, env, fs, path::Path, process::Command};
use anyhow::Context;
use proc_macro2::TokenStream;
use quote::quote;
use serde::Deserialize;
#[derive(Deserialize)]
struct Packet {
name: String,
side: String,
state: String,
id: i32,
}
pub fn main() -> anyhow::Result<()> {
let packets: Vec<Packet> = serde_json::from_str(include_str!("../../extracted/packets.json"))?;
write_packets(&packets)?;
write_transformer(&packets)?;
Ok(())
}
fn write_packets(packets: &Vec<Packet>) -> anyhow::Result<()> {
let mut consts = TokenStream::new();
let len = packets.len();
let mut p: Vec<TokenStream> = Vec::new();
for packet in packets {
let name = packet.name.strip_suffix("Packet").unwrap_or(&packet.name);
// lowercase the last character of name
let name = {
let mut chars = name.chars();
let last_char = chars.next_back().unwrap();
let last_char = last_char.to_lowercase().to_string();
let mut name = chars.collect::<String>();
name.push_str(&last_char);
name
};
// if the packet is clientbound, but the name does not ends with S2c, add it
let name = if packet.side == "clientbound" && !name.ends_with("S2c") {
format!("{}S2c", name)
} else {
name
};
// same for serverbound
let name = if packet.side == "serverbound" && !name.ends_with("C2s") {
format!("{}C2s", name)
} else {
name
};
let id = packet.id;
let side = match &packet.side {
s if s == "clientbound" => quote! { crate::packet_registry::PacketSide::Clientbound },
s if s == "serverbound" => quote! { crate::packet_registry::PacketSide::Serverbound },
_ => unreachable!(),
};
let state = match &packet.state {
s if s == "handshaking" => quote! { crate::packet_registry::PacketState::Handshaking },
s if s == "status" => quote! { crate::packet_registry::PacketState::Status },
s if s == "login" => quote! { crate::packet_registry::PacketState::Login },
s if s == "play" => quote! { crate::packet_registry::PacketState::Play },
_ => unreachable!(),
};
// const STD_PACKETS = [PacketSide::Client(PacketState::Handshaking(Packet{..})), ..];
p.push(quote! {
crate::packet_registry::Packet {
id: #id,
side: #side,
state: #state,
timestamp: None,
name: #name,
data: None,
}
});
}
consts.extend([quote! {
pub const STD_PACKETS: [crate::packet_registry::Packet; #len] = [
#(#p),*
];
}]);
write_generated_file(consts, "packets.rs")?;
Ok(())
}
fn write_transformer(packets: &[Packet]) -> anyhow::Result<()> {
// HashMap<side, HashMap<state, Vec<name>>>
let grouped_packets = HashMap::<String, HashMap<String, Vec<String>>>::new();
let mut grouped_packets = packets.iter().fold(grouped_packets, |mut acc, packet| {
let side = match packet.side.as_str() {
"serverbound" => "Serverbound".to_string(),
"clientbound" => "Clientbound".to_string(),
_ => panic!("Invalid side"),
};
let state = match packet.state.as_str() {
"handshaking" => "Handshaking".to_string(),
"status" => "Status".to_string(),
"login" => "Login".to_string(),
"play" => "Play".to_string(),
_ => panic!("Invalid state"),
};
let name = packet
.name
.strip_suffix("Packet")
.unwrap_or(&packet.name)
.to_string();
// lowercase the last character of name
let name = {
let mut chars = name.chars();
let last_char = chars.next_back().unwrap();
let last_char = last_char.to_lowercase().to_string();
let mut name = chars.collect::<String>();
name.push_str(&last_char);
name
};
// if the packet is clientbound, but the name does not ends with S2c, add it
let name = if side == "Clientbound" && !name.ends_with("S2c") {
format!("{}S2c", name)
} else {
name
};
// same for serverbound
let name = if side == "Serverbound" && !name.ends_with("C2s") {
format!("{}C2s", name)
} else {
name
};
let state_map = acc.entry(side).or_insert_with(HashMap::new);
let id_map = state_map.entry(state).or_insert_with(Vec::new);
id_map.push(name);
acc
});
let mut generated = TokenStream::new();
for (side, state_map) in grouped_packets.iter_mut() {
let mut side_arms = TokenStream::new();
for (state, id_map) in state_map.iter_mut() {
let mut match_arms = TokenStream::new();
for name in id_map.iter_mut() {
let name = syn::parse_str::<syn::Ident>(name).unwrap();
match_arms.extend(quote! {
#name::ID => {
format!("{:#?}", #name::decode(&mut data).unwrap())
}
});
}
let state = syn::parse_str::<syn::Ident>(state).unwrap();
side_arms.extend(quote! {
PacketState::#state => match packet.id {
#match_arms
_ => NOT_AVAILABLE.to_string(),
},
});
}
if side == "Clientbound" {
side_arms.extend(quote! {
_ => NOT_AVAILABLE.to_string(),
});
}
let side = syn::parse_str::<syn::Ident>(side).unwrap();
generated.extend(quote! {
PacketSide::#side => match packet.state {
#side_arms
},
});
}
// wrap generated in a function definition
let generated = quote! {
const NOT_AVAILABLE: &str = "Not yet implemented";
pub fn packet_to_string(packet: &ProxyPacket) -> String {
let bytes = packet.data.as_ref().unwrap();
let mut data = &bytes.clone()[..];
match packet.side {
#generated
}
}
};
write_generated_file(generated, "packet_to_string.rs")?;
Ok(())
}
pub fn write_generated_file(content: TokenStream, out_file: &str) -> anyhow::Result<()> {
let out_dir = env::var_os("OUT_DIR").context("failed to get OUT_DIR env var")?;
let path = Path::new(&out_dir).join(out_file);
let code = content.to_string();
fs::write(&path, code)?;
// Try to format the output for debugging purposes.
// Doesn't matter if rustfmt is unavailable.
let _ = Command::new("rustfmt").arg(path).output();
Ok(())
}

201
tools/packet_inspector/src/app.rs Normal file
View file

@ -0,0 +1,201 @@
use std::{
net::SocketAddr,
sync::{Arc, RwLock},
};
use egui_dock::{DockArea, NodeIndex, Style, Tree};
use packet_inspector::Proxy;
use tokio::task::JoinHandle;
use crate::shared_state::{Event, SharedState};
mod connection;
mod filter;
mod hex_viewer;
mod packet_list;
mod text_viewer;
pub trait View {
fn ui(&mut self, ui: &mut egui::Ui, shared_state: &mut SharedState);
}
/// Something to view
pub trait Tab: View {
fn new() -> Self
where
Self: Sized;
/// `&'static` so we can also use it as a key to store open/close state.
fn name(&self) -> &'static str;
}
struct TabViewer {
shared_state: Arc<RwLock<SharedState>>,
}
impl egui_dock::TabViewer for TabViewer {
type Tab = Box<dyn Tab>;
fn ui(&mut self, ui: &mut egui::Ui, tab: &mut Self::Tab) {
tab.ui(ui, &mut self.shared_state.write().unwrap());
}
fn title(&mut self, tab: &mut Self::Tab) -> egui::WidgetText {
tab.name().into()
}
fn on_close(&mut self, _tab: &mut Self::Tab) -> bool {
false
}
}
pub struct GuiApp {
tree: Tree<Box<dyn Tab>>,
shared_state: Arc<RwLock<SharedState>>,
tab_viewer: TabViewer,
}
impl GuiApp {
pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
let ctx = cc.egui_ctx.clone();
// Default Application Layout
let mut tree: Tree<Box<dyn Tab>> = Tree::new(vec![Box::new(connection::Connection::new())]);
let [a, b] = tree.split_right(
NodeIndex::root(),
0.3,
vec![Box::new(packet_list::PacketList::new())],
);
let [_, _] = tree.split_below(a, 0.25, vec![Box::new(filter::Filter::new())]);
let [_, _] = tree.split_below(
b,
0.5,
vec![
Box::new(hex_viewer::HexView::new()),
Box::new(text_viewer::TextView::new()),
],
);
// Persistant Storage
let mut shared_state = SharedState::new(ctx);
if let Some(storage) = cc.storage {
if let Some(value) = eframe::get_value::<SharedState>(storage, eframe::APP_KEY) {
shared_state = value.merge(shared_state);
}
}
let autostart = shared_state.autostart;
let shared_state = Arc::new(RwLock::new(shared_state));
// Event Handling
handle_events(shared_state.clone());
if autostart {
let state = shared_state.read().unwrap();
state.send_event(Event::StartListening);
}
// Consumer thread
// Tab Viewer
let tab_viewer = TabViewer {
shared_state: shared_state.clone(),
};
Self {
shared_state,
tree,
tab_viewer,
}
}
}
impl eframe::App for GuiApp {
fn save(&mut self, storage: &mut dyn eframe::Storage) {
eframe::set_value(
storage,
eframe::APP_KEY,
&*self.shared_state.read().unwrap(),
);
}
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
DockArea::new(&mut self.tree)
.show_add_buttons(false)
.show_add_popup(false)
.show_close_buttons(false)
.style(Style::from_egui(ctx.style().as_ref()))
.show(ctx, &mut self.tab_viewer);
}
}
// This function is getting waaaay too complcated and messy
fn handle_events(state: Arc<RwLock<SharedState>>) {
tokio::spawn(async move {
let mut proxy_thread: Option<JoinHandle<_>> = None;
let receiver = state.write().unwrap().receiver.take().unwrap();
while let Ok(event) = receiver.recv_async().await {
match event {
Event::StartListening => {
let mut w_state = state.write().unwrap();
if w_state.is_listening {
continue;
}
let Ok(listener_addr) = w_state.listener_addr.parse::<SocketAddr>() else {
w_state.is_listening = false;
continue;
};
let Ok(server_addr) = w_state.server_addr.parse::<SocketAddr>() else {
w_state.is_listening = false;
continue;
};
let state = state.clone();
proxy_thread = Some(tokio::spawn(async move {
let proxy = Proxy::new(listener_addr, server_addr);
let receiver = proxy.subscribe().await;
tokio::spawn(async move {
proxy.run().await?;
Ok::<(), anyhow::Error>(())
});
while let Ok(packet) = receiver.recv_async().await {
let state = state.read().unwrap();
state.packets.write().unwrap().push(packet);
state.send_event(Event::PacketReceived);
}
Ok::<(), anyhow::Error>(())
}));
w_state.is_listening = true;
}
Event::StopListening => {
let mut state = state.write().unwrap();
if !state.is_listening {
continue;
}
if let Some(proxy_thread) = proxy_thread.take() {
proxy_thread.abort();
}
state.is_listening = false;
}
Event::PacketReceived => {
// Refresh UI
if let Some(ctx) = &state.read().unwrap().ctx {
ctx.request_repaint();
}
}
}
}
});
}

44
tools/packet_inspector/src/app/connection.rs Normal file
View file

@ -0,0 +1,44 @@
use crate::shared_state::Event;
use super::{SharedState, Tab, View};
pub struct Connection {}
impl Tab for Connection {
fn new() -> Self {
Self {}
}
fn name(&self) -> &'static str {
"Connection"
}
}
impl View for Connection {
fn ui(&mut self, ui: &mut egui::Ui, state: &mut SharedState) {
if state.is_listening {
ui.label("Listener Address");
ui.text_edit_singleline(&mut state.listener_addr.clone());
ui.label("Server Address");
ui.text_edit_singleline(&mut state.server_addr.clone());
ui.horizontal(|ui| {
if ui.button("Stop Listening").clicked() {
state.send_event(Event::StopListening);
}
ui.checkbox(&mut state.autostart, "Autostart");
});
} else {
ui.label("Listener Address");
ui.text_edit_singleline(&mut state.listener_addr);
ui.label("Server Address");
ui.text_edit_singleline(&mut state.server_addr);
ui.horizontal(|ui| {
if ui.button("Start Listening").clicked() {
state.send_event(Event::StartListening);
}
ui.checkbox(&mut state.autostart, "Autostart");
});
}
}
}

132
tools/packet_inspector/src/app/filter.rs Normal file
View file

@ -0,0 +1,132 @@
use egui::{RichText, Ui, Widget};
use itertools::Itertools;
use packet_inspector::PacketState;
use crate::tri_checkbox::{TriCheckbox, TriCheckboxState};
use super::{SharedState, Tab, View};
pub struct Filter {}
impl Tab for Filter {
fn new() -> Self {
Self {}
}
fn name(&self) -> &'static str {
"Filters"
}
}
impl View for Filter {
fn ui(&mut self, ui: &mut egui::Ui, state: &mut SharedState) {
ui.horizontal(|ui| {
ui.label("Search:");
if ui.button("x").clicked() {
state.packet_search.clear();
}
ui.text_edit_singleline(&mut state.packet_search);
});
egui::ScrollArea::vertical()
.auto_shrink([false, false])
.stick_to_bottom(false)
.show(ui, |ui| {
if draw_packet_list(ui, state, PacketState::Handshaking) > 0 {
ui.separator();
}
if draw_packet_list(ui, state, PacketState::Status) > 0 {
ui.separator();
}
if draw_packet_list(ui, state, PacketState::Login) > 0 {
ui.separator();
}
draw_packet_list(ui, state, PacketState::Play);
});
}
}
fn get_checkbox_state(state: &SharedState, packet_state: PacketState) -> TriCheckboxState {
let mut p_enabled = 0;
let mut disabled = 0;
for (_, enabled) in state
.packet_filter
.iter()
.filter(|(p, _)| p.state == packet_state)
{
if *enabled {
p_enabled += 1;
} else {
disabled += 1;
}
}
if p_enabled > 0 && disabled == 0 {
TriCheckboxState::Enabled
} else if p_enabled > 0 && disabled > 0 {
TriCheckboxState::Partial
} else {
TriCheckboxState::Disabled
}
}
fn draw_packet_list(ui: &mut Ui, state: &mut SharedState, packet_state: PacketState) -> usize {
let title = match packet_state {
PacketState::Handshaking => "Handshaking",
PacketState::Status => "Status",
PacketState::Login => "Login",
PacketState::Play => "Play",
};
let search = state.packet_search.to_lowercase();
let count = state
.packet_filter
.iter_mut()
.filter(|(p, _)| p.state == packet_state && p.name.to_lowercase().contains(&search))
.count();
let count_enabled = state
.packet_filter
.iter_mut()
.filter(|(p, enabled)| {
p.state == packet_state && p.name.to_lowercase().contains(&search) && **enabled
})
.count();
if count == 0 {
return 0;
}
let mut checkbox = get_checkbox_state(state, packet_state);
if TriCheckbox::new(&mut checkbox, RichText::new(title).heading().strong())
.ui(ui)
.changed()
{
for (_, enabled) in state
.packet_filter
.iter_mut()
.filter(|(p, _)| p.state == packet_state && p.name.to_lowercase().contains(&search))
{
if count == count_enabled || count_enabled == 0 {
*enabled = !*enabled;
continue;
}
*enabled = (count / 2) <= count_enabled;
}
}
for (p, enabled) in state
.packet_filter
.iter_mut()
.filter(|(p, _)| p.state == packet_state && p.name.to_lowercase().contains(&search))
.sorted_by(|(a, _), (b, _)| {
a.id.cmp(&b.id)
.then((a.side as usize).cmp(&(b.side as usize)))
})
{
ui.checkbox(enabled, format!("[0x{:0>2X}] {}", p.id, p.name));
}
return count;
}

69
tools/packet_inspector/src/app/hex_viewer.rs Normal file
View file

@ -0,0 +1,69 @@
use std::io::Read;
use egui::Color32;
use super::{SharedState, Tab, View};
pub struct HexView {}
impl Tab for HexView {
fn new() -> Self {
Self {}
}
fn name(&self) -> &'static str {
"Hex Viewer"
}
}
impl View for HexView {
fn ui(&mut self, ui: &mut egui::Ui, state: &mut SharedState) {
let mut buf = [0u8; 16];
let mut count = 0;
let packets = state.packets.read().unwrap();
let Some(packet_index) = state.selected_packet else {
return;
};
let bytes = &packets[packet_index].data.as_ref().unwrap();
let mut file = &(*bytes).clone()[..];
egui::Grid::new("hex_grid")
.spacing([4.0, 1.5])
.striped(true)
.min_col_width(0.0)
.show(ui, |ui| {
ui.label(" ");
for i in 0..16 {
ui.label(format!("{:02X}", i));
}
ui.end_row();
loop {
let bytes_read = file.read(&mut buf).unwrap();
if bytes_read == 0 {
break;
}
ui.label(format!("{:08X}", count));
for b in buf.iter().take(bytes_read) {
ui.colored_label(Color32::from_rgb(255, 255, 255), format!("{:02X}", b));
}
for _ in 0..16 - bytes_read {
ui.label(" ");
}
ui.label(" ");
for b in buf.iter().take(bytes_read) {
if *b >= 0x20 && *b <= 0x7e {
ui.label(format!("{}", *b as char));
} else {
ui.label(".");
}
}
ui.end_row();
count += bytes_read;
}
});
}
}

264
tools/packet_inspector/src/app/packet_list.rs Normal file
View file

@ -0,0 +1,264 @@
use eframe::epaint::{PathShape, RectShape};
use egui::{
Color32, Pos2, Rect, Response, Rgba, Rounding, Sense, Shape, Stroke, TextStyle, Ui, Vec2,
WidgetText,
};
use packet_inspector::{Packet, PacketSide};
use super::{SharedState, Tab, View};
pub struct PacketList {}
impl Tab for PacketList {
fn new() -> Self {
Self {}
}
fn name(&self) -> &'static str {
"Packets"
}
}
impl View for PacketList {
fn ui(&mut self, ui: &mut egui::Ui, state: &mut SharedState) {
handle_keyboard_input(state, ui);
ui.horizontal(|ui| {
ui.heading("Packets");
draw_packet_counter(state, ui);
draw_clear_button(state, ui);
});
draw_packet_list(state, ui);
}
}
fn handle_keyboard_input(state: &mut SharedState, ui: &mut Ui) {
if ui.input(|i| i.key_pressed(egui::Key::ArrowUp)) {
// select previous packet
let index = state.selected_packet.unwrap_or(1);
let packets = state.packets.read().unwrap();
let filtered_packets = packets
.iter()
.enumerate()
.filter(|(i, p)| *i < index && state.packet_filter.get(p).unwrap_or(true))
.map(|(i, _)| i)
.collect::<Vec<_>>();
if let Some(&prev_index) = filtered_packets.last() {
state.selected_packet = Some(prev_index);
state.update_scroll = true;
}
}
if ui.input(|i| i.key_pressed(egui::Key::ArrowDown)) {
// select next packet
let index = state.selected_packet.unwrap_or(0);
let packets = state.packets.read().unwrap();
let filtered_packets = packets
.iter()
.enumerate()
.filter(|(i, p)| *i > index && state.packet_filter.get(p).unwrap_or(true))
.map(|(i, _)| i)
.collect::<Vec<_>>();
if let Some(&next_index) = filtered_packets.first() {
state.selected_packet = Some(next_index);
state.update_scroll = true;
}
}
}
fn draw_packet_counter(state: &mut SharedState, ui: &mut Ui) {
let packets = state.packets.read().unwrap();
let length = packets.len();
let filtered_packets = packets
.iter()
.filter(|p| state.packet_filter.get(p).unwrap_or(true))
.count();
ui.label(format!("({}/{})", filtered_packets, length));
}
fn draw_clear_button(state: &mut SharedState, ui: &mut Ui) {
if ui.button("Clear").clicked() {
state.selected_packet = None;
state.packets.write().unwrap().clear();
}
}
fn draw_packet_list(state: &mut SharedState, ui: &mut Ui) {
let packets = state.packets.read().unwrap();
egui::ScrollArea::vertical()
.auto_shrink([false, false])
.stick_to_bottom(!state.update_scroll)
.show(ui, |ui| {
for (i, packet) in packets.iter().enumerate() {
if let Some(filtered) = state.packet_filter.get(packet) {
if !filtered {
continue;
}
}
let selected = {
if let Some(selected) = state.selected_packet {
selected == i
} else {
false
}
};
let widget = draw_packet_widget(ui, packet, selected);
if state.update_scroll && state.selected_packet == Some(i) {
state.update_scroll = false;
ui.scroll_to_rect(widget.rect, None);
}
if widget.clicked() {
state.selected_packet = Some(i);
}
}
});
}
fn draw_packet_widget(ui: &mut Ui, packet: &Packet, selected: bool) -> Response {
let (mut rect, response) = ui.allocate_at_least(
Vec2 {
x: ui.available_width(),
y: 24.0,
},
Sense::click(),
); // this should give me a new rect inside the scroll area... no?
let fill = match selected /*packet.selected*/ {
true => Rgba::from_rgba_premultiplied(0.3, 0.3, 0.3, 0.4),
false => Rgba::from_rgba_premultiplied(0.0, 0.0, 0.0, 0.0),
};
let text_color: Color32 = match selected /*packet.selected*/ {
true => Rgba::from_rgba_premultiplied(0.0, 0.0, 0.0, 1.0).into(),
false => ui.visuals().strong_text_color(),
};
if ui.is_rect_visible(rect) {
ui.painter().add(Shape::Rect(RectShape {
rect,
rounding: Rounding::none(),
fill: fill.into(),
stroke: Stroke::new(1.0, Rgba::BLACK),
}));
let shape = get_triangle(packet.side, &rect);
ui.painter().add(Shape::Path(shape));
let identifier: WidgetText = format!("0x{:0>2X?}", packet.id).into();
let identifier =
identifier.into_galley(ui, Some(false), rect.width() - 21.0, TextStyle::Button);
let label: WidgetText = packet.name.into();
let label = label.into_galley(ui, Some(false), rect.width() - 60.0, TextStyle::Button);
let timestamp: WidgetText = systemtime_strftime(packet.timestamp.unwrap()).into();
let timestamp =
timestamp.into_galley(ui, Some(false), rect.width() - 60.0, TextStyle::Button);
identifier.paint_with_fallback_color(
ui.painter(),
Pos2 {
x: rect.left() + 21.0,
y: rect.top() + 6.0,
},
ui.visuals().weak_text_color(),
);
rect.set_width(rect.width() - 5.0);
let label_width = label.size().x + 50.0;
label.paint_with_fallback_color(
&ui.painter().with_clip_rect(rect),
Pos2 {
x: rect.left() + 55.0,
y: rect.top() + 6.0,
},
text_color,
);
timestamp.paint_with_fallback_color(
&ui.painter().with_clip_rect(rect),
Pos2 {
x: rect.left() + label_width + 8.0,
y: rect.top() + 6.0,
},
ui.visuals().weak_text_color(),
);
}
response
}
fn get_triangle(direction: PacketSide, outer_rect: &Rect) -> PathShape {
let rect = Rect::from_min_size(
Pos2 {
x: outer_rect.left() + 6.0,
y: outer_rect.top() + 8.0,
},
Vec2 { x: 8.0, y: 8.0 },
);
let color = match direction {
PacketSide::Clientbound => Rgba::from_rgb(255.0, 0.0, 0.0),
PacketSide::Serverbound => Rgba::from_rgb(0.0, 255.0, 0.0),
};
let points = match direction {
PacketSide::Clientbound => vec![
Pos2 {
x: rect.left() + (rect.width() / 2.0),
y: rect.top() + rect.height(),
},
Pos2 {
x: rect.left() + 0.0,
y: rect.top(),
},
Pos2 {
x: rect.left() + rect.width(),
y: rect.top(),
},
],
PacketSide::Serverbound => vec![
Pos2 {
x: rect.left() + (rect.width() / 2.0),
y: rect.top() + 0.0,
},
Pos2 {
x: rect.left() + 0.0,
y: rect.top() + rect.height(),
},
Pos2 {
x: rect.left() + rect.width(),
y: rect.top() + rect.height(),
},
],
};
let mut shape = PathShape::closed_line(points, Stroke::new(2.0, color));
shape.fill = color.into();
shape
}
pub fn systemtime_strftime(odt: time::OffsetDateTime) -> String {
let hour = odt.hour();
let minute = odt.minute();
let second = odt.second();
let millis = odt.millisecond();
format!("{hour:0>2}:{minute:0>2}:{second:0>2}.{millis:0>4}")
}

353
tools/packet_inspector/src/app/text_viewer.rs Normal file
View file

@ -0,0 +1,353 @@
use super::{SharedState, Tab, View};
mod utils {
use packet_inspector::Packet as ProxyPacket;
use packet_inspector::{PacketSide, PacketState};
use valence::protocol::{Decode, Packet};
use valence::advancement::packet::*;
use valence::client::action::*;
use valence::client::command::*;
use valence::client::custom_payload::*;
use valence::client::hand_swing::*;
use valence::client::interact_block::*;
use valence::client::interact_entity::*;
use valence::client::interact_item::*;
use valence::client::keepalive::*;
use valence::client::movement::*;
use valence::client::packet::structure_block::*;
use valence::client::packet::*;
use valence::client::resource_pack::*;
use valence::client::settings::*;
use valence::client::status::*;
use valence::client::teleport::*;
use valence::client::title::*;
use valence::entity::packet::*;
use valence::instance::packet::*;
use valence::inventory::packet::synchronize_recipes::*;
use valence::inventory::packet::*;
use valence::network::packet::*;
use valence::particle::*;
use valence::player_list::packet::*;
use valence::protocol::packet::boss_bar::*;
use valence::protocol::packet::chat::*;
use valence::protocol::packet::command::*;
use valence::protocol::packet::map::*;
use valence::protocol::packet::scoreboard::*;
use valence::protocol::packet::sound::*;
use valence::registry::tags::*;
use valence::world_border::packet::*;
include!(concat!(env!("OUT_DIR"), "/packet_to_string.rs"));
}
pub struct TextView {
last_packet_id: Option<usize>,
packet_str: String,
}
impl Tab for TextView {
fn new() -> Self {
Self {
last_packet_id: None,
packet_str: "".to_string(),
}
}
fn name(&self) -> &'static str {
"Text Viewer"
}
}
impl View for TextView {
fn ui(&mut self, ui: &mut egui::Ui, state: &mut SharedState) {
let packets = state.packets.read().unwrap();
let Some(packet_index) = state.selected_packet else {
self.last_packet_id = None;
self.packet_str = "".to_string();
return;
};
if self.last_packet_id != Some(packet_index) {
self.last_packet_id = Some(packet_index);
self.packet_str = utils::packet_to_string(&packets[packet_index]);
}
code_view_ui(ui, &self.packet_str);
}
}
// From: https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/syntax_highlighting.rs
use egui::text::LayoutJob;
/// View some code with syntax highlighting and selection.
pub fn code_view_ui(ui: &mut egui::Ui, mut code: &str) {
let language = "rs";
let theme = CodeTheme::from_memory(ui.ctx());
let mut layouter = |ui: &egui::Ui, string: &str, wrap_width: f32| {
let mut layout_job = highlight(ui.ctx(), &theme, string, language);
layout_job.wrap.max_width = wrap_width; // no wrapping
ui.fonts(|f| f.layout_job(layout_job))
};
ui.add(
egui::TextEdit::multiline(&mut code)
.font(egui::TextStyle::Monospace) // for cursor height
.code_editor()
.desired_width(ui.available_width())
.desired_rows(24)
.lock_focus(true)
.layouter(&mut layouter),
);
}
/// Memoized Code highlighting
pub fn highlight(ctx: &egui::Context, theme: &CodeTheme, code: &str, language: &str) -> LayoutJob {
impl egui::util::cache::ComputerMut<(&CodeTheme, &str, &str), LayoutJob> for Highlighter {
fn compute(&mut self, (theme, code, lang): (&CodeTheme, &str, &str)) -> LayoutJob {
self.highlight(theme, code, lang)
}
}
type HighlightCache = egui::util::cache::FrameCache<LayoutJob, Highlighter>;
ctx.memory_mut(|mem| {
mem.caches
.cache::<HighlightCache>()
.get((theme, code, language))
})
}
// ----------------------------------------------------------------------------
#[derive(Clone, Copy, Hash, PartialEq, serde::Deserialize, serde::Serialize)]
#[allow(unused)]
enum SyntectTheme {
Base16EightiesDark,
Base16MochaDark,
Base16OceanDark,
Base16OceanLight,
InspiredGitHub,
SolarizedDark,
SolarizedLight,
}
#[allow(unused)]
impl SyntectTheme {
fn all() -> impl ExactSizeIterator<Item = Self> {
[
Self::Base16EightiesDark,
Self::Base16MochaDark,
Self::Base16OceanDark,
Self::Base16OceanLight,
Self::InspiredGitHub,
Self::SolarizedDark,
Self::SolarizedLight,
]
.iter()
.copied()
}
fn name(&self) -> &'static str {
match self {
Self::Base16EightiesDark => "Base16 Eighties (dark)",
Self::Base16MochaDark => "Base16 Mocha (dark)",
Self::Base16OceanDark => "Base16 Ocean (dark)",
Self::Base16OceanLight => "Base16 Ocean (light)",
Self::InspiredGitHub => "InspiredGitHub (light)",
Self::SolarizedDark => "Solarized (dark)",
Self::SolarizedLight => "Solarized (light)",
}
}
fn syntect_key_name(&self) -> &'static str {
match self {
Self::Base16EightiesDark => "base16-eighties.dark",
Self::Base16MochaDark => "base16-mocha.dark",
Self::Base16OceanDark => "base16-ocean.dark",
Self::Base16OceanLight => "base16-ocean.light",
Self::InspiredGitHub => "InspiredGitHub",
Self::SolarizedDark => "Solarized (dark)",
Self::SolarizedLight => "Solarized (light)",
}
}
pub fn is_dark(&self) -> bool {
match self {
Self::Base16EightiesDark
| Self::Base16MochaDark
| Self::Base16OceanDark
| Self::SolarizedDark => true,
Self::Base16OceanLight | Self::InspiredGitHub | Self::SolarizedLight => false,
}
}
}
#[derive(Clone, Hash, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(default)]
pub struct CodeTheme {
dark_mode: bool,
syntect_theme: SyntectTheme,
}
impl Default for CodeTheme {
fn default() -> Self {
Self::dark()
}
}
#[allow(unused)]
impl CodeTheme {
pub fn from_style(style: &egui::Style) -> Self {
if style.visuals.dark_mode {
Self::dark()
} else {
Self::light()
}
}
pub fn from_memory(ctx: &egui::Context) -> Self {
if ctx.style().visuals.dark_mode {
ctx.data_mut(|d| {
d.get_persisted(egui::Id::new("dark"))
.unwrap_or_else(CodeTheme::dark)
})
} else {
ctx.data_mut(|d| {
d.get_persisted(egui::Id::new("light"))
.unwrap_or_else(CodeTheme::light)
})
}
}
pub fn store_in_memory(self, ctx: &egui::Context) {
if self.dark_mode {
ctx.data_mut(|d| d.insert_persisted(egui::Id::new("dark"), self));
} else {
ctx.data_mut(|d| d.insert_persisted(egui::Id::new("light"), self));
}
}
}
#[allow(unused)]
impl CodeTheme {
pub fn dark() -> Self {
Self {
dark_mode: true,
syntect_theme: SyntectTheme::SolarizedDark,
}
}
pub fn light() -> Self {
Self {
dark_mode: false,
syntect_theme: SyntectTheme::SolarizedLight,
}
}
pub fn ui(&mut self, ui: &mut egui::Ui) {
egui::widgets::global_dark_light_mode_buttons(ui);
for theme in SyntectTheme::all() {
if theme.is_dark() == self.dark_mode {
ui.radio_value(&mut self.syntect_theme, theme, theme.name());
}
}
}
}
// ----------------------------------------------------------------------------
struct Highlighter {
ps: syntect::parsing::SyntaxSet,
ts: syntect::highlighting::ThemeSet,
}
impl Default for Highlighter {
fn default() -> Self {
Self {
ps: syntect::parsing::SyntaxSet::load_defaults_newlines(),
ts: syntect::highlighting::ThemeSet::load_defaults(),
}
}
}
impl Highlighter {
#[allow(clippy::unused_self, clippy::unnecessary_wraps)]
fn highlight(&self, theme: &CodeTheme, code: &str, lang: &str) -> LayoutJob {
self.highlight_impl(theme, code, lang).unwrap_or_else(|| {
// Fallback:
LayoutJob::simple(
code.into(),
egui::FontId::monospace(12.0),
if theme.dark_mode {
egui::Color32::LIGHT_GRAY
} else {
egui::Color32::DARK_GRAY
},
f32::INFINITY,
)
})
}
fn highlight_impl(&self, theme: &CodeTheme, text: &str, language: &str) -> Option<LayoutJob> {
use syntect::easy::HighlightLines;
use syntect::highlighting::FontStyle;
use syntect::util::LinesWithEndings;
let syntax = self
.ps
.find_syntax_by_name(language)
.or_else(|| self.ps.find_syntax_by_extension(language))?;
let theme = theme.syntect_theme.syntect_key_name();
let mut h = HighlightLines::new(syntax, &self.ts.themes[theme]);
use egui::text::{LayoutSection, TextFormat};
let mut job = LayoutJob {
text: text.into(),
..Default::default()
};
for line in LinesWithEndings::from(text) {
for (style, range) in h.highlight_line(line, &self.ps).ok()? {
let fg = style.foreground;
let text_color = egui::Color32::from_rgb(fg.r, fg.g, fg.b);
let italics = style.font_style.contains(FontStyle::ITALIC);
let underline = style.font_style.contains(FontStyle::ITALIC);
let underline = if underline {
egui::Stroke::new(1.0, text_color)
} else {
egui::Stroke::NONE
};
job.sections.push(LayoutSection {
leading_space: 0.0,
byte_range: as_byte_range(text, range),
format: TextFormat {
font_id: egui::FontId::monospace(12.0),
color: text_color,
italics,
underline,
..Default::default()
},
});
}
}
Some(job)
}
}
fn as_byte_range(whole: &str, range: &str) -> std::ops::Range<usize> {
let whole_start = whole.as_ptr() as usize;
let range_start = range.as_ptr() as usize;
assert!(whole_start <= range_start);
assert!(range_start + range.len() <= whole_start + whole.len());
let offset = range_start - whole_start;
offset..(offset + range.len())
}

131
tools/packet_inspector/src/config.rs
View file

@ -1,131 +0,0 @@
use std::collections::BTreeMap;
use std::net::SocketAddr;
use std::path::PathBuf;
use directories::ProjectDirs;
use serde::{Deserialize, Serialize};
use crate::MetaPacket;
#[derive(Serialize, Deserialize)]
pub struct ApplicationConfig {
server_addr: SocketAddr,
client_addr: SocketAddr,
max_connections: Option<usize>,
filter: Option<String>,
selected_packets: Option<BTreeMap<MetaPacket, bool>>,
#[serde(skip_serializing, skip_deserializing)]
must_save: bool,
}
impl Default for ApplicationConfig {
fn default() -> Self {
Self {
server_addr: "127.0.0.1:25565".parse().unwrap(),
client_addr: "127.0.0.1:25566".parse().unwrap(),
max_connections: None,
filter: None,
selected_packets: None,
must_save: false,
}
}
}
impl ApplicationConfig {
pub fn load() -> Result<ApplicationConfig, Box<dyn std::error::Error>> {
let config_dir = get_or_create_project_dirs()?;
let config_file = config_dir.join("config.toml");
if config_file.exists() {
let config = std::fs::read_to_string(config_file)?;
toml::from_str(&config).map_err(|e| e.into())
} else {
let config = toml::to_string(&ApplicationConfig::default()).unwrap();
std::fs::write(config_file, config)?;
Ok(ApplicationConfig::default())
}
}
pub fn server_addr(&self) -> SocketAddr {
self.server_addr
}
pub fn client_addr(&self) -> SocketAddr {
self.client_addr
}
pub fn max_connections(&self) -> Option<usize> {
self.max_connections
}
pub fn filter(&self) -> &Option<String> {
&self.filter
}
pub fn selected_packets(&self) -> &Option<BTreeMap<MetaPacket, bool>> {
&self.selected_packets
}
pub fn set_server_addr(&mut self, addr: SocketAddr) {
self.must_save = true;
self.server_addr = addr;
}
pub fn set_client_addr(&mut self, addr: SocketAddr) {
self.must_save = true;
self.client_addr = addr;
}
pub fn set_max_connections(&mut self, max: Option<usize>) {
self.must_save = true;
self.max_connections = max;
}
pub fn set_filter(&mut self, filter: Option<String>) {
self.must_save = true;
self.filter = filter;
}
pub fn set_selected_packets(&mut self, packets: BTreeMap<MetaPacket, bool>) {
self.must_save = true;
self.selected_packets = Some(packets);
}
pub fn save(&mut self) -> Result<(), Box<dyn std::error::Error>> {
if !self.must_save {
return Ok(());
}
self.must_save = false;
let config_dir = match get_or_create_project_dirs() {
Ok(dir) => dir,
Err(e) => {
eprintln!("Could not find config directory: {}", e);
return Ok(());
}
};
let config_file = config_dir.join("config.toml");
let config = toml::to_string(&self).unwrap();
std::fs::write(config_file, config).unwrap();
Ok(())
}
}
fn get_or_create_project_dirs() -> Result<PathBuf, Box<dyn std::error::Error>> {
if let Some(proj_dirs) = ProjectDirs::from("com", "valence", "inspector") {
// check if the directory exists, if not create it
if !proj_dirs.config_dir().exists() {
std::fs::create_dir_all(proj_dirs.config_dir())?;
}
Ok(proj_dirs.config_dir().to_owned())
} else {
Err("Could not find project directories".into())
}
}

356
tools/packet_inspector/src/context.rs
View file

@ -1,356 +0,0 @@
use std::collections::BTreeMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::RwLock;
use owo_colors::{OwoColorize, Style};
use regex::Regex;
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use valence::network::packet::{
HandshakeC2s, LoginHelloC2s, LoginKeyC2s, LoginSuccessS2c, QueryPingC2s, QueryPongS2c,
QueryRequestC2s, QueryResponseS2c,
};
use valence::protocol::decode::PacketDecoder;
use crate::packet_groups::{C2sPlayPacket, S2cLoginPacket, S2cPlayPacket};
use crate::packet_widget::{systemtime_strftime, PacketDirection};
use crate::MetaPacket;
#[derive(Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
pub enum Stage {
HandshakeC2s,
QueryRequestC2s,
QueryResponseS2c,
QueryPingC2s,
QueryPongS2c,
LoginHelloC2s,
S2cLoginPacket,
LoginKeyC2s,
LoginSuccessS2c,
C2sPlayPacket,
S2cPlayPacket,
}
impl From<Stage> for usize {
fn from(stage: Stage) -> Self {
match stage {
Stage::HandshakeC2s => 0,
Stage::QueryRequestC2s => 1,
Stage::QueryResponseS2c => 2,
Stage::QueryPingC2s => 3,
Stage::QueryPongS2c => 4,
Stage::LoginHelloC2s => 5,
Stage::S2cLoginPacket => 6,
Stage::LoginKeyC2s => 7,
Stage::LoginSuccessS2c => 8,
Stage::C2sPlayPacket => 9,
Stage::S2cPlayPacket => 10,
}
}
}
impl TryFrom<usize> for Stage {
type Error = anyhow::Error;
fn try_from(value: usize) -> anyhow::Result<Self> {
match value {
0 => Ok(Stage::HandshakeC2s),
1 => Ok(Stage::QueryRequestC2s),
2 => Ok(Stage::QueryResponseS2c),
3 => Ok(Stage::QueryPingC2s),
4 => Ok(Stage::QueryPongS2c),
5 => Ok(Stage::LoginHelloC2s),
6 => Ok(Stage::S2cLoginPacket),
7 => Ok(Stage::LoginKeyC2s),
8 => Ok(Stage::LoginSuccessS2c),
9 => Ok(Stage::C2sPlayPacket),
10 => Ok(Stage::S2cPlayPacket),
_ => Err(anyhow::anyhow!("Invalid stage")),
}
}
}
#[derive(Clone)]
pub struct Packet {
pub(crate) id: usize,
pub(crate) direction: PacketDirection,
pub(crate) selected: bool,
pub(crate) compression_threshold: Option<u32>,
pub(crate) packet_data: Vec<u8>,
pub(crate) stage: Stage,
pub(crate) packet_type: i32,
pub(crate) packet_name: String,
pub(crate) created_at: OffsetDateTime,
}
impl Packet {
pub(crate) fn selected(&mut self, value: bool) {
self.selected = value;
}
pub fn get_raw_packet(&self) -> Vec<u8> {
let mut dec = PacketDecoder::new();
dec.set_compression(self.compression_threshold);
dec.queue_slice(&self.packet_data);
match dec.try_next_packet() {
Ok(Some(data)) => data.into(),
Ok(None) => vec![],
Err(e) => {
eprintln!("Error decoding packet: {e:#}");
vec![]
}
}
}
pub fn get_packet_string(&self, formatted: bool) -> String {
let mut dec = PacketDecoder::new();
dec.set_compression(self.compression_threshold);
dec.queue_slice(&self.packet_data);
macro_rules! get {
($packet:ident) => {
match dec.try_next_packet() {
Ok(Some(frame)) => {
if let Ok(pkt) =
<$packet as valence::protocol::Packet>::decode_packet(&mut &frame[..])
{
if formatted {
format!("{pkt:#?}")
} else {
format!("{pkt:?}")
}
} else {
stringify!($packet).into()
}
}
Ok(None) => stringify!($packet).into(),
Err(e) => format!("{e:#}"),
}
};
}
match self.stage {
Stage::HandshakeC2s => get!(HandshakeC2s),
Stage::QueryRequestC2s => get!(QueryRequestC2s),
Stage::QueryResponseS2c => get!(QueryResponseS2c),
Stage::QueryPingC2s => get!(QueryPingC2s),
Stage::QueryPongS2c => get!(QueryPongS2c),
Stage::LoginHelloC2s => get!(LoginHelloC2s),
Stage::S2cLoginPacket => get!(S2cLoginPacket),
Stage::LoginKeyC2s => get!(LoginKeyC2s),
Stage::LoginSuccessS2c => get!(LoginSuccessS2c),
Stage::C2sPlayPacket => get!(C2sPlayPacket),
Stage::S2cPlayPacket => get!(S2cPlayPacket),
}
}
}
pub struct Logger {
pub include_filter: Option<Regex>,
pub exclude_filter: Option<Regex>,
}
pub enum ContextMode {
Gui(egui::Context),
Cli(Logger),
}
pub struct Context {
pub mode: ContextMode,
pub last_packet: AtomicUsize,
pub selected_packet: RwLock<Option<usize>>,
pub(crate) packets: RwLock<Vec<Packet>>,
pub(crate) packet_count: RwLock<usize>,
pub(crate) has_encryption_enabled_error: AtomicBool,
pub filter: RwLock<String>,
pub visible_packets: RwLock<BTreeMap<MetaPacket, bool>>,
c2s_style: Style,
s2c_style: Style,
}
impl Context {
pub fn new(mode: ContextMode) -> Self {
Self {
mode,
last_packet: AtomicUsize::new(0),
selected_packet: RwLock::new(None),
packets: RwLock::new(Vec::new()),
filter: RwLock::new("".into()),
visible_packets: RwLock::new(BTreeMap::new()),
packet_count: RwLock::new(0),
has_encryption_enabled_error: AtomicBool::new(false),
c2s_style: Style::new().green(),
s2c_style: Style::new().purple(),
}
}
pub fn clear(&self) {
self.last_packet.store(0, Ordering::Relaxed);
*self.selected_packet.write().unwrap() = None;
self.packets.write().unwrap().clear();
if let ContextMode::Gui(ctx) = &self.mode {
ctx.request_repaint();
}
}
pub fn add(&self, mut packet: Packet) {
match &self.mode {
ContextMode::Gui(ctx) => {
packet.id = self.last_packet.fetch_add(1, Ordering::Relaxed);
self.packets.write().unwrap().push(packet);
ctx.request_repaint();
}
ContextMode::Cli(logger) => {
if let Some(include_filter) = &logger.include_filter {
if !include_filter.is_match(&packet.packet_name) {
return;
}
}
if let Some(exclude_filter) = &logger.exclude_filter {
if exclude_filter.is_match(&packet.packet_name) {
return;
}
}
let arrow = match &packet.direction {
PacketDirection::ClientToServer => "↑",
PacketDirection::ServerToClient => "↓",
};
if atty::is(atty::Stream::Stdout) {
let style = match &packet.direction {
PacketDirection::ClientToServer => self.c2s_style,
PacketDirection::ServerToClient => self.s2c_style,
};
println!(
"[{}] ({}) {}",
systemtime_strftime(packet.created_at),
arrow.style(style),
packet.get_packet_string(false).style(style)
);
} else {
println!(
"[{}] ({}) {}",
systemtime_strftime(packet.created_at),
arrow,
packet.get_packet_string(false)
);
}
}
}
}
pub fn set_selected_packets(&self, packets: BTreeMap<MetaPacket, bool>) {
*self.visible_packets.write().unwrap() = packets;
}
pub fn is_packet_hidden(&self, index: usize) -> bool {
let packets = self.packets.read().unwrap();
let packet = packets.get(index).expect("Packet not found");
let visible_packets = self.visible_packets.read().unwrap();
let meta_packet: MetaPacket = (*packet).clone().into();
if let Some(visible) = visible_packets.get(&meta_packet) {
if !visible {
return true;
}
}
let filter = self.filter.read().unwrap();
let filter = filter.as_str();
if !filter.is_empty()
&& packet
.packet_name
.to_lowercase()
.contains(&filter.to_lowercase())
{
return true;
}
false
}
pub fn select_previous_packet(&self) {
let mut selected_packet = self.selected_packet.write().unwrap();
if let Some(idx) = *selected_packet {
if idx > 0 {
let mut new_index = idx - 1;
while self.is_packet_hidden(new_index) {
if new_index == 0 {
new_index = idx;
break;
}
new_index -= 1;
}
*selected_packet = Some(new_index);
}
} else {
let packets = self.packets.read().unwrap();
if !packets.is_empty() {
*selected_packet = Some(0);
}
}
}
pub fn select_next_packet(&self) {
let mut selected_packet = self.selected_packet.write().unwrap();
if let Some(idx) = *selected_packet {
if idx < self.packets.read().unwrap().len() - 1 {
let mut new_index = idx + 1;
while self.is_packet_hidden(new_index) {
if new_index == self.packets.read().unwrap().len() - 1 {
new_index = idx;
break;
}
new_index += 1;
}
*selected_packet = Some(new_index);
}
} else {
let packets = self.packets.read().unwrap();
if !packets.is_empty() {
*selected_packet = Some(1);
}
}
}
pub fn set_selected_packet(&self, idx: usize) {
*self.selected_packet.write().unwrap() = Some(idx);
}
pub fn set_filter(&self, filter: String) {
*self.filter.write().expect("Posisoned RwLock") = filter;
*self.selected_packet.write().unwrap() = None;
}
pub fn save(&self, path: PathBuf) -> Result<(), std::io::Error> {
let packets = self
.packets
.read()
.unwrap()
.iter()
.map(|packet| {
format!(
"[{}] {}",
systemtime_strftime(packet.created_at),
packet.get_packet_string(false)
)
})
.collect::<Vec<String>>()
.join("\n");
std::fs::write(path, packets)?;
Ok(())
}
}

45
tools/packet_inspector/src/hex_viewer.rs
View file

@ -1,45 +0,0 @@
use std::io::Read;
use egui::Color32;
pub fn hex_view_ui(ui: &mut egui::Ui, mut file: &[u8]) {
let mut buf = [0u8; 16];
let mut count = 0;
egui::Grid::new("hex_grid")
.spacing([4.0, 1.5])
.striped(true)
.min_col_width(0.0)
.show(ui, |ui| {
ui.label(" ");
for i in 0..16 {
ui.label(format!("{:02X}", i));
}
ui.end_row();
loop {
let bytes_read = file.read(&mut buf).unwrap();
if bytes_read == 0 {
break;
}
ui.label(format!("{:08X}", count));
for b in buf.iter().take(bytes_read) {
ui.colored_label(Color32::from_rgb(255, 255, 255), format!("{:02X}", b));
}
for _ in 0..16 - bytes_read {
ui.label(" ");
}
ui.label(" ");
for b in buf.iter().take(bytes_read) {
if *b >= 0x20 && *b <= 0x7e {
ui.label(format!("{}", *b as char));
} else {
ui.label(".");
}
}
ui.end_row();
count += bytes_read;
}
});
}

188
tools/packet_inspector/src/lib.rs Normal file
View file

@ -0,0 +1,188 @@
mod packet_io;
mod packet_registry;
use std::{net::SocketAddr, sync::OnceLock};
use tokio::net::TcpStream;
use std::sync::Arc;
use tokio::sync::RwLock;
use valence::network::packet::{
HandshakeC2s, HandshakeNextState, LoginCompressionS2c, LoginSuccessS2c,
};
use valence::protocol::{decode::PacketFrame, Decode, Packet as ValencePacket};
use crate::{packet_io::PacketIo, packet_registry::PacketRegistry};
pub use packet_registry::Packet;
pub use crate::packet_registry::PacketSide;
pub use crate::packet_registry::PacketState;
static PACKET_REGISTRY: OnceLock<Arc<RwLock<PacketRegistry>>> = OnceLock::new();
include!(concat!(env!("OUT_DIR"), "/packets.rs"));
pub struct Proxy {
listener_addr: SocketAddr,
server_addr: SocketAddr,
}
impl Proxy {
pub fn new(listener_addr: SocketAddr, server_addr: SocketAddr) -> Self {
PACKET_REGISTRY.get_or_init(|| {
let registry = PacketRegistry::new();
registry.register_all(&STD_PACKETS);
Arc::new(RwLock::new(registry))
});
Proxy {
listener_addr,
server_addr,
}
}
pub async fn subscribe(&self) -> flume::Receiver<Packet> {
PACKET_REGISTRY.get().unwrap().read().await.subscribe()
}
pub async fn run(&self) -> anyhow::Result<()> {
let listener = tokio::net::TcpListener::bind(self.listener_addr).await?;
while let Ok((client, _addr)) = listener.accept().await {
let server_addr = self.server_addr;
tokio::spawn(async move {
let server = TcpStream::connect(server_addr).await?;
if let Err(e) = Self::process(client, server).await {
if !e.to_string().contains("unexpected end of file") {
// bit meh to do it like this but it works
tracing::error!("Error: {:?}", e);
}
}
Ok::<(), anyhow::Error>(())
});
}
Ok(())
}
async fn process(client: TcpStream, server: TcpStream) -> anyhow::Result<()> {
let client = PacketIo::new(client);
let server = PacketIo::new(server);
let (mut client_reader, mut client_writer) = client.split();
let (mut server_reader, mut server_writer) = server.split();
let current_state_inner = Arc::new(RwLock::new(PacketState::Handshaking));
let threshold_inner: Arc<RwLock<Option<u32>>> = Arc::new(RwLock::new(None));
let current_state = current_state_inner.clone();
let threshold = threshold_inner.clone();
let registry = PACKET_REGISTRY.get().unwrap().clone();
let c2s = tokio::spawn(async move {
loop {
let threashold = *threshold.read().await;
client_reader.set_compression(threashold);
server_writer.set_compression(threashold);
// client to server handling
let packet = client_reader.recv_packet_raw().await?;
let state = {
let state = current_state.read().await;
*state
};
let registry = registry.write().await;
registry
.process(
crate::packet_registry::PacketSide::Serverbound,
state,
threashold,
&packet,
)
.await?;
if state == PacketState::Handshaking {
if let Some(handshake) = extrapolate_packet::<HandshakeC2s>(&packet) {
*current_state.write().await = match handshake.next_state {
HandshakeNextState::Status => PacketState::Status,
HandshakeNextState::Login => PacketState::Login,
};
}
}
server_writer.send_packet_raw(&packet).await?;
}
#[allow(unreachable_code)]
Ok::<(), anyhow::Error>(())
});
let current_state = current_state_inner.clone();
let threshold = threshold_inner.clone();
let registry = PACKET_REGISTRY.get().unwrap().clone();
let s2c = tokio::spawn(async move {
loop {
let threashold_value = *threshold.read().await;
server_reader.set_compression(threashold_value);
client_writer.set_compression(threashold_value);
// server to client handling
let packet = server_reader.recv_packet_raw().await?;
let state = {
let state = current_state.read().await;
*state
};
if state == PacketState::Login {
if let Some(compression) = extrapolate_packet::<LoginCompressionS2c>(&packet) {
if compression.threshold.0 >= 0 {
*threshold.write().await = Some(compression.threshold.0 as u32);
}
};
if extrapolate_packet::<LoginSuccessS2c>(&packet).is_some() {
*current_state.write().await = PacketState::Play;
};
}
registry
.write()
.await
.process(
crate::packet_registry::PacketSide::Clientbound,
state,
threashold_value,
&packet,
)
.await?;
client_writer.send_packet_raw(&packet).await?;
}
#[allow(unreachable_code)]
Ok::<(), anyhow::Error>(())
});
// wait for either to finish
tokio::select! {
res = c2s => res?,
res = s2c => res?,
}
}
}
fn extrapolate_packet<'a, P>(packet: &'a PacketFrame) -> Option<P>
where
P: ValencePacket + Decode<'a> + Clone,
{
if packet.id != P::ID {
return None;
}
let mut r = &packet.body[..];
let packet = P::decode(&mut r).ok()?;
Some(packet)
}

965
tools/packet_inspector/src/main.rs
View file

@ -1,957 +1,18 @@
#![doc = include_str!("../README.md")]
#![deny(
rustdoc::broken_intra_doc_links,
rustdoc::private_intra_doc_links,
rustdoc::missing_crate_level_docs,
rustdoc::invalid_codeblock_attributes,
rustdoc::invalid_rust_codeblocks,
rustdoc::bare_urls,
rustdoc::invalid_html_tags
)]
#![warn(
trivial_casts,
trivial_numeric_casts,
unused_lifetimes,
unused_import_braces,
clippy::dbg_macro
#![cfg_attr(
all(not(debug_assertions), feature = "gui"),
windows_subsystem = "windows"
)]
mod config;
mod context;
mod hex_viewer;
pub mod packet_groups;
mod packet_widget;
mod state;
mod syntax_highlighting;
use std::collections::BTreeMap;
use std::net::SocketAddr;
use std::str::FromStr;
use std::sync::atomic::Ordering;
use std::sync::{Arc, RwLock};
use anyhow::bail;
use bytes::BytesMut;
use clap::Parser;
use config::ApplicationConfig;
use context::{Context, Packet};
use egui::{Align2, RichText};
use hex_viewer::hex_view_ui;
use regex::Regex;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use syntax_highlighting::code_view_ui;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::tcp::{OwnedReadHalf, OwnedWriteHalf};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::Semaphore;
use tokio::task::JoinHandle;
use tracing_subscriber::filter::LevelFilter;
use valence::network::packet::{
HandshakeC2s, HandshakeNextState, LoginHelloC2s, LoginKeyC2s, LoginSuccessS2c, QueryPingC2s,
QueryPongS2c, QueryRequestC2s, QueryResponseS2c,
};
use valence::protocol::decode::PacketDecoder;
use valence::protocol::encode::PacketEncoder;
use crate::context::{ContextMode, Stage};
use crate::packet_groups::{C2sPlayPacket, S2cLoginPacket, S2cPlayPacket};
use crate::packet_widget::PacketDirection;
use crate::state::State;
#[derive(Parser, Clone, Debug)]
#[clap(author, version, about)]
struct Cli {
/// The socket address to listen for connections on. This is the address
/// clients should connect to.
#[arg(required_if_eq("nogui", "true"))]
client_addr: Option<SocketAddr>,
/// The socket address the proxy will connect to. This is the address of the
/// server.
#[arg(required_if_eq("nogui", "true"))]
server_addr: Option<SocketAddr>,
/// The maximum number of connections allowed to the proxy. By default,
/// there is no limit.
#[clap(short, long)]
max_connections: Option<usize>,
/// Disable the GUI. Logging to stdout.
#[clap(long)]
nogui: bool,
/// Only show packets that match the filter.
#[clap(short, long)]
include_filter: Option<Regex>,
/// Hide packets that match the filter. Note: Only in effect if nogui is
/// set.
#[clap(short, long)]
exclude_filter: Option<Regex>,
#[cfg(any(
all(not(feature = "gui"), not(feature = "cli")),
all(feature = "gui", feature = "cli")
))]
fn main() {
panic!("Invalid features; select either \"cli\" or \"gui\"");
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
tracing_subscriber::fmt()
.with_max_level(LevelFilter::DEBUG)
.init();
#[cfg(all(not(feature = "cli"), feature = "gui"))]
include!("./main_gui.rs");
let cli = Arc::new(Cli::parse());
match cli.nogui {
true => start_cli(cli).await?,
false => start_gui(cli)?,
};
Ok(())
}
async fn start_cli(cli: Arc<Cli>) -> Result<(), Box<dyn std::error::Error>> {
let context = Arc::new(Context::new(ContextMode::Cli(context::Logger {
include_filter: cli.include_filter.clone(),
exclude_filter: cli.exclude_filter.clone(),
})));
let sema = Arc::new(Semaphore::new(cli.max_connections.unwrap_or(100_000)));
let client_addr = match cli.client_addr {
Some(addr) => addr,
None => return Err("Missing Client Address".into()),
};
let server_addr = match cli.server_addr {
Some(addr) => addr,
None => return Err("Missing Server Address".into()),
};
eprintln!("Waiting for connections on {}", client_addr);
let listen = TcpListener::bind(client_addr).await?;
while let Ok(permit) = sema.clone().acquire_owned().await {
let (client, remote_client_addr) = listen.accept().await?;
eprintln!("Accepted connection to {remote_client_addr}");
if let Err(e) = client.set_nodelay(true) {
eprintln!("Failed to set TCP_NODELAY: {e}");
}
let context = context.clone();
tokio::spawn(async move {
if let Err(e) = handle_connection(client, server_addr, context).await {
eprintln!("Connection to {remote_client_addr} ended with: {e:#}");
} else {
eprintln!("Connection to {remote_client_addr} ended.");
}
drop(permit);
});
}
Ok(())
}
fn start_gui(cli: Arc<Cli>) -> Result<(), Box<dyn std::error::Error>> {
let native_options = eframe::NativeOptions {
initial_window_size: Some(egui::Vec2::new(800.0, 600.0)),
decorated: true,
..Default::default()
};
let server_addr = cli.server_addr;
let client_addr = cli.client_addr;
let max_connections = cli.max_connections.unwrap_or(100_000);
let filter = cli
.include_filter
.clone()
.map(|f| f.to_string())
.unwrap_or("".to_string());
eframe::run_native(
"Valence Packet Inspector",
native_options,
Box::new(move |cc| {
let gui_app = GuiApp::new(cc, filter);
if let Some(server_addr) = server_addr {
if let Some(client_addr) = client_addr {
gui_app.start_listening(client_addr, server_addr, max_connections);
}
}
Box::new(gui_app)
}),
)?;
Ok(())
}
async fn handle_connection(
client: TcpStream,
server_addr: SocketAddr,
context: Arc<Context>,
) -> anyhow::Result<()> {
eprintln!("Connecting to {}", server_addr);
let server = TcpStream::connect(server_addr).await?;
if let Err(e) = server.set_nodelay(true) {
eprintln!("Failed to set TCP_NODELAY: {e}");
}
let (client_read, client_write) = client.into_split();
let (server_read, server_write) = server.into_split();
let mut s2c = State {
enc: PacketEncoder::new(),
dec: PacketDecoder::new(),
read: server_read,
write: client_write,
direction: PacketDirection::ServerToClient,
context: context.clone(),
frame: BytesMut::new(),
};
let mut c2s = State {
enc: PacketEncoder::new(),
dec: PacketDecoder::new(),
read: client_read,
write: server_write,
direction: PacketDirection::ClientToServer,
context: context.clone(),
frame: BytesMut::new(),
};
let handshake: HandshakeC2s = c2s.rw_packet(Stage::HandshakeC2s).await?;
match handshake.next_state {
HandshakeNextState::Status => {
c2s.rw_packet::<QueryRequestC2s>(Stage::QueryRequestC2s)
.await?;
s2c.rw_packet::<QueryResponseS2c>(Stage::QueryResponseS2c)
.await?;
c2s.rw_packet::<QueryPingC2s>(Stage::QueryPingC2s).await?;
s2c.rw_packet::<QueryPongS2c>(Stage::QueryPongS2c).await?;
Ok(())
}
HandshakeNextState::Login => {
c2s.rw_packet::<LoginHelloC2s>(Stage::LoginHelloC2s).await?;
match s2c
.rw_packet::<S2cLoginPacket>(Stage::S2cLoginPacket)
.await?
{
S2cLoginPacket::LoginHelloS2c(_) => {
c2s.rw_packet::<LoginKeyC2s>(Stage::LoginKeyC2s).await?;
eprintln!(
"Encryption is enabled! Packet contents are inaccessible to the proxy. \
Disable online mode to fix this."
);
context
.has_encryption_enabled_error
.store(true, Ordering::Relaxed);
return tokio::select! {
c2s_res = passthrough(c2s.read, c2s.write) => c2s_res,
s2c_res = passthrough(s2c.read, s2c.write) => s2c_res,
};
}
S2cLoginPacket::LoginCompressionS2c(pkt) => {
let threshold = pkt.threshold.0 as u32;
s2c.enc.set_compression(Some(threshold));
s2c.dec.set_compression(Some(threshold));
c2s.enc.set_compression(Some(threshold));
c2s.dec.set_compression(Some(threshold));
s2c.rw_packet::<LoginSuccessS2c>(Stage::LoginSuccessS2c)
.await?;
}
S2cLoginPacket::LoginSuccessS2c(_) => {}
S2cLoginPacket::LoginDisconnectS2c(_) => return Ok(()),
S2cLoginPacket::LoginQueryRequestS2c(_) => {
bail!("Got login plugin request. Don't know how to proceed.")
}
}
let c2s_fut: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
loop {
c2s.rw_packet::<C2sPlayPacket>(Stage::C2sPlayPacket).await?;
}
});
let s2c_fut: JoinHandle<anyhow::Result<()>> = tokio::spawn(async move {
loop {
s2c.rw_packet::<S2cPlayPacket>(Stage::S2cPlayPacket).await?;
}
});
tokio::select! {
c2s = c2s_fut => Ok(c2s??),
s2c = s2c_fut => Ok(s2c??),
}
}
}
}
async fn passthrough(mut read: OwnedReadHalf, mut write: OwnedWriteHalf) -> anyhow::Result<()> {
let mut buf = Box::new([0u8; 8192]);
loop {
let bytes_read = read.read(buf.as_mut_slice()).await?;
let bytes = &mut buf[..bytes_read];
if bytes.is_empty() {
break Ok(());
}
write.write_all(bytes).await?;
}
}
#[derive(Clone)]
pub struct MetaPacket {
id: i32,
stage: Stage,
direction: PacketDirection,
name: String,
}
// manually implement Serialize and Deserialize that use the ToString and
// FromStr implementaions for keys
impl Serialize for MetaPacket {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_str(&self.to_string())
}
}
impl<'de> Deserialize<'de> for MetaPacket {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
MetaPacket::from_str(&s).map_err(serde::de::Error::custom)
}
}
impl From<(Stage, i32, PacketDirection, String)> for MetaPacket {
fn from((stage, id, direction, name): (Stage, i32, PacketDirection, String)) -> Self {
Self {
stage,
id,
direction,
name,
}
}
}
impl From<Packet> for MetaPacket {
fn from(packet: Packet) -> Self {
Self {
stage: packet.stage,
id: packet.packet_type,
direction: packet.direction,
name: packet.packet_name,
}
}
}
// to string and from string to be used in toml
impl ToString for MetaPacket {
fn to_string(&self) -> String {
let stage: usize = self.stage.clone().into();
format!(
"{}:{}:{}:{}",
stage,
self.id,
match self.direction {
PacketDirection::ClientToServer => 0,
PacketDirection::ServerToClient => 1,
},
self.name
)
}
}
impl FromStr for MetaPacket {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let mut split = s.split(':');
let stage = match split.next().unwrap().parse::<usize>() {
Ok(stage) => Stage::try_from(stage)?,
Err(_) => bail!("invalid stage"),
};
let id = split.next().unwrap().parse::<i32>()?;
let direction = match split.next().unwrap().parse::<i32>()? {
0 => PacketDirection::ClientToServer,
1 => PacketDirection::ServerToClient,
_ => bail!("invalid direction"),
};
let name = split.next().unwrap().to_string();
Ok(Self {
stage,
id,
direction,
name,
})
}
}
impl Ord for MetaPacket {
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
#[derive(PartialEq, Eq, PartialOrd, Ord)]
struct OrdMetaPacket {
stage: Stage,
id: i32,
direction: PacketDirection,
}
let left = OrdMetaPacket {
stage: self.stage.clone(),
id: self.id,
direction: self.direction.clone(),
};
let right = OrdMetaPacket {
stage: other.stage.clone(),
id: other.id,
direction: other.direction.clone(),
};
left.cmp(&right)
}
}
impl PartialOrd for MetaPacket {
fn partial_cmp(&self, other: &Self) -> std::option::Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for MetaPacket {
fn eq(&self, other: &Self) -> bool {
self.stage == other.stage && self.id == other.id && self.direction == other.direction
}
}
impl Eq for MetaPacket {}
struct GuiApp {
config: ApplicationConfig,
temp_server_addr: String,
temp_client_addr: String,
temp_max_connections: String,
server_addr_error: bool,
client_addr_error: bool,
max_connections_error: bool,
context: Arc<Context>,
filter: String,
selected_packets: BTreeMap<MetaPacket, bool>,
packet_filter: String,
buffer: String,
is_listening: RwLock<bool>,
window_open: bool,
encryption_error_dialog_open: bool,
config_load_error: Option<String>,
config_load_error_window_open: bool,
raw_packet: Vec<u8>,
view_hex: bool,
}
impl GuiApp {
fn new(cc: &eframe::CreationContext<'_>, filter: String) -> Self {
let ctx = cc.egui_ctx.clone();
let context = Context::new(ContextMode::Gui(ctx));
let mut config_load_error: Option<String> = None;
let mut config = match ApplicationConfig::load() {
Ok(config) => config,
Err(e) => {
config_load_error = Some(format!("Failed to load config:\n{}", e));
ApplicationConfig::default()
}
};
let mut filter = filter;
if filter.is_empty() {
if let Some(c_filter) = config.filter() {
filter = c_filter.to_string();
}
} else {
config.set_filter(Some(filter.clone()));
}
{
let mut f = context.filter.write().expect("Poisoned filter");
*f = filter.clone();
}
let context = Arc::new(context);
let temp_server_addr = config.server_addr().to_string();
let temp_client_addr = config.client_addr().to_string();
let temp_max_connections = match config.max_connections() {
Some(max_connections) => max_connections.to_string(),
None => String::new(),
};
let selected_packets = match config.selected_packets().clone() {
Some(selected_packets) => selected_packets,
None => BTreeMap::new(),
};
context.set_selected_packets(selected_packets.clone());
Self {
config,
context,
filter,
selected_packets,
packet_filter: String::new(),
buffer: String::new(),
is_listening: RwLock::new(false),
window_open: false,
encryption_error_dialog_open: false,
temp_server_addr,
temp_client_addr,
temp_max_connections,
server_addr_error: false,
client_addr_error: false,
max_connections_error: false,
config_load_error,
config_load_error_window_open: false,
raw_packet: Vec::new(),
view_hex: false,
}
}
fn start_listening(
&self,
client_addr: SocketAddr,
server_addr: SocketAddr,
max_connections: usize,
) {
let t_context = self.context.clone();
tokio::spawn(async move {
let sema = Arc::new(Semaphore::new(max_connections));
let listen = TcpListener::bind(client_addr).await?;
eprintln!("Waiting for connections on {}", client_addr);
while let Ok(permit) = sema.clone().acquire_owned().await {
let (client, remote_client_addr) = listen.accept().await?;
eprintln!("Accepted connection to {remote_client_addr}");
if let Err(e) = client.set_nodelay(true) {
eprintln!("Failed to set TCP_NODELAY: {e}");
}
let t2_context = t_context.clone();
tokio::spawn(async move {
if let Err(e) = handle_connection(client, server_addr, t2_context).await {
eprintln!("Connection to {remote_client_addr} ended with: {e:#}");
} else {
eprintln!("Connection to {remote_client_addr} ended.");
}
drop(permit);
});
}
Ok::<(), anyhow::Error>(())
});
*self.is_listening.write().expect("Poisoned is_listening") = true;
}
fn nested_menus(&mut self, ui: &mut egui::Ui) {
let mut changed = false;
self.selected_packets
.iter_mut()
.filter(|(m_packet, _)| {
self.packet_filter.is_empty()
|| m_packet
.name
.to_lowercase()
.contains(&self.packet_filter.to_lowercase())
})
.for_each(|(m_packet, selected)| {
// todo: format, add arrows, etc
if ui.checkbox(selected, m_packet.name.clone()).changed() {
changed = true;
ui.ctx().request_repaint();
}
});
if changed {
self.config
.set_selected_packets(self.selected_packets.clone());
self.context
.set_selected_packets(self.selected_packets.clone());
}
}
}
impl eframe::App for GuiApp {
fn on_close_event(&mut self) -> bool {
match self.config.save() {
Ok(_) => {}
Err(e) => {
eprintln!("Failed to save config: {e}");
}
}
true
}
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
if !*self.is_listening.read().expect("Poisoned is_listening") {
self.window_open = true;
}
if self
.context
.has_encryption_enabled_error
.load(Ordering::Relaxed)
{
self.encryption_error_dialog_open = true;
}
if self.encryption_error_dialog_open {
egui::Window::new("Encryption Error")
.anchor(Align2::CENTER_CENTER, [0.0, 0.0])
.open(&mut self.encryption_error_dialog_open)
.movable(false)
.collapsible(false)
.resizable(false)
.show(ctx, |ui| {
ui.label(
"Encryption is enabled! Packet contents are inaccessible to the proxy. \
Disable online mode to fix this.",
);
});
// it was true, now it's false, the user acknowledged the error, set it to false
if !self.encryption_error_dialog_open {
self.context
.has_encryption_enabled_error
.store(false, Ordering::Relaxed);
}
}
if self.config_load_error.is_some() {
self.config_load_error_window_open = true;
}
if self.config_load_error_window_open {
if let Some(err) = &self.config_load_error {
egui::Window::new("Config Error")
.anchor(Align2::CENTER_CENTER, [0.0, 0.0])
.open(&mut self.config_load_error_window_open)
.movable(false)
.collapsible(false)
.resizable(false)
.show(ctx, |ui| {
ui.label(err);
});
}
if !self.config_load_error_window_open {
self.config_load_error = None;
}
return;
}
if self.window_open {
egui::Window::new("Setup")
.anchor(Align2::CENTER_CENTER, [0.0, 0.0])
.movable(false)
.collapsible(false)
.resizable(false)
.show(ctx, |ui| {
egui::Grid::new("setup_grid")
.num_columns(2)
.spacing([40.0, 4.0])
.striped(true)
.show(ui, |ui| {
ui.label(RichText::new("Server address:").color(
match self.server_addr_error {
true => egui::Color32::RED,
false => egui::Color32::WHITE,
},
));
if ui
.text_edit_singleline(&mut self.temp_server_addr)
.on_hover_text(
"The socket address the proxy will connect to. This is the \
address of the server.",
)
.changed()
{
self.server_addr_error = false;
};
ui.end_row();
ui.label(RichText::new("Client address:").color(
match self.client_addr_error {
true => egui::Color32::RED,
false => egui::Color32::WHITE,
},
));
ui.text_edit_singleline(&mut self.temp_client_addr)
.on_hover_text(
"The socket address to listen for connections on. This is the \
address clients should connect to.",
);
ui.end_row();
ui.label(RichText::new("Max Connections:").color(
match self.max_connections_error {
true => egui::Color32::RED,
false => egui::Color32::WHITE,
},
));
ui.text_edit_singleline(&mut self.temp_max_connections)
.on_hover_text(
"The maximum number of connections allowed to the proxy. By \
default, there is no limit.",
);
ui.end_row();
if ui.button("Start Proxy").clicked() {
self.window_open = false;
}
});
});
if !self.window_open {
let server_addr = self.temp_server_addr.parse::<SocketAddr>().map_err(|_| {
self.server_addr_error = true;
});
let client_addr = self.temp_client_addr.parse::<SocketAddr>().map_err(|_| {
self.client_addr_error = true;
});
let max_connections = if self.temp_max_connections.is_empty() {
Ok(100_000)
} else {
self.temp_max_connections.parse::<usize>().map_err(|_| {
self.max_connections_error = true;
})
};
if server_addr.is_err() || client_addr.is_err() || max_connections.is_err() {
self.window_open = true;
return;
}
self.config.set_server_addr(server_addr.unwrap());
self.config.set_client_addr(client_addr.unwrap());
self.config
.set_max_connections(if self.temp_max_connections.is_empty() {
None
} else {
Some(self.temp_max_connections.parse::<usize>().unwrap())
});
self.start_listening(
client_addr.unwrap(),
server_addr.unwrap(),
max_connections.unwrap(),
);
}
return;
}
egui::TopBottomPanel::top("header").show(ctx, |ui| {
ui.horizontal(|ui| {
ui.label("Filter:");
if ui.text_edit_singleline(&mut self.filter).changed() {
self.context.set_filter(self.filter.clone());
self.config.set_filter(match self.filter.is_empty() {
true => None,
false => Some(self.filter.clone()),
});
}
ui.menu_button("Packets", |ui| {
ui.set_max_width(250.0);
ui.set_max_height(400.0);
ui.text_edit_singleline(&mut self.packet_filter);
egui::ScrollArea::vertical()
.auto_shrink([true, true])
.show(ui, |ui| {
self.nested_menus(ui);
});
});
});
});
egui::SidePanel::left("side_panel")
.min_width(150.0)
.default_width(250.0)
.show(ctx, |ui| {
if ui.input(|i| i.key_pressed(egui::Key::ArrowUp)) {
self.context.select_previous_packet();
}
if ui.input(|i| i.key_pressed(egui::Key::ArrowDown)) {
self.context.select_next_packet();
}
ui.horizontal(|ui| {
ui.heading("Packets");
let count = self.context.packet_count.read().unwrap();
let total = self.context.packets.read().unwrap().len();
let all_selected = self.selected_packets.values().all(|v| *v);
if self.filter.is_empty() && all_selected {
ui.label(format!("({total})"));
} else {
ui.label(format!("({count}/{total})"));
}
if ui.button("Clear").clicked() {
self.context.clear();
self.buffer = String::new();
self.raw_packet = vec![];
}
if ui.button("Export").clicked() {
if let Some(path) = rfd::FileDialog::new()
.add_filter("Text Document", &["txt"])
.save_file()
{
match self.context.save(path) {
Ok(_) => {}
Err(err) => {
eprintln!("Failed to save: {}", err);
}
}
}
}
});
egui::ScrollArea::vertical()
.auto_shrink([false, false])
.stick_to_bottom(true)
.show(ui, |ui| {
let mut f = self.context.packets.write().unwrap();
let f: Vec<&mut Packet> = f
.iter_mut()
.filter(|p| {
let m_packet = MetaPacket {
stage: p.stage.clone(),
id: p.packet_type,
direction: p.direction.clone(),
name: p.packet_name.clone(),
};
if !self.selected_packets.contains_key(&m_packet) {
self.selected_packets.insert(m_packet.clone(), true);
self.config
.set_selected_packets(self.selected_packets.clone());
self.context
.set_selected_packets(self.selected_packets.clone());
} else {
// if it does exist, check if the names are the same, if not
// update the key
let (existing, value) =
self.selected_packets.get_key_value(&m_packet).unwrap();
if existing.name != m_packet.name {
let value = *value; // keep the old value
self.selected_packets.remove(&m_packet);
self.selected_packets.insert(m_packet.clone(), value);
self.config
.set_selected_packets(self.selected_packets.clone());
self.context
.set_selected_packets(self.selected_packets.clone());
}
}
if let Some(selected) = self.selected_packets.get(&m_packet) {
if !*selected {
return false;
}
}
if self.filter.is_empty() {
return true;
}
if p.packet_name
.to_lowercase()
.contains(&self.filter.to_lowercase())
{
return true;
}
false
})
.collect();
*self.context.packet_count.write().unwrap() = f.len();
for packet in f {
{
let selected = self.context.selected_packet.read().unwrap();
if let Some(idx) = *selected {
if idx == packet.id {
packet.selected(true);
self.buffer = packet.get_packet_string(true);
self.raw_packet = packet.get_raw_packet();
} else {
packet.selected(false);
}
} else {
packet.selected(false);
}
}
if ui.add(packet.clone()).clicked() {
self.context.set_selected_packet(packet.id);
}
}
});
});
egui::CentralPanel::default().show(ctx, |ui| {
ui.horizontal(|ui| {
ui.checkbox(&mut self.view_hex, "Hex View");
});
egui::ScrollArea::both()
.auto_shrink([false, false])
.show(ui, |ui| {
if self.view_hex {
hex_view_ui(ui, &self.raw_packet);
} else {
code_view_ui(ui, &self.buffer);
}
});
});
}
}
#[cfg(all(not(feature = "gui"), feature = "cli"))]
include!("./main_cli.rs");

62
tools/packet_inspector/src/main_cli.rs Normal file
View file

@ -0,0 +1,62 @@
use clap::Parser;
use packet_inspector::Packet;
use packet_inspector::Proxy;
use std::net::SocketAddr;
use tracing::Level;
#[derive(Parser, Clone, Debug)]
#[clap(author, version, about)]
struct CliArgs {
/// The socket address to listen for connections on. This is the address clients should connect to
listener_addr: SocketAddr,
/// The socket address the proxy will connect to. This is the address of the server
server_addr: SocketAddr,
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
tracing_subscriber::fmt()
.with_max_level(Level::TRACE)
.init();
let args = CliArgs::parse();
let proxy = Proxy::new(args.listener_addr, args.server_addr);
let receiver = proxy.subscribe().await;
tokio::spawn(async move {
proxy.run().await?;
Ok::<(), anyhow::Error>(())
});
// consumer
tokio::spawn(async move {
while let Ok(packet) = receiver.recv_async().await {
log(&packet);
}
});
tokio::signal::ctrl_c().await.unwrap();
Ok(())
}
fn log(packet: &Packet) {
tracing::debug!(
"{:?} -> [{:?}] 0x{:0>2X} \"{}\" {:?}",
packet.side,
packet.state,
packet.id,
packet.name,
truncated(format!("{:?}", packet.data), 512)
);
}
fn truncated(string: String, max_len: usize) -> String {
if string.len() > max_len {
format!("{}...", &string[..max_len])
} else {
string
}
}

44
tools/packet_inspector/src/main_gui.rs Normal file
View file

@ -0,0 +1,44 @@
mod tri_checkbox;
mod app;
mod shared_state;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let native_options = eframe::NativeOptions {
icon_data: Some(load_icon()),
initial_window_size: Some(egui::Vec2::new(1024.0, 768.0)),
decorated: true,
..Default::default()
};
eframe::run_native(
"Valence Packet Inspector",
native_options,
Box::new(move |cc| {
let gui_app = app::GuiApp::new(cc);
Box::new(gui_app)
}),
)?;
Ok(())
}
fn load_icon() -> eframe::IconData {
let (icon_rgba, icon_width, icon_height) = {
let icon = include_bytes!("../../../assets/logo-256x256.png");
let image = image::load_from_memory(icon)
.expect("Failed to open icon path")
.into_rgba8();
let (width, height) = image.dimensions();
let rgba = image.into_raw();
(rgba, width, height)
};
eframe::IconData {
rgba: icon_rgba,
width: icon_width,
height: icon_height,
}
}

249
tools/packet_inspector/src/packet_groups.rs
View file

@ -1,249 +0,0 @@
use valence::advancement::packet::*;
use valence::client::action::*;
use valence::client::command::*;
use valence::client::custom_payload::*;
use valence::client::hand_swing::*;
use valence::client::interact_block::*;
use valence::client::interact_entity::*;
use valence::client::interact_item::*;
use valence::client::keepalive::*;
use valence::client::movement::*;
use valence::client::packet::structure_block::*;
use valence::client::packet::*;
use valence::client::resource_pack::*;
use valence::client::settings::*;
use valence::client::status::*;
use valence::client::teleport::*;
use valence::client::title::*;
use valence::entity::packet::*;
use valence::instance::packet::*;
use valence::inventory::packet::synchronize_recipes::*;
use valence::inventory::packet::*;
use valence::network::packet::*;
use valence::packet_group;
use valence::particle::*;
use valence::player_list::packet::*;
use valence::protocol::packet::boss_bar::*;
use valence::protocol::packet::chat::*;
use valence::protocol::packet::command::*;
use valence::protocol::packet::map::*;
use valence::protocol::packet::scoreboard::*;
use valence::protocol::packet::sound::*;
use valence::protocol::packet::synchronize_tags::*;
packet_group! {
#[derive(Clone)]
pub C2sHandshakePacket<'a> {
HandshakeC2s<'a>
}
}
packet_group! {
#[derive(Clone)]
pub S2cStatusPacket<'a> {
QueryPongS2c,
QueryResponseS2c<'a>,
}
}
packet_group! {
#[derive(Clone)]
pub C2sStatusPacket {
QueryPingC2s,
QueryRequestC2s,
}
}
packet_group! {
#[derive(Clone)]
pub S2cLoginPacket<'a> {
LoginCompressionS2c,
LoginDisconnectS2c<'a>,
LoginHelloS2c<'a>,
LoginQueryRequestS2c<'a>,
LoginSuccessS2c<'a>,
}
}
packet_group! {
#[derive(Clone)]
pub C2sLoginPacket<'a> {
LoginHelloC2s<'a>,
LoginKeyC2s<'a>,
LoginQueryResponseC2s<'a>,
}
}
packet_group! {
#[derive(Clone)]
pub S2cPlayPacket<'a> {
AdvancementUpdateS2c<'a>,
BlockBreakingProgressS2c,
BlockEntityUpdateS2c<'a>,
BlockEventS2c,
BlockUpdateS2c,
BossBarS2c,
BundleSplitterS2c,
ChatMessageS2c<'a>,
ChatSuggestionsS2c<'a>,
ChunkBiomeDataS2c<'a>,
ChunkDataS2c<'a>,
ChunkDeltaUpdateS2c<'a>,
ChunkLoadDistanceS2c,
ChunkRenderDistanceCenterS2c,
ClearTitleS2c,
CloseScreenS2c,
CommandSuggestionsS2c<'a>,
CommandTreeS2c<'a>,
CooldownUpdateS2c,
CraftFailedResponseS2c<'a>,
CustomPayloadS2c<'a>,
DamageTiltS2c,
DeathMessageS2c<'a>,
DifficultyS2c,
DisconnectS2c<'a>,
EndCombatS2c,
EnterCombatS2c,
EntitiesDestroyS2c<'a>,
EntityAnimationS2c,
EntityAttachS2c,
EntityAttributesS2c<'a>,
EntityDamageS2c,
EntityEquipmentUpdateS2c,
EntityPassengersSetS2c,
EntityPositionS2c,
EntitySetHeadYawS2c,
EntitySpawnS2c,
EntityStatusEffectS2c,
EntityStatusS2c,
EntityTrackerUpdateS2c<'a>,
EntityVelocityUpdateS2c,
ExperienceBarUpdateS2c,
ExperienceOrbSpawnS2c,
ExplosionS2c<'a>,
FeaturesS2c<'a>,
GameJoinS2c<'a>,
GameMessageS2c<'a>,
GameStateChangeS2c,
HealthUpdateS2c,
InventoryS2c<'a>,
ItemPickupAnimationS2c,
KeepAliveS2c,
LightUpdateS2c,
LookAtS2c,
MapUpdateS2c<'a>,
MoveRelativeS2c,
NbtQueryResponseS2c,
OpenHorseScreenS2c,
OpenScreenS2c<'a>,
OpenWrittenBookS2c,
OverlayMessageS2c<'a>,
ParticleS2c<'a>,
PlayerAbilitiesS2c,
PlayerActionResponseS2c,
PlayerListHeaderS2c<'a>,
PlayerListS2c<'a>,
PlayerPositionLookS2c,
PlayerRemoveS2c<'a>,
PlayerRespawnS2c<'a>,
PlayerSpawnPositionS2c,
PlayerSpawnS2c,
PlayPingS2c,
PlaySoundFromEntityS2c,
PlaySoundS2c<'a>,
ProfilelessChatMessageS2c<'a>,
RemoveEntityStatusEffectS2c,
RemoveMessageS2c<'a>,
ResourcePackSendS2c<'a>,
RotateS2c,
RotateAndMoveRelativeS2c,
ScoreboardDisplayS2c<'a>,
ScoreboardObjectiveUpdateS2c<'a>,
ScoreboardPlayerUpdateS2c<'a>,
ScreenHandlerPropertyUpdateS2c,
ScreenHandlerSlotUpdateS2c<'a>,
SelectAdvancementTabS2c<'a>,
ServerMetadataS2c<'a>,
SetCameraEntityS2c,
SetTradeOffersS2c,
SignEditorOpenS2c,
SimulationDistanceS2c,
StatisticsS2c,
StopSoundS2c<'a>,
SubtitleS2c<'a>,
SynchronizeRecipesS2c<'a>,
SynchronizeTagsS2c<'a>,
TeamS2c<'a>,
TitleFadeS2c,
TitleS2c<'a>,
UnloadChunkS2c,
UnlockRecipesS2c<'a>,
UpdateSelectedSlotS2c,
VehicleMoveS2c,
WorldBorderCenterChangedS2c,
WorldBorderInitializeS2c,
WorldBorderInterpolateSizeS2c,
WorldBorderSizeChangedS2c,
WorldBorderWarningBlocksChangedS2c,
WorldBorderWarningTimeChangedS2c,
WorldEventS2c,
WorldTimeUpdateS2c,
}
}
packet_group! {
#[derive(Clone)]
pub C2sPlayPacket<'a> {
AdvancementTabC2s<'a>,
BoatPaddleStateC2s,
BookUpdateC2s<'a>,
ButtonClickC2s,
ChatMessageC2s<'a>,
ClickSlotC2s,
ClientCommandC2s,
ClientSettingsC2s<'a>,
ClientStatusC2s,
CloseHandledScreenC2s,
CommandExecutionC2s<'a>,
CraftRequestC2s<'a>,
CreativeInventoryActionC2s,
CustomPayloadC2s<'a>,
FullC2s,
HandSwingC2s,
JigsawGeneratingC2s,
KeepAliveC2s,
LookAndOnGroundC2s,
MessageAcknowledgmentC2s,
OnGroundOnlyC2s,
PickFromInventoryC2s,
PlayerActionC2s,
PlayerInputC2s,
PlayerInteractBlockC2s,
PlayerInteractEntityC2s,
PlayerInteractItemC2s,
PlayerSessionC2s<'a>,
PlayPongC2s,
PositionAndOnGroundC2s,
QueryBlockNbtC2s,
QueryEntityNbtC2s,
RecipeBookDataC2s<'a>,
RecipeCategoryOptionsC2s,
RenameItemC2s<'a>,
RequestCommandCompletionsC2s<'a>,
ResourcePackStatusC2s,
SelectMerchantTradeC2s,
SpectatorTeleportC2s,
TeleportConfirmC2s,
UpdateBeaconC2s,
UpdateCommandBlockC2s<'a>,
UpdateCommandBlockMinecartC2s<'a>,
UpdateDifficultyC2s,
UpdateDifficultyLockC2s,
UpdateJigsawC2s<'a>,
UpdatePlayerAbilitiesC2s,
UpdateSelectedSlotC2s,
UpdateSignC2s<'a>,
UpdateStructureBlockC2s<'a>,
VehicleMoveC2s,
}
}

195
tools/packet_inspector/src/packet_io.rs Normal file
View file

@ -0,0 +1,195 @@
use anyhow::ensure;
use bytes::BufMut;
use bytes::BytesMut;
use std::io;
use std::io::ErrorKind;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use valence::__private::VarInt;
use valence::protocol::decode::{PacketDecoder, PacketFrame};
use valence::protocol::encode::PacketEncoder;
use valence::protocol::Encode;
use valence::protocol::MAX_PACKET_SIZE;
pub(crate) struct PacketIoReader {
reader: tokio::io::ReadHalf<tokio::net::TcpStream>,
dec: PacketDecoder,
threshold: Option<u32>,
}
impl PacketIoReader {
pub(crate) async fn recv_packet_raw(&mut self) -> anyhow::Result<PacketFrame> {
loop {
if let Some(frame) = self.dec.try_next_packet()? {
// self.logger
// .log("Unknown".to_string(), self.direction.clone(), frame.clone());
return Ok(frame);
}
self.dec.reserve(READ_BUF_SIZE);
let mut buf = self.dec.take_capacity();
if self.reader.read_buf(&mut buf).await? == 0 {
return Err(io::Error::from(ErrorKind::UnexpectedEof).into());
}
// This should always be an O(1) unsplit because we reserved space earlier and
// the call to `read_buf` shouldn't have grown the allocation.
self.dec.queue_bytes(buf);
}
}
#[allow(dead_code)]
pub(crate) fn set_compression(&mut self, threshold: Option<u32>) {
self.threshold = threshold;
self.dec.set_compression(threshold);
}
}
pub(crate) struct PacketIoWriter {
writer: tokio::io::WriteHalf<tokio::net::TcpStream>,
enc: PacketEncoder,
threshold: Option<u32>,
}
impl PacketIoWriter {
/*
No | Packet Length | VarInt | Length of (Data Length) + Compressed length of (Packet ID + Data)
No | Data Length | VarInt | Length of uncompressed (Packet ID + Data) or 0
Yes | Packet ID | VarInt | zlib compressed packet ID (see the sections below)
Yes | Data | Byte Array | zlib compressed packet data (see the sections below)
*/
pub(crate) async fn send_packet_raw(&mut self, frame: &PacketFrame) -> anyhow::Result<()> {
let id_varint = VarInt(frame.id);
let id_buf = varint_to_bytes(id_varint);
let mut uncompressed_packet = BytesMut::new();
uncompressed_packet.extend_from_slice(&id_buf);
uncompressed_packet.extend_from_slice(&frame.body);
let uncompressed_packet_length = uncompressed_packet.len();
let uncompressed_packet_length_varint = VarInt(uncompressed_packet_length as i32);
if let Some(threshold) = self.threshold {
if uncompressed_packet_length > threshold as usize {
use flate2::{bufread::ZlibEncoder, Compression};
use std::io::Read;
let mut z = ZlibEncoder::new(&uncompressed_packet[..], Compression::new(4));
let mut compressed = Vec::new();
let data_len_size = uncompressed_packet_length_varint.written_size();
let packet_len = data_len_size + z.read_to_end(&mut compressed)?;
ensure!(
packet_len <= MAX_PACKET_SIZE as usize,
"packet exceeds maximum length"
);
drop(z);
self.enc
.append_bytes(&varint_to_bytes(VarInt(packet_len as i32)));
self.enc
.append_bytes(&varint_to_bytes(uncompressed_packet_length_varint));
self.enc.append_bytes(&compressed);
let bytes = self.enc.take();
self.writer.write_all(&bytes).await?;
self.writer.flush().await?;
// now we need to compress the packet.
} else {
// no need to compress, but we do need to inject a zero
let empty = VarInt(0);
let data_len_size = empty.written_size();
let packet_len = data_len_size + uncompressed_packet_length;
self.enc
.append_bytes(&varint_to_bytes(VarInt(packet_len as i32)));
self.enc.append_bytes(&varint_to_bytes(empty));
self.enc.append_bytes(&uncompressed_packet);
let bytes = self.enc.take();
self.writer.write_all(&bytes).await?;
self.writer.flush().await?;
}
return Ok(());
}
let length = varint_to_bytes(VarInt(uncompressed_packet_length as i32));
// the frame should be uncompressed at this point.
self.enc.append_bytes(&length);
self.enc.append_bytes(&uncompressed_packet);
let bytes = self.enc.take();
self.writer.write_all(&bytes).await?;
Ok(())
}
#[allow(dead_code)]
pub(crate) fn set_compression(&mut self, threshold: Option<u32>) {
self.threshold = threshold;
self.enc.set_compression(threshold);
}
}
pub(crate) struct PacketIo {
stream: TcpStream,
enc: PacketEncoder,
dec: PacketDecoder,
threshold: Option<u32>,
}
const READ_BUF_SIZE: usize = 1024;
impl PacketIo {
pub(crate) fn new(stream: TcpStream) -> Self {
Self {
stream,
enc: PacketEncoder::new(),
dec: PacketDecoder::new(),
threshold: None,
}
}
pub fn split(self) -> (PacketIoReader, PacketIoWriter) {
let (reader, writer) = tokio::io::split(self.stream);
(
PacketIoReader {
reader,
dec: self.dec,
threshold: self.threshold,
},
PacketIoWriter {
writer,
enc: self.enc,
threshold: self.threshold,
},
)
}
#[allow(dead_code)]
pub(crate) async fn set_compression(&mut self, threshold: Option<u32>) {
self.threshold = threshold;
self.enc.set_compression(threshold);
self.dec.set_compression(threshold);
}
}
pub fn varint_to_bytes(i: VarInt) -> BytesMut {
let mut buf = BytesMut::new();
let mut writer = (&mut buf).writer();
i.encode(&mut writer).unwrap();
buf
}

132
tools/packet_inspector/src/packet_registry.rs Normal file
View file

@ -0,0 +1,132 @@
use std::{
hash::{Hash, Hasher},
sync::RwLock,
};
use bytes::Bytes;
use time::OffsetDateTime;
use valence::protocol::decode::PacketFrame;
pub struct PacketRegistry {
packets: RwLock<Vec<Packet>>,
receiver: flume::Receiver<Packet>,
sender: flume::Sender<Packet>,
}
#[allow(unused)]
impl PacketRegistry {
pub fn new() -> Self {
let (sender, receiver) = flume::unbounded::<Packet>();
Self {
packets: RwLock::new(Vec::new()),
receiver,
sender,
}
}
pub fn subscribe(&self) -> flume::Receiver<Packet> {
self.receiver.clone()
}
pub fn register(&self, packet: Packet) {
self.packets.write().unwrap().push(packet);
}
// register_all(takes an array of packets)
pub fn register_all(&self, packets: &[Packet]) {
self.packets.write().unwrap().extend_from_slice(packets);
}
fn get_specific_packet(&self, side: PacketSide, state: PacketState, packet_id: i32) -> Packet {
let time = match OffsetDateTime::now_local() {
Ok(time) => time,
Err(_) => OffsetDateTime::now_utc(),
};
self.packets
.read()
.unwrap()
.iter()
.find(|packet| packet.id == packet_id && packet.side == side && packet.state == state)
.unwrap_or(&Packet {
side,
state,
id: packet_id,
timestamp: Some(time),
name: "Unknown Packet",
data: None,
})
.clone()
}
pub async fn process(
&self,
side: PacketSide,
state: PacketState,
threshold: Option<u32>,
packet: &PacketFrame,
) -> anyhow::Result<()> {
let mut p = self.get_specific_packet(side, state, packet.id);
let time = match OffsetDateTime::now_local() {
Ok(time) => time,
Err(_) => OffsetDateTime::now_utc(),
};
p.data = Some(packet.body.clone().freeze());
p.timestamp = Some(time);
// store in received_packets
self.sender.send_async(p).await?;
Ok(())
}
}
#[derive(Clone, Debug, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Packet {
pub side: PacketSide,
pub state: PacketState,
pub id: i32,
#[cfg_attr(feature = "serde", serde[skip])]
pub timestamp: Option<OffsetDateTime>,
#[cfg_attr(feature = "serde", serde[skip])]
pub name: &'static str,
/// Uncompressed packet data
#[cfg_attr(feature = "serde", serde[skip])]
pub data: Option<Bytes>,
}
impl PartialEq for Packet {
fn eq(&self, other: &Self) -> bool {
self.side == other.side
&& self.state == other.state
&& self.id == other.id
&& self.data == other.data
}
}
impl Hash for Packet {
fn hash<H: Hasher>(&self, state: &mut H) {
self.id.hash(state);
self.side.hash(state);
self.state.hash(state);
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub enum PacketState {
Handshaking,
Status,
Login,
Play,
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
pub enum PacketSide {
Clientbound,
Serverbound,
}

156
tools/packet_inspector/src/packet_widget.rs
View file

@ -1,156 +0,0 @@
use eframe::epaint::{PathShape, RectShape};
use egui::{
Color32, Pos2, Rect, Response, Rgba, Rounding, Sense, Shape, Stroke, TextStyle, Ui, Vec2,
Widget, WidgetText,
};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use crate::context::Packet;
pub fn systemtime_strftime(odt: OffsetDateTime) -> String {
let hour = odt.hour();
let minute = odt.minute();
let second = odt.second();
let millis = odt.millisecond();
format!("{hour:0>2}:{minute:0>2}:{second:0>2}.{millis:0>4}")
}
#[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Serialize, Deserialize)]
pub enum PacketDirection {
ClientToServer,
ServerToClient,
}
impl PacketDirection {
fn get_shape(&self, outer_rect: &Rect) -> PathShape {
let rect = Rect::from_min_size(
Pos2 {
x: outer_rect.left() + 6.0,
y: outer_rect.top() + 8.0,
},
Vec2 { x: 8.0, y: 8.0 },
);
let color = match self {
PacketDirection::ServerToClient => Rgba::from_rgb(255.0, 0.0, 0.0),
PacketDirection::ClientToServer => Rgba::from_rgb(0.0, 255.0, 0.0),
};
let points = match self {
PacketDirection::ServerToClient => vec![
Pos2 {
x: rect.left() + (rect.width() / 2.0),
y: rect.top() + rect.height(),
},
Pos2 {
x: rect.left() + 0.0,
y: rect.top(),
},
Pos2 {
x: rect.left() + rect.width(),
y: rect.top(),
},
],
PacketDirection::ClientToServer => vec![
Pos2 {
x: rect.left() + (rect.width() / 2.0),
y: rect.top() + 0.0,
},
Pos2 {
x: rect.left() + 0.0,
y: rect.top() + rect.height(),
},
Pos2 {
x: rect.left() + rect.width(),
y: rect.top() + rect.height(),
},
],
};
let mut shape = PathShape::closed_line(points, Stroke::new(2.0, color));
shape.fill = color.into();
shape
}
}
impl Widget for Packet {
fn ui(self, ui: &mut Ui) -> Response {
let (mut rect, response) = ui.allocate_at_least(
Vec2 {
x: ui.available_width(),
y: 24.0,
},
Sense::click(),
);
let fill = match self.selected {
true => Rgba::from_rgba_premultiplied(0.3, 0.3, 0.3, 0.4),
false => Rgba::from_rgba_premultiplied(0.0, 0.0, 0.0, 0.0),
};
let text_color: Color32 = match self.selected {
true => Rgba::from_rgba_premultiplied(0.0, 0.0, 0.0, 1.0).into(),
false => ui.visuals().strong_text_color(),
};
if ui.is_rect_visible(rect) {
ui.painter().add(Shape::Rect(RectShape {
rect,
rounding: Rounding::none(),
fill: fill.into(),
stroke: Stroke::new(1.0, Rgba::BLACK),
}));
let shape = self.direction.get_shape(&rect);
ui.painter().add(Shape::Path(shape));
let identifier: WidgetText = format!("0x{:0>2X?}", self.packet_type).into();
let identifier =
identifier.into_galley(ui, Some(false), rect.width() - 21.0, TextStyle::Button);
let label: WidgetText = self.packet_name.into();
let label = label.into_galley(ui, Some(false), rect.width() - 60.0, TextStyle::Button);
let timestamp: WidgetText = systemtime_strftime(self.created_at).into();
let timestamp =
timestamp.into_galley(ui, Some(false), rect.width() - 60.0, TextStyle::Button);
identifier.paint_with_fallback_color(
ui.painter(),
Pos2 {
x: rect.left() + 21.0,
y: rect.top() + 6.0,
},
ui.visuals().weak_text_color(),
);
rect.set_width(rect.width() - 5.0);
let label_width = label.size().x + 50.0;
label.paint_with_fallback_color(
&ui.painter().with_clip_rect(rect),
Pos2 {
x: rect.left() + 55.0,
y: rect.top() + 6.0,
},
text_color,
);
timestamp.paint_with_fallback_color(
&ui.painter().with_clip_rect(rect),
Pos2 {
x: rect.left() + label_width + 8.0,
y: rect.top() + 6.0,
},
ui.visuals().weak_text_color(),
);
}
response
}
}

132
tools/packet_inspector/src/shared_state.rs Normal file
View file

@ -0,0 +1,132 @@
#![allow(clippy::mutable_key_type)]
use egui::Context;
use packet_inspector::Packet;
use std::{collections::HashMap, sync::RwLock};
#[derive(serde::Deserialize, serde::Serialize)]
pub struct PacketFilter {
inner: HashMap<Packet, bool>,
}
impl PacketFilter {
pub fn new() -> Self {
let mut inner = HashMap::new();
for p in packet_inspector::STD_PACKETS.iter() {
inner.insert(p.clone(), true);
}
Self { inner }
}
pub fn get(&self, packet: &Packet) -> Option<bool> {
self.inner
.iter()
.find(|(k, _)| k.id == packet.id && k.side == packet.side && k.state == packet.state)
.map(|(_, v)| v)
.copied()
}
pub fn insert(&mut self, packet: Packet, value: bool) {
self.inner.insert(packet, value);
}
pub fn iter(&self) -> impl Iterator<Item = (&Packet, &bool)> {
self.inner.iter()
}
pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Packet, &mut bool)> {
self.inner.iter_mut()
}
}
pub enum Event {
StartListening,
StopListening,
PacketReceived,
}
#[derive(serde::Deserialize, serde::Serialize)]
pub struct SharedState {
pub listener_addr: String,
pub server_addr: String,
pub autostart: bool,
pub packet_filter: PacketFilter,
pub packet_search: String,
#[serde(skip)]
pub is_listening: bool,
#[serde(skip)]
pub selected_packet: Option<usize>,
#[serde(skip)]
pub update_scroll: bool,
#[serde(skip)]
pub packets: RwLock<Vec<Packet>>,
#[serde(skip)]
pub(super) receiver: Option<flume::Receiver<Event>>,
#[serde(skip)]
sender: Option<flume::Sender<Event>>,
#[serde(skip)]
pub ctx: Option<Context>,
}
impl Default for SharedState {
fn default() -> Self {
let (sender, receiver) = flume::unbounded();
Self {
listener_addr: "127.0.0.1:25566".to_string(),
server_addr: "127.0.0.1:25565".to_string(),
autostart: false,
is_listening: false,
packet_search: String::new(),
packet_filter: PacketFilter::new(),
selected_packet: None,
update_scroll: false,
packets: RwLock::new(Vec::new()),
receiver: Some(receiver),
sender: Some(sender),
ctx: None,
}
}
}
#[allow(unused)]
impl SharedState {
pub fn new(ctx: Context) -> Self {
Self {
ctx: Some(ctx),
..Self::default()
}
}
pub(super) fn merge(mut self, other: Self) -> Self {
self.ctx = other.ctx;
self.sender = other.sender;
self.receiver = other.receiver;
// make a backup of self.packet_filter
let mut packet_filter = PacketFilter::new();
// iterate over packet_inspector::STD_PACKETS
for p in packet_inspector::STD_PACKETS.iter() {
// if the packet is in the current packet_filter
if let Some(v) = self.packet_filter.get(p) {
// insert it into packet_filter
packet_filter.insert(p.clone(), v);
} else {
// otherwise insert it into packet_filter with a default value of true
packet_filter.insert(p.clone(), true);
}
}
self.packet_filter = packet_filter;
self
}
pub fn send_event(&self, event: Event) {
if let Some(sender) = &self.sender {
sender.send(event);
}
}
}

71
tools/packet_inspector/src/state.rs
View file

@ -1,71 +0,0 @@
use std::io::ErrorKind;
use std::sync::Arc;
use bytes::BytesMut;
use time::OffsetDateTime;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::tcp::{OwnedReadHalf, OwnedWriteHalf};
use valence::protocol::decode::{decode_packet, PacketDecoder};
use valence::protocol::encode::PacketEncoder;
use valence::protocol::Packet as ValencePacket;
use crate::context::{Context, Packet, Stage};
use crate::packet_widget::PacketDirection;
pub struct State {
pub direction: PacketDirection,
pub context: Arc<Context>,
pub enc: PacketEncoder,
pub dec: PacketDecoder,
pub frame: BytesMut,
pub read: OwnedReadHalf,
pub write: OwnedWriteHalf,
}
impl State {
pub async fn rw_packet<'a, P>(&'a mut self, stage: Stage) -> anyhow::Result<P>
where
P: ValencePacket<'a>,
{
loop {
if let Some(frame) = self.dec.try_next_packet()? {
self.frame = frame;
let pkt: P = decode_packet(&self.frame)?;
self.enc.append_packet(&pkt)?;
let bytes = self.enc.take();
self.write.write_all(&bytes).await?;
let time = match OffsetDateTime::now_local() {
Ok(time) => time,
Err(_) => OffsetDateTime::now_utc(),
};
self.context.add(Packet {
id: 0, // updated when added to context
direction: self.direction.clone(),
compression_threshold: self.dec.compression(),
packet_data: bytes.to_vec(),
stage,
created_at: time,
selected: false,
packet_type: pkt.packet_id(),
packet_name: pkt.packet_name().to_string(),
});
return Ok(pkt);
}
self.dec.reserve(4096);
let mut buf = self.dec.take_capacity();
if self.read.read_buf(&mut buf).await? == 0 {
return Err(std::io::Error::from(ErrorKind::UnexpectedEof).into());
}
self.dec.queue_bytes(buf);
}
}
}

513
tools/packet_inspector/src/syntax_highlighting.rs
View file

@ -1,513 +0,0 @@
// From: https://github.com/emilk/egui/blob/master/crates/egui_demo_lib/src/syntax_highlighting.rs
use egui::text::LayoutJob;
/// View some code with syntax highlighting and selection.
pub fn code_view_ui(ui: &mut egui::Ui, mut code: &str) {
let language = "rs";
let theme = CodeTheme::from_memory(ui.ctx());
let mut layouter = |ui: &egui::Ui, string: &str, wrap_width: f32| {
let mut layout_job = highlight(ui.ctx(), &theme, string, language);
layout_job.wrap.max_width = wrap_width; // no wrapping
ui.fonts(|f| f.layout_job(layout_job))
};
ui.add(
egui::TextEdit::multiline(&mut code)
.font(egui::TextStyle::Monospace) // for cursor height
.code_editor()
.desired_width(ui.available_width())
.desired_rows(24)
.lock_focus(true)
.layouter(&mut layouter),
);
}
/// Memoized Code highlighting
pub fn highlight(ctx: &egui::Context, theme: &CodeTheme, code: &str, language: &str) -> LayoutJob {
impl egui::util::cache::ComputerMut<(&CodeTheme, &str, &str), LayoutJob> for Highlighter {
fn compute(&mut self, (theme, code, lang): (&CodeTheme, &str, &str)) -> LayoutJob {
self.highlight(theme, code, lang)
}
}
type HighlightCache = egui::util::cache::FrameCache<LayoutJob, Highlighter>;
ctx.memory_mut(|mem| {
mem.caches
.cache::<HighlightCache>()
.get((theme, code, language))
})
}
// ----------------------------------------------------------------------------
#[cfg(not(feature = "syntect"))]
#[derive(Clone, Copy, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(enum_map::Enum)]
enum TokenType {
Comment,
Keyword,
Literal,
StringLiteral,
Punctuation,
Whitespace,
}
#[cfg(feature = "syntect")]
#[derive(Clone, Copy, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[allow(unused)]
enum SyntectTheme {
Base16EightiesDark,
Base16MochaDark,
Base16OceanDark,
Base16OceanLight,
InspiredGitHub,
SolarizedDark,
SolarizedLight,
}
#[allow(unused)]
#[cfg(feature = "syntect")]
impl SyntectTheme {
fn all() -> impl ExactSizeIterator<Item = Self> {
[
Self::Base16EightiesDark,
Self::Base16MochaDark,
Self::Base16OceanDark,
Self::Base16OceanLight,
Self::InspiredGitHub,
Self::SolarizedDark,
Self::SolarizedLight,
]
.iter()
.copied()
}
fn name(&self) -> &'static str {
match self {
Self::Base16EightiesDark => "Base16 Eighties (dark)",
Self::Base16MochaDark => "Base16 Mocha (dark)",
Self::Base16OceanDark => "Base16 Ocean (dark)",
Self::Base16OceanLight => "Base16 Ocean (light)",
Self::InspiredGitHub => "InspiredGitHub (light)",
Self::SolarizedDark => "Solarized (dark)",
Self::SolarizedLight => "Solarized (light)",
}
}
fn syntect_key_name(&self) -> &'static str {
match self {
Self::Base16EightiesDark => "base16-eighties.dark",
Self::Base16MochaDark => "base16-mocha.dark",
Self::Base16OceanDark => "base16-ocean.dark",
Self::Base16OceanLight => "base16-ocean.light",
Self::InspiredGitHub => "InspiredGitHub",
Self::SolarizedDark => "Solarized (dark)",
Self::SolarizedLight => "Solarized (light)",
}
}
pub fn is_dark(&self) -> bool {
match self {
Self::Base16EightiesDark
| Self::Base16MochaDark
| Self::Base16OceanDark
| Self::SolarizedDark => true,
Self::Base16OceanLight | Self::InspiredGitHub | Self::SolarizedLight => false,
}
}
}
#[derive(Clone, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "serde", serde(default))]
pub struct CodeTheme {
dark_mode: bool,
#[cfg(feature = "syntect")]
syntect_theme: SyntectTheme,
#[cfg(not(feature = "syntect"))]
formats: enum_map::EnumMap<TokenType, egui::TextFormat>,
}
impl Default for CodeTheme {
fn default() -> Self {
Self::dark()
}
}
#[allow(unused)]
impl CodeTheme {
pub fn from_style(style: &egui::Style) -> Self {
if style.visuals.dark_mode {
Self::dark()
} else {
Self::light()
}
}
pub fn from_memory(ctx: &egui::Context) -> Self {
if ctx.style().visuals.dark_mode {
ctx.data_mut(|d| {
d.get_persisted(egui::Id::new("dark"))
.unwrap_or_else(CodeTheme::dark)
})
} else {
ctx.data_mut(|d| {
d.get_persisted(egui::Id::new("light"))
.unwrap_or_else(CodeTheme::light)
})
}
}
pub fn store_in_memory(self, ctx: &egui::Context) {
if self.dark_mode {
ctx.data_mut(|d| d.insert_persisted(egui::Id::new("dark"), self));
} else {
ctx.data_mut(|d| d.insert_persisted(egui::Id::new("light"), self));
}
}
}
#[allow(unused)]
#[cfg(feature = "syntect")]
impl CodeTheme {
pub fn dark() -> Self {
Self {
dark_mode: true,
syntect_theme: SyntectTheme::SolarizedDark,
}
}
pub fn light() -> Self {
Self {
dark_mode: false,
syntect_theme: SyntectTheme::SolarizedLight,
}
}
pub fn ui(&mut self, ui: &mut egui::Ui) {
egui::widgets::global_dark_light_mode_buttons(ui);
for theme in SyntectTheme::all() {
if theme.is_dark() == self.dark_mode {
ui.radio_value(&mut self.syntect_theme, theme, theme.name());
}
}
}
}
#[cfg(not(feature = "syntect"))]
impl CodeTheme {
pub fn dark() -> Self {
let font_id = egui::FontId::monospace(10.0);
use egui::{Color32, TextFormat};
Self {
dark_mode: true,
formats: enum_map::enum_map![
TokenType::Comment => TextFormat::simple(font_id.clone(), Color32::from_gray(120)),
TokenType::Keyword => TextFormat::simple(font_id.clone(), Color32::from_rgb(255, 100, 100)),
TokenType::Literal => TextFormat::simple(font_id.clone(), Color32::from_rgb(87, 165, 171)),
TokenType::StringLiteral => TextFormat::simple(font_id.clone(), Color32::from_rgb(109, 147, 226)),
TokenType::Punctuation => TextFormat::simple(font_id.clone(), Color32::LIGHT_GRAY),
TokenType::Whitespace => TextFormat::simple(font_id.clone(), Color32::TRANSPARENT),
],
}
}
pub fn light() -> Self {
let font_id = egui::FontId::monospace(10.0);
use egui::{Color32, TextFormat};
Self {
dark_mode: false,
#[cfg(not(feature = "syntect"))]
formats: enum_map::enum_map![
TokenType::Comment => TextFormat::simple(font_id.clone(), Color32::GRAY),
TokenType::Keyword => TextFormat::simple(font_id.clone(), Color32::from_rgb(235, 0, 0)),
TokenType::Literal => TextFormat::simple(font_id.clone(), Color32::from_rgb(153, 134, 255)),
TokenType::StringLiteral => TextFormat::simple(font_id.clone(), Color32::from_rgb(37, 203, 105)),
TokenType::Punctuation => TextFormat::simple(font_id.clone(), Color32::DARK_GRAY),
TokenType::Whitespace => TextFormat::simple(font_id.clone(), Color32::TRANSPARENT),
],
}
}
pub fn ui(&mut self, ui: &mut egui::Ui) {
ui.horizontal_top(|ui| {
let selected_id = egui::Id::null();
let mut selected_tt: TokenType =
ui.data_mut(|d| *d.get_persisted_mut_or(selected_id, TokenType::Comment));
ui.vertical(|ui| {
ui.set_width(150.0);
egui::widgets::global_dark_light_mode_buttons(ui);
ui.add_space(8.0);
ui.separator();
ui.add_space(8.0);
ui.scope(|ui| {
for (tt, tt_name) in [
(TokenType::Comment, "// comment"),
(TokenType::Keyword, "keyword"),
(TokenType::Literal, "literal"),
(TokenType::StringLiteral, "\"string literal\""),
(TokenType::Punctuation, "punctuation ;"),
// (TokenType::Whitespace, "whitespace"),
] {
let format = &mut self.formats[tt];
ui.style_mut().override_font_id = Some(format.font_id.clone());
ui.visuals_mut().override_text_color = Some(format.color);
ui.radio_value(&mut selected_tt, tt, tt_name);
}
});
let reset_value = if self.dark_mode {
CodeTheme::dark()
} else {
CodeTheme::light()
};
if ui
.add_enabled(*self != reset_value, egui::Button::new("Reset theme"))
.clicked()
{
*self = reset_value;
}
});
ui.add_space(16.0);
ui.data_mut(|d| d.insert_persisted(selected_id, selected_tt));
egui::Frame::group(ui.style())
.inner_margin(egui::Vec2::splat(2.0))
.show(ui, |ui| {
// ui.group(|ui| {
ui.style_mut().override_text_style = Some(egui::TextStyle::Small);
ui.spacing_mut().slider_width = 128.0; // Controls color picker size
egui::widgets::color_picker::color_picker_color32(
ui,
&mut self.formats[selected_tt].color,
egui::color_picker::Alpha::Opaque,
);
});
});
}
}
// ----------------------------------------------------------------------------
#[cfg(feature = "syntect")]
struct Highlighter {
ps: syntect::parsing::SyntaxSet,
ts: syntect::highlighting::ThemeSet,
}
#[cfg(feature = "syntect")]
impl Default for Highlighter {
fn default() -> Self {
Self {
ps: syntect::parsing::SyntaxSet::load_defaults_newlines(),
ts: syntect::highlighting::ThemeSet::load_defaults(),
}
}
}
#[cfg(feature = "syntect")]
impl Highlighter {
#[allow(clippy::unused_self, clippy::unnecessary_wraps)]
fn highlight(&self, theme: &CodeTheme, code: &str, lang: &str) -> LayoutJob {
self.highlight_impl(theme, code, lang).unwrap_or_else(|| {
// Fallback:
LayoutJob::simple(
code.into(),
egui::FontId::monospace(12.0),
if theme.dark_mode {
egui::Color32::LIGHT_GRAY
} else {
egui::Color32::DARK_GRAY
},
f32::INFINITY,
)
})
}
fn highlight_impl(&self, theme: &CodeTheme, text: &str, language: &str) -> Option<LayoutJob> {
use syntect::easy::HighlightLines;
use syntect::highlighting::FontStyle;
use syntect::util::LinesWithEndings;
let syntax = self
.ps
.find_syntax_by_name(language)
.or_else(|| self.ps.find_syntax_by_extension(language))?;
let theme = theme.syntect_theme.syntect_key_name();
let mut h = HighlightLines::new(syntax, &self.ts.themes[theme]);
use egui::text::{LayoutSection, TextFormat};
let mut job = LayoutJob {
text: text.into(),
..Default::default()
};
for line in LinesWithEndings::from(text) {
for (style, range) in h.highlight_line(line, &self.ps).ok()? {
let fg = style.foreground;
let text_color = egui::Color32::from_rgb(fg.r, fg.g, fg.b);
let italics = style.font_style.contains(FontStyle::ITALIC);
let underline = style.font_style.contains(FontStyle::ITALIC);
let underline = if underline {
egui::Stroke::new(1.0, text_color)
} else {
egui::Stroke::NONE
};
job.sections.push(LayoutSection {
leading_space: 0.0,
byte_range: as_byte_range(text, range),
format: TextFormat {
font_id: egui::FontId::monospace(12.0),
color: text_color,
italics,
underline,
..Default::default()
},
});
}
}
Some(job)
}
}
#[cfg(feature = "syntect")]
fn as_byte_range(whole: &str, range: &str) -> std::ops::Range<usize> {
let whole_start = whole.as_ptr() as usize;
let range_start = range.as_ptr() as usize;
assert!(whole_start <= range_start);
assert!(range_start + range.len() <= whole_start + whole.len());
let offset = range_start - whole_start;
offset..(offset + range.len())
}
// ----------------------------------------------------------------------------
#[cfg(not(feature = "syntect"))]
#[derive(Default)]
struct Highlighter {}
#[cfg(not(feature = "syntect"))]
impl Highlighter {
#[allow(clippy::unused_self, clippy::unnecessary_wraps)]
fn highlight(&self, theme: &CodeTheme, mut text: &str, _language: &str) -> LayoutJob {
// Extremely simple syntax highlighter for when we compile without syntect
let mut job = LayoutJob::default();
while !text.is_empty() {
if text.starts_with("//") {
let end = text.find('\n').unwrap_or(text.len());
job.append(&text[..end], 0.0, theme.formats[TokenType::Comment].clone());
text = &text[end..];
} else if text.starts_with('"') {
let end = text[1..]
.find('"')
.map(|i| i + 2)
.or_else(|| text.find('\n'))
.unwrap_or(text.len());
job.append(
&text[..end],
0.0,
theme.formats[TokenType::StringLiteral].clone(),
);
text = &text[end..];
} else if text.starts_with(|c: char| c.is_ascii_alphanumeric()) {
let end = text[1..]
.find(|c: char| !c.is_ascii_alphanumeric())
.map_or_else(|| text.len(), |i| i + 1);
let word = &text[..end];
let tt = if is_keyword(word) {
TokenType::Keyword
} else {
TokenType::Literal
};
job.append(word, 0.0, theme.formats[tt].clone());
text = &text[end..];
} else if text.starts_with(|c: char| c.is_ascii_whitespace()) {
let end = text[1..]
.find(|c: char| !c.is_ascii_whitespace())
.map_or_else(|| text.len(), |i| i + 1);
job.append(
&text[..end],
0.0,
theme.formats[TokenType::Whitespace].clone(),
);
text = &text[end..];
} else {
let mut it = text.char_indices();
it.next();
let end = it.next().map_or(text.len(), |(idx, _chr)| idx);
job.append(
&text[..end],
0.0,
theme.formats[TokenType::Punctuation].clone(),
);
text = &text[end..];
}
}
job
}
}
#[cfg(not(feature = "syntect"))]
fn is_keyword(word: &str) -> bool {
matches!(
word,
"as" | "async"
| "await"
| "break"
| "const"
| "continue"
| "crate"
| "dyn"
| "else"
| "enum"
| "extern"
| "false"
| "fn"
| "for"
| "if"
| "impl"
| "in"
| "let"
| "loop"
| "match"
| "mod"
| "move"
| "mut"
| "pub"
| "ref"
| "return"
| "self"
| "Self"
| "static"
| "struct"
| "super"
| "trait"
| "true"
| "type"
| "unsafe"
| "use"
| "where"
| "while"
)
}

133
tools/packet_inspector/src/tri_checkbox.rs Normal file
View file

@ -0,0 +1,133 @@
use egui::{
epaint, pos2, vec2, NumExt, Response, Sense, Shape, TextStyle, Ui, Vec2, Widget, WidgetInfo,
WidgetText, WidgetType,
};
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TriCheckboxState {
Enabled,
Partial,
Disabled,
}
// TODO(emilk): allow checkbox without a text label
/// Boolean on/off control with text label.
///
/// Usually you'd use [`Ui::checkbox`] instead.
///
/// ```
/// # egui::__run_test_ui(|ui| {
/// # let mut my_bool = true;
/// // These are equivalent:
/// ui.checkbox(&mut my_bool, "Checked");
/// ui.add(egui::Checkbox::new(&mut my_bool, "Checked"));
/// # });
/// ```
#[must_use = "You should put this widget in an ui with `ui.add(widget);`"]
pub struct TriCheckbox<'a> {
checked: &'a mut TriCheckboxState,
text: WidgetText,
}
#[allow(unused)]
impl<'a> TriCheckbox<'a> {
pub fn new(checked: &'a mut TriCheckboxState, text: impl Into<WidgetText>) -> Self {
TriCheckbox {
checked,
text: text.into(),
}
}
pub fn without_text(checked: &'a mut TriCheckboxState) -> Self {
Self::new(checked, WidgetText::default())
}
}
impl<'a> Widget for TriCheckbox<'a> {
fn ui(self, ui: &mut Ui) -> Response {
let TriCheckbox { checked, text } = self;
let spacing = &ui.spacing();
let icon_width = spacing.icon_width;
let icon_spacing = spacing.icon_spacing;
let (text, mut desired_size) = if text.is_empty() {
(None, vec2(icon_width, 0.0))
} else {
let total_extra = vec2(icon_width + icon_spacing, 0.0);
let wrap_width = ui.available_width() - total_extra.x;
let text = text.into_galley(ui, None, wrap_width, TextStyle::Button);
let mut desired_size = total_extra + text.size();
desired_size = desired_size.at_least(spacing.interact_size);
(Some(text), desired_size)
};
desired_size = desired_size.at_least(Vec2::splat(spacing.interact_size.y));
desired_size.y = desired_size.y.max(icon_width);
let (rect, mut response) = ui.allocate_exact_size(desired_size, Sense::click());
if response.clicked() {
*checked = match *checked {
TriCheckboxState::Partial | TriCheckboxState::Disabled => TriCheckboxState::Enabled,
TriCheckboxState::Enabled => TriCheckboxState::Disabled,
};
response.mark_changed();
}
response.widget_info(|| {
WidgetInfo::selected(
WidgetType::Checkbox,
*checked == TriCheckboxState::Enabled,
text.as_ref().map_or("", |x| x.text()),
)
});
if ui.is_rect_visible(rect) {
// let visuals = ui.style().interact_selectable(&response, *checked); // too colorful
let visuals = ui.style().interact(&response);
let (small_icon_rect, big_icon_rect) = ui.spacing().icon_rectangles(rect);
ui.painter().add(epaint::RectShape {
rect: big_icon_rect.expand(visuals.expansion),
rounding: visuals.rounding,
fill: visuals.bg_fill,
stroke: visuals.bg_stroke,
});
match *checked {
TriCheckboxState::Enabled => {
// Check mark:
ui.painter().add(Shape::line(
vec![
pos2(small_icon_rect.left(), small_icon_rect.center().y),
pos2(small_icon_rect.center().x, small_icon_rect.bottom()),
pos2(small_icon_rect.right(), small_icon_rect.top()),
],
visuals.fg_stroke,
));
}
TriCheckboxState::Partial => {
// Minus sign:
ui.painter().add(Shape::line(
vec![
pos2(small_icon_rect.left(), small_icon_rect.center().y),
pos2(small_icon_rect.right(), small_icon_rect.center().y),
],
visuals.fg_stroke,
));
}
_ => {}
}
if let Some(text) = text {
let text_pos = pos2(
rect.min.x + icon_width + icon_spacing,
rect.center().y - 0.5 * text.size().y,
);
text.paint_with_visuals(ui.painter(), text_pos, visuals);
}
}
response
}
}