From 1a4a296fae6d8829a856cc613486d8d8af05e8b9 Mon Sep 17 00:00:00 2001 From: AB Date: Mon, 1 Dec 2025 01:48:36 +0200 Subject: [PATCH] Applied clippy fixes --- src/parser/mod.rs | 40 ++++++++++++++++----------------- src/parser/shadow_socks/data.rs | 8 +++---- src/parser/shadow_socks/mod.rs | 4 ++-- src/parser/socks/data.rs | 10 ++++----- src/parser/socks/mod.rs | 4 ++-- src/parser/trojan/data.rs | 8 +++---- src/parser/trojan/mod.rs | 4 ++-- src/parser/uri_identifier.rs | 4 ++-- src/parser/vless/data.rs | 8 +++---- src/parser/vless/mod.rs | 4 ++-- src/parser/vmess/data.rs | 23 +++++++++---------- src/parser/vmess/mod.rs | 4 ++-- src/utils/inbound_generator.rs | 24 ++++++++------------ src/utils/mod.rs | 14 ++++++------ src/xray_runner.rs | 4 ++-- 15 files changed, 78 insertions(+), 85 deletions(-) diff --git a/src/parser/mod.rs b/src/parser/mod.rs index ffc88d0..3900ccf 100644 --- a/src/parser/mod.rs +++ b/src/parser/mod.rs @@ -18,17 +18,17 @@ pub fn get_metadata(uri: &str) -> String { name: data.remarks, host: data.host.clone(), address: data.address.clone(), - port: data.port.clone(), + port: data.port, protocol, }; - let serialized = serde_json::to_string(&meta_data).unwrap(); - return serialized; + + serde_json::to_string(&meta_data).unwrap() } pub fn create_json_config(uri: &str, socks_port: Option, http_port: Option) -> String { let config = create_config(uri, socks_port, http_port); - let serialized = serde_json::to_string(&config).unwrap(); - return serialized; + + serde_json::to_string(&config).unwrap() } pub fn create_config( @@ -42,11 +42,11 @@ pub fn create_config( socks_port, http_port, }); - let config = config_models::Config { + + config_models::Config { outbounds: vec![outbound_object], inbounds: inbound_config, - }; - return config; + } } pub fn create_outbound_object(uri: &str) -> config_models::Outbound { @@ -56,7 +56,9 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { let allow_insecure = data.allowInsecure == Some(String::from("true")) || data.allowInsecure == Some(String::from("1")); - let outbound = Outbound { + + + Outbound { protocol: name, tag: String::from("proxy"), streamSettings: StreamSettings { @@ -79,7 +81,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { } else { None }, - wsSettings: if network_type == String::from("ws") { + wsSettings: if network_type == "ws" { Some(WsSettings { Host: data.host.clone(), path: data.path.clone(), @@ -88,7 +90,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { } else { None }, - tcpSettings: if network_type == String::from("tcp") { + tcpSettings: if network_type == "tcp" { Some(TCPSettings { header: Some(TCPHeader { r#type: Some(data.header_type.unwrap_or(String::from("none"))), @@ -109,7 +111,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { } else { None }, - grpcSettings: if network_type == String::from("grpc") { + grpcSettings: if network_type == "grpc" { Some(GRPCSettings { authority: data.authority, multiMode: Some(false), @@ -118,7 +120,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { } else { None }, - quicSettings: if network_type == String::from("quic") { + quicSettings: if network_type == "quic" { Some(QuicSettings { header: Some(NonHeaderObject { r#type: Some(String::from("none")), @@ -129,7 +131,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { } else { None }, - kcpSettings: if network_type == String::from("kcp") { + kcpSettings: if network_type == "kcp" { Some(KCPSettings { mtu: None, tti: None, @@ -143,7 +145,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { } else { None }, - xhttpSettings: if network_type == String::from("xhttp") { + xhttpSettings: if network_type == "xhttp" { Some(XHTTPSettings { host: data.host.clone(), path: data.path.clone(), @@ -155,14 +157,12 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound { }, }, settings: outbound_settings, - }; - - return outbound; + } } fn get_uri_data(uri: &str) -> (String, RawData, OutboundSettings) { let protocol = uri_identifier::get_uri_protocol(uri); - return match protocol { + match protocol { Some(uri_identifier::Protocols::Vless) => { let d = vless::data::get_data(uri); let s = vless::create_outbound_settings(&d); @@ -194,5 +194,5 @@ fn get_uri_data(uri: &str) -> (String, RawData, OutboundSettings) { None => { panic!("The protocol is not supported"); } - }; + } } diff --git a/src/parser/shadow_socks/data.rs b/src/parser/shadow_socks/data.rs index b389d38..51b1619 100644 --- a/src/parser/shadow_socks/data.rs +++ b/src/parser/shadow_socks/data.rs @@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData { let (raw_data, name) = data.split_once("#").unwrap_or((data, "")); let (raw_uri, _) = raw_data.split_once("?").unwrap_or((raw_data, "")); let parsed_address = parse_ss_address(raw_uri); - return RawData { + RawData { remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")), server_method: url_decode(Some(parsed_address.method)), address: Some(parsed_address.address), @@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData { allowInsecure: None, vnext_security: None, username: None, - }; + } } fn parse_ss_address(raw_data: &str) -> models::ShadowSocksAddress { @@ -65,10 +65,10 @@ fn parse_ss_address(raw_data: &str) -> models::ShadowSocksAddress { .split_once(":") .expect("No `:` found in the decoded base64"); - return models::ShadowSocksAddress { + models::ShadowSocksAddress { method: String::from(method), password: String::from(password), address: parsed.host().unwrap().to_string(), port: parsed.port().unwrap().as_u16(), - }; + } } diff --git a/src/parser/shadow_socks/mod.rs b/src/parser/shadow_socks/mod.rs index 4254bea..40361d2 100644 --- a/src/parser/shadow_socks/mod.rs +++ b/src/parser/shadow_socks/mod.rs @@ -3,7 +3,7 @@ mod models; use crate::config_models::*; pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { - return OutboundSettings::ShadowSocks(ShadowSocksOutboundSettings { + OutboundSettings::ShadowSocks(ShadowSocksOutboundSettings { servers: vec![ShadowSocksServerObject { address: data.address.clone(), port: data.port, @@ -11,5 +11,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { level: Some(0), method: data.server_method.clone(), }], - }); + }) } diff --git a/src/parser/socks/data.rs b/src/parser/socks/data.rs index 9404d39..772c69d 100644 --- a/src/parser/socks/data.rs +++ b/src/parser/socks/data.rs @@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData { let (raw_data, name) = data.split_once("#").unwrap_or((data, "")); let (raw_uri, _) = raw_data.split_once("?").unwrap_or((raw_data, "")); let parsed_address = parse_socks_address(raw_uri); - return RawData { + RawData { remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")), username: url_decode(parsed_address.username), address: Some(parsed_address.address), @@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData { quic_security: None, allowInsecure: None, vnext_security: None, - }; + } } fn parse_socks_address(raw_data: &str) -> models::SocksAddress { @@ -54,7 +54,7 @@ fn parse_socks_address(raw_data: &str) -> models::SocksAddress { let parsed = address_wo_slash.parse::().unwrap(); - return match maybe_userinfo { + match maybe_userinfo { Some(userinfo) => { let url_decoded = url_decode_str(&userinfo).unwrap_or(userinfo); let username_and_password = general_purpose::STANDARD @@ -64,7 +64,7 @@ fn parse_socks_address(raw_data: &str) -> models::SocksAddress { std::str::from_utf8(&a).expect("Base64 did not yield a valid utf-8 string"), ) }) - .unwrap_or(String::from(url_decoded.clone())); + .unwrap_or(url_decoded.clone()); let (username, password) = username_and_password .split_once(":") @@ -83,5 +83,5 @@ fn parse_socks_address(raw_data: &str) -> models::SocksAddress { address: parsed.host().unwrap().to_string(), port: parsed.port().unwrap().as_u16(), }, - }; + } } diff --git a/src/parser/socks/mod.rs b/src/parser/socks/mod.rs index eecd912..302ba32 100644 --- a/src/parser/socks/mod.rs +++ b/src/parser/socks/mod.rs @@ -3,7 +3,7 @@ mod models; use crate::config_models::*; pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { - return OutboundSettings::Socks(SocksOutboundSettings { + OutboundSettings::Socks(SocksOutboundSettings { servers: vec![SocksServerObject { users: match (&data.username, &data.uuid) { (Some(username), Some(uuid)) => Some(vec![SocksUser { @@ -16,5 +16,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { port: data.port, level: Some(0), }], - }); + }) } diff --git a/src/parser/trojan/data.rs b/src/parser/trojan/data.rs index 5948837..93d8c87 100644 --- a/src/parser/trojan/data.rs +++ b/src/parser/trojan/data.rs @@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData { let parsed_address = parse_trojan_address(data.split_once("?").unwrap().0); let query: Vec<(&str, &str)> = querystring::querify(raw_query); - return RawData { + RawData { remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")), uuid: Some(parsed_address.uuid), port: Some(parsed_address.port), @@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData { allowInsecure: get_parameter_value(&query, "allowInsecure"), server_method: None, username: None, - }; + } } fn parse_trojan_address(raw_data: &str) -> models::TrojanAddress { @@ -56,9 +56,9 @@ fn parse_trojan_address(raw_data: &str) -> models::TrojanAddress { let parsed = address_wo_slash.parse::().unwrap(); - return models::TrojanAddress { + models::TrojanAddress { uuid: url_decode(Some(uuid)).unwrap(), address: parsed.host().unwrap().to_string(), port: parsed.port().unwrap().as_u16(), - }; + } } diff --git a/src/parser/trojan/mod.rs b/src/parser/trojan/mod.rs index 3361dc0..b2d8273 100644 --- a/src/parser/trojan/mod.rs +++ b/src/parser/trojan/mod.rs @@ -3,12 +3,12 @@ mod models; use crate::config_models::*; pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { - return OutboundSettings::Trojan(TrojanOutboundSettings { + OutboundSettings::Trojan(TrojanOutboundSettings { servers: vec![TrojanServerObject { address: data.address.clone(), port: data.port, password: data.uuid.clone(), level: Some(0), }], - }); + }) } diff --git a/src/parser/uri_identifier.rs b/src/parser/uri_identifier.rs index 111ff4c..c06a8af 100644 --- a/src/parser/uri_identifier.rs +++ b/src/parser/uri_identifier.rs @@ -26,7 +26,7 @@ pub fn get_uri_protocol(uri: &str) -> Option { if uri.starts_with("trojan://") { return Some(Protocols::Trojan); } - return None; + None } #[cfg(test)] @@ -37,7 +37,7 @@ mod tests { let protocol = get_uri_protocol( "123-vless://3d1c3f04-729d-59d3-bdb6-3f3f4352e173@root.ii.one:2083?security=reality&sni=www.spamhaus.org&fp=safari&pbk=7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04&sid=6ba85179e30d4fc2&type=tcp&flow=xtls-rprx-vision#Ha-ac", ); - assert!(matches!(protocol, None)); + assert!(protocol.is_none()); } #[test] fn recognize_vless_protocol() { diff --git a/src/parser/vless/data.rs b/src/parser/vless/data.rs index cf18a1d..172631d 100644 --- a/src/parser/vless/data.rs +++ b/src/parser/vless/data.rs @@ -12,7 +12,7 @@ pub fn get_data(uri: &str) -> RawData { let parsed_address = parse_vless_address(data.split_once("?").unwrap().0); let query: Vec<(&str, &str)> = querystring::querify(raw_query); - return RawData { + RawData { remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")), uuid: Some(parsed_address.uuid), port: Some(parsed_address.port), @@ -42,7 +42,7 @@ pub fn get_data(uri: &str) -> RawData { allowInsecure: get_parameter_value(&query, "allowInsecure"), server_method: None, username: None, - }; + } } fn parse_vless_address(raw_data: &str) -> models::VlessAddress { @@ -56,9 +56,9 @@ fn parse_vless_address(raw_data: &str) -> models::VlessAddress { let parsed = address_wo_slash.parse::().unwrap(); - return models::VlessAddress { + models::VlessAddress { uuid: url_decode(Some(uuid)).unwrap(), address: parsed.host().unwrap().to_string(), port: parsed.port().unwrap().as_u16(), - }; + } } diff --git a/src/parser/vless/mod.rs b/src/parser/vless/mod.rs index 3fbaae6..187ffcf 100644 --- a/src/parser/vless/mod.rs +++ b/src/parser/vless/mod.rs @@ -3,7 +3,7 @@ mod models; use crate::config_models::*; pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { - return OutboundSettings::Vless(VlessOutboundSettings { + OutboundSettings::Vless(VlessOutboundSettings { vnext: vec![VnextServerObject { port: data.port, address: data.address.clone(), @@ -15,5 +15,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { security: None, }]), }], - }); + }) } diff --git a/src/parser/vmess/data.rs b/src/parser/vmess/data.rs index 88c07db..0a52c82 100644 --- a/src/parser/vmess/data.rs +++ b/src/parser/vmess/data.rs @@ -8,23 +8,22 @@ use serde_json::Value; pub fn get_data(uri: &str) -> RawData { let data = uri.split_once("vmess://").unwrap().1; - return match general_purpose::STANDARD + match general_purpose::STANDARD .decode(url_decode_str(data).unwrap_or(String::from(data))) { Ok(decoded) => get_raw_data_from_base64(&decoded), Err(_) => get_raw_data_from_uri(data), - }; + } } -fn get_raw_data_from_base64(decoded_base64: &Vec) -> RawData { +fn get_raw_data_from_base64(decoded_base64: &[u8]) -> RawData { let json_str = std::str::from_utf8(decoded_base64).unwrap(); let json = serde_json::from_str::(json_str).unwrap(); - return RawData { + RawData { remarks: url_decode(get_str_field(&json, "ps")).unwrap_or(String::from("")), uuid: get_str_field(&json, "id"), - port: get_str_field(&json, "port") - .and_then(|s| Some(s.parse::().expect("port is not a number"))), + port: get_str_field(&json, "port").map(|s| s.parse::().expect("port is not a number")), address: get_str_field(&json, "add"), alpn: url_decode(get_str_field(&json, "alpn")), path: url_decode(get_str_field(&json, "path")), @@ -59,11 +58,11 @@ fn get_raw_data_from_base64(decoded_base64: &Vec) -> RawData { allowInsecure: None, server_method: None, username: None, - }; + } } fn get_str_field(json: &Value, field: &str) -> Option { - return json.get(field).and_then(|v| v.as_str()).map(String::from); + json.get(field).and_then(|v| v.as_str()).map(String::from) } fn get_raw_data_from_uri(data: &str) -> RawData { @@ -75,7 +74,7 @@ fn get_raw_data_from_uri(data: &str) -> RawData { let parsed_address = parse_vmess_address(data.split_once("?").unwrap().0); let query: Vec<(&str, &str)> = querystring::querify(raw_query); - return RawData { + RawData { remarks: url_decode(Some(String::from(name))).unwrap_or(String::from("")), uuid: Some(parsed_address.uuid), port: Some(parsed_address.port), @@ -105,7 +104,7 @@ fn get_raw_data_from_uri(data: &str) -> RawData { allowInsecure: get_parameter_value(&query, "allowInsecure"), server_method: None, username: None, - }; + } } fn parse_vmess_address(raw_data: &str) -> VmessAddress { @@ -119,9 +118,9 @@ fn parse_vmess_address(raw_data: &str) -> VmessAddress { let parsed = address_wo_slash.parse::().unwrap(); - return VmessAddress { + VmessAddress { uuid: url_decode(Some(uuid)).unwrap(), address: parsed.host().unwrap().to_string(), port: parsed.port().unwrap().as_u16(), - }; + } } diff --git a/src/parser/vmess/mod.rs b/src/parser/vmess/mod.rs index 7845b4b..d6711ff 100644 --- a/src/parser/vmess/mod.rs +++ b/src/parser/vmess/mod.rs @@ -3,7 +3,7 @@ mod models; use crate::config_models::*; pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { - return OutboundSettings::Vmess(VmessOutboundSettings { + OutboundSettings::Vmess(VmessOutboundSettings { vnext: vec![VnextServerObject { port: data.port, address: data.address.clone(), @@ -15,5 +15,5 @@ pub fn create_outbound_settings(data: &RawData) -> OutboundSettings { security: data.vnext_security.clone(), }]), }], - }); + }) } diff --git a/src/utils/inbound_generator.rs b/src/utils/inbound_generator.rs index 3808dfb..84d2435 100644 --- a/src/utils/inbound_generator.rs +++ b/src/utils/inbound_generator.rs @@ -7,25 +7,19 @@ pub struct InboundGenerationOptions { pub fn generate_inbound_config(options: InboundGenerationOptions) -> Vec { let mut inbounds: Vec = vec![]; - match options.socks_port { - Some(port) => { - inbounds.push(generate_socks_inbound(port)); - } - None => {} + if let Some(port) = options.socks_port { + inbounds.push(generate_socks_inbound(port)); } - match options.http_port { - Some(port) => { - inbounds.push(generate_http_inbound(port)); - } - None => {} + if let Some(port) = options.http_port { + inbounds.push(generate_http_inbound(port)); } - return inbounds; + inbounds } pub fn generate_http_inbound(http_port: u16) -> config_models::Inbound { - return config_models::Inbound { + config_models::Inbound { protocol: String::from("http"), port: http_port, tag: String::from("http-in"), @@ -42,11 +36,11 @@ pub fn generate_http_inbound(http_port: u16) -> config_models::Inbound { String::from("quic"), ]), }), - }; + } } pub fn generate_socks_inbound(socks_port: u16) -> config_models::Inbound { - return config_models::Inbound { + config_models::Inbound { protocol: String::from("socks"), port: socks_port, tag: String::from("socks-in"), @@ -63,5 +57,5 @@ pub fn generate_socks_inbound(socks_port: u16) -> config_models::Inbound { String::from("quic"), ]), }), - }; + } } diff --git a/src/utils/mod.rs b/src/utils/mod.rs index 54a8d93..6443286 100644 --- a/src/utils/mod.rs +++ b/src/utils/mod.rs @@ -1,17 +1,17 @@ pub mod inbound_generator; pub fn url_decode_str(value: &str) -> Option { - return urlencoding::decode(value) + urlencoding::decode(value) .ok() - .map(|decoded| decoded.into_owned()); + .map(|decoded| decoded.into_owned()) } pub fn url_decode(value: Option) -> Option { - return value.and_then(|s| { + value.and_then(|s| { urlencoding::decode(&s) .ok() .map(|decoded| decoded.into_owned()) - }); + }) } pub fn parse_raw_json(input: &str) -> Option { @@ -24,8 +24,8 @@ pub fn parse_raw_json(input: &str) -> Option { } pub fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option { - return query + query .iter() - .find(|q| String::from(q.0) == String::from(param)) - .map(|q| q.1.to_string()); + .find(|q| q.0 == param) + .map(|q| q.1.to_string()) } diff --git a/src/xray_runner.rs b/src/xray_runner.rs index f064b67..b86c23c 100644 --- a/src/xray_runner.rs +++ b/src/xray_runner.rs @@ -50,7 +50,7 @@ impl XrayRunner { println!("Stopping xray-core process..."); // Try graceful shutdown first - if let Err(_) = process.kill().await { + if (process.kill().await).is_err() { eprintln!("Failed to kill xray-core process gracefully"); } @@ -62,7 +62,7 @@ impl XrayRunner { } // Cleanup config file - if let Some(_) = self.config_file.take() { + if self.config_file.take().is_some() { println!("Cleaned up temporary config file"); }