perf(scanner)!: improve RAM performance from 16 bytes per IP to 4 bytes per IP

Author: Cyberdolfi

src/minecraft/join.rs

@@ -1,3 +1,4 @@
+use std::net::Ipv4Addr;
 use std::time::Duration;
 use tokio::net::TcpStream;
 use tokio::io::AsyncWriteExt;
@@ -8,17 +9,17 @@ use crate::minecraft::utils::{Handshake, write_varint, read_varint, prepend_leng
 // TODO: Make this work
 //  It have every time the same error:
 //  [20:13:41 INFO]: /[0:0:0:0:0:0:0:1]:58067 lost connection: Internal Exception: io.netty.handler.codec.DecoderException: Failed to decode packet 'serverbound/minecraft:hello'
-pub async fn execute_join_check(ip: String, port: u16, timeout_dur: Duration, username: &str, protocol: i32) -> Result<Join, String> {
-    let address = format!("{}:{}", ip, port);
-    let mut stream = timeout(timeout_dur, TcpStream::connect(&address))
+// I used this docs here https://minecraft.wiki/w/Java_Edition_protocol/FAQ#What's_the_normal_login_sequence_for_a_client?
+pub async fn execute_join_check(ip: Ipv4Addr, port: u16, timeout_dur: Duration, username: &str, protocol: i32) -> Result<Join, String> {
+    let mut stream = timeout(timeout_dur, TcpStream::connect((ip, port)))
         .await
         .map_err(|_| "Connect Timeout")?
         .map_err(|e| e.to_string())?;
 
-    // Sending handshake
+    // Send handshake
     let handshake = Handshake {
         protocol,
-        address: ip.clone(),
+        address: ip,
         port,
         next_state: 2,
     }.serialize();
@@ -29,6 +30,7 @@ pub async fn execute_join_check(ip: String, port: u16, timeout_dur: Duration, us
     write_varint(0x00, &mut login_start);
     login_start.extend(encode_string(username));
     login_start.push(0x01);
+    // Used here 0x0U0
     login_start.extend(encode_uuid("00000000-0000-0000-0000-000000000000"));
 
     let final_login = prepend_length(login_start);

src/minecraft/ping.rs

@@ -1,3 +1,4 @@
+use std::net::Ipv4Addr;
 use std::time::Duration;
 use tokio::net::TcpStream;
 use tokio::time::timeout;
@@ -7,10 +8,8 @@ use serde_json::Value;
 use crate::minecraft::utils::{write_varint, read_varint, prepend_length, Handshake, MinecraftPacket, parse_legacy, parse_plain};
 use crate::minecraft::{Ping, LightPlayer, Mod, ModLoader};
 
-pub async fn execute_ping(ip: String, port: u16, protocol: i32, timeout_dur: Duration) -> Result<Ping, String> {
-    let address = format!("{}:{}", ip, port);
-
-    let mut stream = match timeout(timeout_dur, TcpStream::connect(&address)).await {
+pub async fn execute_ping(ip: Ipv4Addr, port: u16, protocol: i32, timeout_dur: Duration) -> Result<Ping, String> {
+    let mut stream = match timeout(timeout_dur, TcpStream::connect((ip, port))).await {
         Ok(Ok(s)) => s,
         Ok(Err(e)) => return Err(format!("Connect error: {}", e)),
         Err(_) => return Err("Connect timeout".into()),
@@ -21,7 +20,7 @@ pub async fn execute_ping(ip: String, port: u16, protocol: i32, timeout_dur: Dur
 
     let handshake = Handshake {
         protocol,
-        address: ip.clone(),
+        address: ip,
         port,
         next_state: 1,
     }.serialize();

src/minecraft/query.rs

@@ -1,15 +1,15 @@
 use std::collections::HashMap;
+use std::net::Ipv4Addr;
 use std::time::Duration;
 use serde::Deserialize;
 use tokio::net::UdpSocket;
 use tokio::time::timeout;
 use crate::minecraft::{Query, Plugin, LightPlayer, Software};
 
 // To understand this here I recommend to read https://minecraft.wiki/w/Query#Client_to_Server_Packet_Format
-pub async fn execute_query(ip: &str, port: u16, timeout_dur: Duration, with_uuids: bool) -> Result<Query, String> {
-    let address = format!("{}:{}", ip, port);
+pub async fn execute_query(ip: Ipv4Addr, port: u16, timeout_dur: Duration, with_uuids: bool) -> Result<Query, String> {
     let socket = UdpSocket::bind("0.0.0.0:0").await.map_err(|e| e.to_string())?;
-    socket.connect(&address).await.map_err(|e| e.to_string())?;
+    socket.connect((ip, port)).await.map_err(|e| e.to_string())?;
 
     // Query handshake
     let session_id: i32 = 0x01010101; // Just a random ID
@@ -83,6 +83,7 @@ pub async fn parse_query_response(data: &[u8], with_uuids: bool) -> Result<Query
     let mut players = Vec::new();
     let client = reqwest::Client::new();
 
+    // Getting uuids from Mojangs server
     for name in player_names {
         let mut uuid = None;
 
@@ -102,6 +103,7 @@ pub async fn parse_query_response(data: &[u8], with_uuids: bool) -> Result<Query
         });
     }
 
+    // Parsing plugin string
     let mut raw_software_str = "Vanilla".to_string();
     let mut plugins = Vec::new();
 
@@ -164,6 +166,5 @@ fn parse_plugin_string(raw: &str) -> Vec<Plugin> {
 
 #[derive(Deserialize)]
 struct MojangProfile {
-    id: String,
-    // name: String,
+    id: String
 }

src/scanning/scanner.rs

@@ -1,3 +1,4 @@
+use std::net::Ipv4Addr;
 use std::sync::Arc;
 use futures::{stream, Stream, StreamExt};
 use std::time::Duration;
@@ -33,15 +34,15 @@ impl Default for ScanConfig {
 }
 
 pub struct ScanResult {
-    pub ip: String,
+    pub ip: Ipv4Addr,
     pub port: u16,
 
     pub ping: minecraft::Ping,
     pub query: Option<minecraft::Query>,
     pub join: Option<minecraft::Join>,
 }
 
-pub fn scan(targets: Vec<(String, u16)>, config: ScanConfig) -> impl Stream<Item = Option<ScanResult>> {
+pub fn scan(targets: Vec<(Ipv4Addr, u16)>, config: ScanConfig) -> impl Stream<Item = Option<ScanResult>> {
     let max_tasks = config.max_tasks as usize;
     let config_arc = Arc::new(config);
 
@@ -50,16 +51,16 @@ pub fn scan(targets: Vec<(String, u16)>, config: ScanConfig) -> impl Stream<Item
             let cfg = config_arc.clone();
 
             async move {
-                match execute_ping(ip.clone(), port, 767, cfg.ping_timeout).await {
+                match execute_ping(ip, port, 767, cfg.ping_timeout).await {
                     Ok(ping_res) => {
                         let query = if cfg.do_query {
-                            execute_query(ip.as_str(), port, cfg.query_timeout, cfg.with_uuid).await.ok()
+                            execute_query(ip, port, cfg.query_timeout, cfg.with_uuid).await.ok()
                         } else {
                             None
                         };
 
                         let join = if cfg.do_join {
-                            execute_join_check(ip.clone(), port, cfg.join_timeout, "ServerRawler", ping_res.protocol_version.unwrap_or(767)).await.ok()
+                            execute_join_check(ip, port, cfg.join_timeout, "ServerRawler", ping_res.protocol_version.unwrap_or(767)).await.ok()
                         } else {
                             None
                         };