ab/v2ray-proxy
1
0
Fork 0
mirror of https://github.com/house-of-vanity/v2-uri-parser.git synced 2025-12-15 14:47:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Applied clippy fixes

Browse Source
This commit is contained in:
AB
2025-12-01 01:48:36 +02:00
parent 1249d15aad
commit 1a4a296fae
15 changed files with 78 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
src/parser/mod.rs
View File

@@ -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<u16>, http_port: Option<u16>) -> 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");
}
};
}
}

8
src/parser/shadow_socks/data.rs
View File

@@ -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(),
};
}
}

4
src/parser/shadow_socks/mod.rs
View File

@@ -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(),
}],
});
})
}

10
src/parser/socks/data.rs
View File

@@ -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::<Uri>().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(),
},
};
}
}

4
src/parser/socks/mod.rs
View File

@@ -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),
}],
});
})
}

8
src/parser/trojan/data.rs
View File

@@ -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::<Uri>().unwrap();
return models::TrojanAddress {
models::TrojanAddress {
uuid: url_decode(Some(uuid)).unwrap(),
address: parsed.host().unwrap().to_string(),
port: parsed.port().unwrap().as_u16(),
};
}
}

4
src/parser/trojan/mod.rs
View File

@@ -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),
}],
});
})
}

4
src/parser/uri_identifier.rs
View File

@@ -26,7 +26,7 @@ pub fn get_uri_protocol(uri: &str) -> Option<Protocols> {
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() {

8
src/parser/vless/data.rs
View File

@@ -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::<Uri>().unwrap();
return models::VlessAddress {
models::VlessAddress {
uuid: url_decode(Some(uuid)).unwrap(),
address: parsed.host().unwrap().to_string(),
port: parsed.port().unwrap().as_u16(),
};
}
}

4
src/parser/vless/mod.rs
View File

@@ -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,
}]),
}],
});
})
}

23
src/parser/vmess/data.rs
View File

@@ -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<u8>) -> 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::<Value>(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::<u16>().expect("port is not a number"))),
port: get_str_field(&json, "port").map(|s| s.parse::<u16>().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<u8>) -> RawData {
allowInsecure: None,
server_method: None,
username: None,
};
}
}
fn get_str_field(json: &Value, field: &str) -> Option<String> {
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::<Uri>().unwrap();
return VmessAddress {
VmessAddress {
uuid: url_decode(Some(uuid)).unwrap(),
address: parsed.host().unwrap().to_string(),
port: parsed.port().unwrap().as_u16(),
};
}
}

4
src/parser/vmess/mod.rs
View File

@@ -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(),
}]),
}],
});
})
}

24
src/utils/inbound_generator.rs
View File

@@ -7,25 +7,19 @@ pub struct InboundGenerationOptions {
pub fn generate_inbound_config(options: InboundGenerationOptions) -> Vec<config_models::Inbound> {
let mut inbounds: Vec<config_models::Inbound> = 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"),
]),
}),
};
}
}

14
src/utils/mod.rs
View File

@@ -1,17 +1,17 @@
pub mod inbound_generator;
pub fn url_decode_str(value: &str) -> Option<String> {
return urlencoding::decode(value)
urlencoding::decode(value)
.ok()
.map(|decoded| decoded.into_owned());
.map(|decoded| decoded.into_owned())
}
pub fn url_decode(value: Option<String>) -> Option<String> {
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<serde_json::Value> {
@@ -24,8 +24,8 @@ pub fn parse_raw_json(input: &str) -> Option<serde_json::Value> {
}
pub fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option<String> {
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())
}

4
src/xray_runner.rs
View File

@@ -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");
}