Merge pull request #8 from Keivan-sf/5-improve-vless-parser-and-headers

5 improve vless parser and headers

src/config_models/mod.rs

@@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize};
 pub struct VlessUser {
     pub id: String,
     pub encryption: String,
-    pub flow: String,
-    pub level: u8,
+    pub flow: Option<String>,
+    pub level: Option<u8>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -28,38 +28,66 @@ pub enum OutboundSettings {
 
 #[derive(Serialize, Deserialize)]
 pub struct NonHeaderObject {
-    pub r#type: String,
+    pub r#type: Option<String>,
 }
 
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize)]
 pub struct QuicSettings {
     pub header: Option<NonHeaderObject>,
-    pub security: String,
-    pub key: String,
+    pub security: Option<String>,
+    pub key: Option<String>,
 }
 
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize)]
 pub struct GRPCSettings {
-    pub multiMode: bool,
-    pub serviceName: String,
+    pub authority: Option<String>,
+    pub multiMode: Option<bool>,
+    pub serviceName: Option<String>,
+}
+
+#[allow(non_snake_case)]
+#[derive(Serialize, Deserialize)]
+pub struct KCPSettings {
+    pub mtu: Option<u32>,
+    pub tti: Option<u32>,
+    pub uplinkCapacity: Option<u32>,
+    pub downlinkCapacity: Option<u32>,
+    pub congestion: Option<bool>,
+    pub readBufferSize: Option<u32>,
+    pub writeBufferSize: Option<u32>,
+    pub seed: Option<String>,
+}
+
+#[allow(non_snake_case)]
+#[derive(Serialize, Deserialize)]
+pub struct XHTTPSettings {
+    pub host: Option<String>,
+    pub path: Option<String>,
+    pub mode: Option<String>,
+    pub extra: Option<serde_json::Value>,
 }
 
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize)]
 pub struct RealitySettings {
-    pub fingerprint: String,
-    pub serverName: String,
-    pub publicKey: String,
-    pub shortId: String,
-    pub spiderX: String,
+    pub fingerprint: Option<String>,
+    pub serverName: Option<String>,
+    pub publicKey: Option<String>,
+    pub shortId: Option<String>,
+    pub spiderX: Option<String>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct TCPHeader {
+    pub r#type: Option<String>,
 }
 
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize)]
 pub struct TCPSettings {
-    pub header: Option<NonHeaderObject>,
+    pub header: Option<TCPHeader>,
     pub acceptProxyProtocol: Option<bool>,
 }
 
@@ -73,13 +101,14 @@ pub struct HeaderSetting {
 #[derive(Serialize, Deserialize)]
 pub struct WsSettings {
     pub path: Option<String>,
-    pub headers: Option<HeaderSetting>,
+    pub Host: Option<String>,
     pub acceptProxyProtocol: Option<bool>,
 }
 
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize)]
 pub struct TlsSettings {
+    pub alpn: Option<Vec<String>>,
     pub allowInsecure: Option<bool>,
     pub serverName: Option<String>,
     pub enableSessionResumption: Option<bool>,
@@ -95,14 +124,16 @@ pub struct TlsSettings {
 #[allow(non_snake_case)]
 #[derive(Serialize, Deserialize)]
 pub struct StreamSettings {
-    pub network: String,
-    pub security: String,
+    pub network: Option<String>,
+    pub security: Option<String>,
     pub tlsSettings: Option<TlsSettings>,
     pub wsSettings: Option<WsSettings>,
     pub tcpSettings: Option<TCPSettings>,
     pub realitySettings: Option<RealitySettings>,
     pub grpcSettings: Option<GRPCSettings>,
     pub quicSettings: Option<QuicSettings>,
+    pub kcpSettings: Option<KCPSettings>,
+    pub xhttpSettings: Option<XHTTPSettings>,
 }
 
 #[allow(non_snake_case)]

src/parser/mod.rs

@@ -28,7 +28,7 @@ pub fn create_outbound_object(uri: &str) -> config_models::Outbound {
     let protocol = uri_identifier::get_uri_protocol(uri);
     match protocol {
         Some(uri_identifier::Protocols::Vless) => {
-            let vless_data = vless::get_vless_data(uri);
+            let vless_data = vless::data::get_data(uri);
             let outbound_object = vless::create_outbound_object(vless_data);
             return outbound_object;
         }

src/parser/vless/data.rs

@@ -0,0 +1,183 @@
+use crate::parser::vless::models;
+use crate::utils::{get_parameter_value, url_decode};
+use http::Uri;
+
+pub fn get_data(uri: &str) -> models::VlessData {
+    let data = uri.split_once("vless://").unwrap().1;
+    let query_and_name = uri.split_once("?").unwrap().1;
+    let query = query_and_name
+        .split_once("#")
+        .unwrap_or((query_and_name, ""))
+        .0;
+    let parsed_query = parse_vless_query(query);
+    let parsed_address = parse_vless_address(data.split_once("?").unwrap().0);
+    return models::VlessData {
+        query: parsed_query,
+        address_data: parsed_address,
+    };
+}
+
+fn parse_vless_address(raw_data: &str) -> models::VlessAddress {
+    let (uuid, raw_address): (String, &str) = match raw_data.split_once("@") {
+        None => {
+            panic!("Wrong vless format, no `@` found in the address");
+        }
+        Some(data) => (String::from(data.0), data.1),
+    };
+    let address_wo_slash = raw_address.strip_suffix("/").unwrap_or(raw_address);
+
+    let parsed = address_wo_slash.parse::<Uri>().unwrap();
+
+    return models::VlessAddress {
+        uuid: url_decode(Some(uuid)).unwrap(),
+        address: parsed.host().unwrap().to_string(),
+        port: parsed.port().unwrap().as_u16(),
+    };
+}
+
+fn parse_vless_query(raw_query: &str) -> models::VlessQuery {
+    let query: Vec<(&str, &str)> = querystring::querify(raw_query);
+
+    let a = models::VlessQuery {
+        alpn: url_decode(get_parameter_value(&query, "alpn")),
+        path: url_decode(get_parameter_value(&query, "path")),
+        authority: url_decode(get_parameter_value(&query, "authority")),
+        pbk: url_decode(get_parameter_value(&query, "pbk")),
+        security: get_parameter_value(&query, "security"),
+        sid: url_decode(get_parameter_value(&query, "sid")),
+        flow: get_parameter_value(&query, "flow"),
+        sni: get_parameter_value(&query, "sni"),
+        fp: url_decode(get_parameter_value(&query, "fp")),
+        r#type: get_parameter_value(&query, "type"),
+        encryption: get_parameter_value(&query, "encryption"),
+        header_type: get_parameter_value(&query, "headerType"),
+        host: url_decode(get_parameter_value(&query, "host")),
+        seed: url_decode(get_parameter_value(&query, "seed")),
+        quic_security: get_parameter_value(&query, "quicSecurity"),
+        key: get_parameter_value(&query, "key"),
+        mode: url_decode(get_parameter_value(&query, "mode")),
+        service_name: url_decode(get_parameter_value(&query, "serviceName")),
+        slpn: get_parameter_value(&query, "slpn"),
+        spx: url_decode(get_parameter_value(&query, "spx")),
+        extra: url_decode(get_parameter_value(&query, "extra")),
+    };
+    return a;
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::parser::vless::create_outbound_object;
+
+    use super::*;
+
+    #[test]
+    fn vless_tcp_header_test() {
+        let v = "vless://1010501a-ca9a-479c-84d0-1308d97789b5@104.21.25.109:443?security=reality&alpn=http%2F1.1&encryption=none&pbk=testpub&host=mehr14-n.gowow31220.workers.dev&headerType=http&fp=chrome&spx=spideex&type=tcp&flow=xtls-rprx-vision&sni=mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran-mehr14-iran.gowow31220.workers.dev&sid=testshort#%E2%AD%90%EF%B8%8F%20Telegram%20%3D%20%40z_v2ray";
+        let data = create_outbound_object(get_data(v));
+        assert_eq!(
+            data.streamSettings
+                .tcpSettings
+                .unwrap()
+                .header
+                .unwrap()
+                .r#type,
+            Some(String::from("http"))
+        )
+    }
+
+    #[test]
+    fn vless_test_2() {
+        let v = "vless://2dc56709-sdfs-sdfs-2234-128904@nwarne.fast-ip.com:80/?type=ws&encryption=none&host=Shuposipet.com&path=%2Fde%3Fed%3D1048#[test]@test";
+        let data = get_data(v);
+        assert_eq!(data.address_data.address, "nwarne.fast-ip.com");
+        assert_eq!(data.address_data.uuid, "2dc56709-sdfs-sdfs-2234-128904");
+        assert_eq!(data.address_data.port, 80);
+        assert_eq!(data.query.encryption.unwrap(), "none");
+        assert_eq!(data.query.r#type.unwrap(), "ws");
+    }
+
+    #[test]
+    fn vless_test() {
+        let v = "vless://4d2c3e35-749d-52e3-bdb6-3f3f4950c183@tre.test.one:2053?security=reality&type=tcp&flow=xtls-rprx-vision#test-name";
+        let data = get_data(v);
+        assert_eq!(data.address_data.address, "tre.test.one");
+        assert_eq!(
+            data.address_data.uuid,
+            "4d2c3e35-749d-52e3-bdb6-3f3f4950c183"
+        );
+        assert_eq!(data.address_data.port, 2053);
+        assert_eq!(data.query.flow.unwrap(), "xtls-rprx-vision");
+        assert_eq!(data.query.security.unwrap(), "reality");
+        assert_eq!(data.query.r#type.unwrap(), "tcp");
+    }
+
+    #[test]
+    fn parse_vless_query_data() {
+        let query = "security=reality&sni=bench.sh&fp=chrome&pbk=7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04&sid=6ba85179e30d4fc2&type=tcp&flow=xtls-rprx-vision&alpn=http%2F1.1&path=/";
+        let parsed_query = parse_vless_query(query);
+        assert_eq!(parsed_query.sni.unwrap(), "bench.sh");
+        assert_eq!(parsed_query.security.unwrap(), "reality");
+        assert_eq!(parsed_query.fp.unwrap(), "chrome");
+        assert_eq!(
+            parsed_query.pbk.unwrap(),
+            "7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04"
+        );
+        assert_eq!(parsed_query.sid.unwrap(), "6ba85179e30d4fc2");
+        assert_eq!(parsed_query.r#type.unwrap(), "tcp");
+        assert_eq!(parsed_query.flow.unwrap(), "xtls-rprx-vision");
+        assert_eq!(parsed_query.alpn.unwrap(), "http/1.1");
+        assert_eq!(parsed_query.path.unwrap(), "/");
+        assert_eq!(parsed_query.encryption, None);
+        assert_eq!(parsed_query.header_type, None);
+        assert_eq!(parsed_query.host, None);
+        assert_eq!(parsed_query.seed, None);
+        assert_eq!(parsed_query.quic_security, None);
+        assert_eq!(parsed_query.key, None);
+        assert_eq!(parsed_query.mode, None);
+        assert_eq!(parsed_query.service_name, None);
+        assert_eq!(parsed_query.slpn, None);
+        assert_eq!(parsed_query.spx, None);
+    }
+
+    #[test]
+    fn parse_vless_query_with_defaults() {
+        let query = "";
+        let parsed_query = parse_vless_query(query);
+        assert_eq!(parsed_query.sni, None);
+        assert_eq!(parsed_query.security, None);
+        assert_eq!(parsed_query.fp, None);
+        assert_eq!(parsed_query.pbk, None);
+        assert_eq!(parsed_query.sid, None);
+        assert_eq!(parsed_query.r#type, None);
+        assert_eq!(parsed_query.r#flow, None);
+        assert_eq!(parsed_query.path, None);
+        assert_eq!(parsed_query.encryption, None);
+        assert_eq!(parsed_query.header_type, None);
+        assert_eq!(parsed_query.host, None);
+        assert_eq!(parsed_query.seed, None);
+        assert_eq!(parsed_query.quic_security, None);
+        assert_eq!(parsed_query.key, None);
+        assert_eq!(parsed_query.mode, None);
+        assert_eq!(parsed_query.service_name, None);
+        assert_eq!(parsed_query.slpn, None);
+        assert_eq!(parsed_query.spx, None);
+    }
+
+    #[test]
+    fn parse_vless_host() {
+        let raw_host = "uu0id@127.0.0.1:3012";
+        let parsed = parse_vless_address(raw_host);
+        assert_eq!(parsed.address, "127.0.0.1");
+        assert_eq!(parsed.port, 3012);
+        assert_eq!(parsed.uuid, "uu0id");
+    }
+
+    #[test]
+    fn parse_vless_ipv6_host() {
+        let raw_host = "uu0id@[2a06:98c1:3120::1]:443";
+        let parsed = parse_vless_address(raw_host);
+        assert_eq!(parsed.port, 443);
+        assert_eq!(parsed.address, "[2a06:98c1:3120::1]");
+        assert_eq!(parsed.uuid, "uu0id");
+    }
+}

src/parser/vless/mod.rs

@@ -1,18 +1,18 @@
-use querystring;
+pub mod data;
 mod models;
-use crate::config_models::*;
-use http::Uri;
-use std::process::exit;
+use crate::{config_models::*, utils::parse_raw_json};
 
 pub fn create_outbound_object(data: models::VlessData) -> Outbound {
+    let network_type = data.query.r#type.clone().unwrap_or(String::from(""));
     return Outbound {
         protocol: String::from("vless"),
         tag: String::from("proxy"),
         streamSettings: StreamSettings {
             network: data.query.r#type.clone(),
             security: data.query.security.clone(),
-            tlsSettings: if data.query.security == String::from("tls") {
+            tlsSettings: if network_type == String::from("tls") {
                 Some(TlsSettings {
+                    alpn: data.query.alpn.map(|alpn| vec![alpn]),
                     rejectUnknownSni: None,
                     enableSessionResumption: None,
                     minVersion: None,
@@ -20,64 +20,83 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound {
                     cipherSuites: None,
                     disableSystemRoot: None,
                     preferServerCipherSuites: None,
-                    fingerprint: Some(String::from("")),
-                    serverName: Some(data.query.sni.clone()),
+                    fingerprint: data.query.fp.clone(),
+                    serverName: data.query.sni.clone(),
                     allowInsecure: Some(false),
                 })
             } else {
                 None
             },
-            wsSettings: if data.query.r#type == String::from("ws") {
+            wsSettings: if network_type == String::from("ws") {
                 Some(WsSettings {
-                    headers: Some(HeaderSetting {
-                        Host: Some(data.query.host),
-                    }),
-                    path: Some(
-                        urlencoding::decode(data.query.path.as_str())
-                            .unwrap()
-                            .into_owned(),
-                    ),
+                    Host: data.query.host.clone(),
+                    path: data.query.path.clone(),
                     acceptProxyProtocol: None,
                 })
             } else {
                 None
             },
-            tcpSettings: if data.query.r#type == String::from("tcp") {
+            tcpSettings: if network_type == String::from("tcp") {
                 Some(TCPSettings {
-                    header: Some(NonHeaderObject {
-                        r#type: String::from("none"),
+                    header: Some(TCPHeader {
+                        r#type: Some(data.query.header_type.unwrap_or(String::from("none"))),
                     }),
                     acceptProxyProtocol: None,
                 })
             } else {
                 None
             },
-            realitySettings: if data.query.security == String::from("reality") {
+            realitySettings: if network_type == String::from("reality") {
                 Some(RealitySettings {
                     publicKey: data.query.pbk,
                     serverName: data.query.sni.clone(),
                     shortId: data.query.sid,
-                    spiderX: String::from(""),
-                    fingerprint: data.query.fp,
+                    spiderX: Some(String::from("")),
+                    fingerprint: data.query.fp.clone(),
                 })
             } else {
                 None
             },
-            grpcSettings: if data.query.r#type == String::from("grpc") {
+            grpcSettings: if network_type == String::from("grpc") {
                 Some(GRPCSettings {
-                    multiMode: false,
+                    authority: data.query.authority,
+                    multiMode: Some(false),
                     serviceName: data.query.service_name,
                 })
             } else {
                 None
             },
-            quicSettings: if data.query.r#type == String::from("quic") {
+            quicSettings: if network_type == String::from("quic") {
                 Some(QuicSettings {
                     header: Some(NonHeaderObject {
-                        r#type: String::from("none"),
+                        r#type: Some(String::from("none")),
                     }),
-                    security: String::from("none"),
-                    key: String::from(""),
+                    security: Some(String::from("none")),
+                    key: Some(String::from("")),
+                })
+            } else {
+                None
+            },
+            kcpSettings: if network_type == String::from("kcp") {
+                Some(KCPSettings {
+                    mtu: None,
+                    tti: None,
+                    congestion: None,
+                    uplinkCapacity: None,
+                    readBufferSize: None,
+                    writeBufferSize: None,
+                    downlinkCapacity: None,
+                    seed: data.query.seed,
+                })
+            } else {
+                None
+            },
+            xhttpSettings: if network_type == String::from("xhttp") {
+                Some(XHTTPSettings {
+                    host: data.query.host.clone(),
+                    path: data.query.path.clone(),
+                    mode: data.query.mode,
+                    extra: data.query.extra.and_then(|e| parse_raw_json(e.as_str())),
                 })
             } else {
                 None
@@ -90,196 +109,10 @@ pub fn create_outbound_object(data: models::VlessData) -> Outbound {
                 users: vec![VlessUser {
                     id: data.address_data.uuid,
                     flow: data.query.flow,
-                    encryption: if data.query.encryption.len() > 0 {
-                        data.query.encryption
-                    } else {
-                        String::from("none")
-                    },
-                    level: 0,
+                    encryption: data.query.encryption.unwrap_or(String::from("none")),
+                    level: Some(0),
                 }],
             }],
         }),
     };
 }
-
-pub fn get_vless_data(uri: &str) -> models::VlessData {
-    let data = uri.split_once("vless://").unwrap().1;
-    let query_and_name = uri.split_once("?").unwrap().1;
-    let query = query_and_name
-        .split_once("#")
-        .unwrap_or((query_and_name, ""))
-        .0;
-    let parsed_query = parse_vless_query(query);
-    let parsed_address = parse_vless_address(data.split_once("?").unwrap().0);
-    return models::VlessData {
-        query: parsed_query,
-        address_data: parsed_address,
-    };
-}
-
-fn parse_vless_address(raw_data: &str) -> models::VlessAddress {
-    let (uuid, raw_address): (String, &str) = match raw_data.split_once("@") {
-        None => {
-            println!("Wrong vless format, no `@` found in the address");
-            exit(0);
-        }
-        Some(data) => (String::from(data.0), data.1),
-    };
-    let address_wo_slash = raw_address.strip_suffix("/").unwrap_or(raw_address);
-
-    let parsed = address_wo_slash.parse::<Uri>().unwrap();
-
-    return models::VlessAddress {
-        uuid,
-        address: parsed.host().unwrap().to_string(),
-        port: parsed.port().unwrap().as_u16(),
-    };
-}
-
-fn parse_vless_query(raw_query: &str) -> models::VlessQuery {
-    let query: Vec<(&str, &str)> = querystring::querify(raw_query);
-
-    let a = models::VlessQuery {
-        path: get_parameter_value(&query, "path"),
-        pbk: get_parameter_value(&query, "pbk"),
-        security: get_parameter_value(&query, "security"),
-        sid: get_parameter_value(&query, "sid"),
-        flow: get_parameter_value(&query, "flow"),
-        sni: get_parameter_value(&query, "sni"),
-        fp: get_parameter_value(&query, "fp"),
-        r#type: get_parameter_value(&query, "type"),
-        encryption: get_parameter_value(&query, "encryption"),
-        header_type: get_parameter_value(&query, "headerType"),
-        host: get_parameter_value(&query, "host"),
-        seed: get_parameter_value(&query, "seed"),
-        quic_security: get_parameter_value(&query, "quicSecurity"),
-        key: get_parameter_value(&query, "key"),
-        mode: get_parameter_value(&query, "mode"),
-        service_name: get_parameter_value(&query, "serviceName"),
-        slpn: get_parameter_value(&query, "slpn"),
-        spx: get_parameter_value(&query, "spx"),
-    };
-    return a;
-}
-
-fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> String {
-    return query
-        .iter()
-        .find(|q| String::from(q.0) == String::from(param))
-        .unwrap_or(&("", ""))
-        .1
-        .to_string();
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn vless_test_2() {
-        let v = "vless://2dc56709-sdfs-sdfs-2234-128904@nwarne.fast-ip.com:80/?type=ws&encryption=none&host=Shuposipet.com&path=%2Fde%3Fed%3D1048#[test]@test";
-        let data = get_vless_data(v);
-        assert_eq!(data.address_data.address, "nwarne.fast-ip.com");
-        assert_eq!(data.address_data.uuid, "2dc56709-sdfs-sdfs-2234-128904");
-        assert_eq!(data.address_data.port, 80);
-        assert_eq!(data.query.encryption, "none");
-        assert_eq!(data.query.r#type, "ws");
-    }
-
-    #[test]
-    fn vless_test() {
-        let v = "vless://4d2c3e35-749d-52e3-bdb6-3f3f4950c183@tre.test.one:2053?security=reality&type=tcp&flow=xtls-rprx-vision#test-name";
-        let data = get_vless_data(v);
-        assert_eq!(data.address_data.address, "tre.test.one");
-        assert_eq!(
-            data.address_data.uuid,
-            "4d2c3e35-749d-52e3-bdb6-3f3f4950c183"
-        );
-        assert_eq!(data.address_data.port, 2053);
-        assert_eq!(data.query.flow, "xtls-rprx-vision");
-        assert_eq!(data.query.security, "reality");
-        assert_eq!(data.query.r#type, "tcp");
-    }
-
-    #[test]
-    fn parse_vless_query_data() {
-        let query = "security=reality&sni=bench.sh&fp=chrome&pbk=7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04&sid=6ba85179e30d4fc2&type=tcp&flow=xtls-rprx-vision&path=/";
-        let parsed_query = parse_vless_query(query);
-        assert_eq!(parsed_query.sni, "bench.sh");
-        assert_eq!(parsed_query.security, "reality");
-        assert_eq!(parsed_query.fp, "chrome");
-        assert_eq!(
-            parsed_query.pbk,
-            "7xhH4b_VkliBxGulljcyPOH-bYUA2dl-XAdZAsfhk04"
-        );
-        assert_eq!(parsed_query.sid, "6ba85179e30d4fc2");
-        assert_eq!(parsed_query.r#type, "tcp");
-        assert_eq!(parsed_query.flow, "xtls-rprx-vision");
-        assert_eq!(parsed_query.path, "/");
-        assert_eq!(parsed_query.encryption, "");
-        assert_eq!(parsed_query.header_type, "");
-        assert_eq!(parsed_query.host, "");
-        assert_eq!(parsed_query.seed, "");
-        assert_eq!(parsed_query.quic_security, "");
-        assert_eq!(parsed_query.key, "");
-        assert_eq!(parsed_query.mode, "");
-        assert_eq!(parsed_query.service_name, "");
-        assert_eq!(parsed_query.slpn, "");
-        assert_eq!(parsed_query.spx, "");
-    }
-
-    #[test]
-    fn parse_vless_query_with_defaults() {
-        let query = "";
-        let parsed_query = parse_vless_query(query);
-        assert_eq!(parsed_query.sni, "");
-        assert_eq!(parsed_query.security, "");
-        assert_eq!(parsed_query.fp, "");
-        assert_eq!(parsed_query.pbk, "");
-        assert_eq!(parsed_query.sid, "");
-        assert_eq!(parsed_query.r#type, "");
-        assert_eq!(parsed_query.r#flow, "");
-        assert_eq!(parsed_query.path, "");
-        assert_eq!(parsed_query.encryption, "");
-        assert_eq!(parsed_query.header_type, "");
-        assert_eq!(parsed_query.host, "");
-        assert_eq!(parsed_query.seed, "");
-        assert_eq!(parsed_query.quic_security, "");
-        assert_eq!(parsed_query.key, "");
-        assert_eq!(parsed_query.mode, "");
-        assert_eq!(parsed_query.service_name, "");
-        assert_eq!(parsed_query.slpn, "");
-        assert_eq!(parsed_query.spx, "");
-    }
-
-    #[test]
-    fn parse_vless_host() {
-        let raw_host = "uu0id@127.0.0.1:3012";
-        let parsed = parse_vless_address(raw_host);
-        assert_eq!(parsed.address, "127.0.0.1");
-        assert_eq!(parsed.port, 3012);
-        assert_eq!(parsed.uuid, "uu0id");
-    }
-
-    #[test]
-    fn parse_vless_ipv6_host() {
-        let v = "vless://4d91916f-a7fd-419b-8b90-640bb8d1b9f4@[2a06:98c1:3120::1]:443?path=%2FPSZPkYG71g6bn84o%2FMTQxLjE0OC4yMDMuNg&security=tls&alpn=http%2F1.1&encryption=none&host=titantablomanahamrah.ir&fp=randomized&type=ws&sni=TITanTabLOmaNAHaMRaH.IR#";
-        let raw_host = "uu0id@[2a06:98c1:3120::1]:443";
-        let parsed = parse_vless_address(raw_host);
-        assert_eq!(parsed.port, 443);
-        assert_eq!(parsed.address, "[2a06:98c1:3120::1]");
-        assert_eq!(parsed.uuid, "uu0id");
-    }
-
-    #[test]
-    fn create_outbound_for_tcp_reality() {
-        let v = "vless://3d2c2r05-y739-51e3-bd86-3f3f4950c183@tr.deet23ngdell.com:1818?security=reality&encryption=none&pbk=7xhH8b_VkliBxgulljcyPOH-bYoA2dl-XAdZAsfhk04&headerType=none&fp=chrome&type=tcp&flow=xtls-rprx-vision&sni=bench.sh&sid=6bt85979e30d4fc2#%F0%9F%87%B9%F0%9F%87%B7+H";
-        let data = get_vless_data(v);
-        let outbound_object = create_outbound_object(data);
-        let serialized = serde_json::to_string(&outbound_object).unwrap();
-
-        assert_eq!(
-            serialized,
-            r#"{"settings":{"vnext":[{"address":"tr.deet23ngdell.com","port":1818,"users":[{"id":"3d2c2r05-y739-51e3-bd86-3f3f4950c183","encryption":"none","flow":"xtls-rprx-vision","level":0}]}]},"streamSettings":{"network":"tcp","security":"reality","tlsSettings":null,"wsSettings":null,"tcpSettings":{"header":{"type":"none"},"acceptProxyProtocol":null},"realitySettings":{"fingerprint":"chrome","serverName":"bench.sh","publicKey":"7xhH8b_VkliBxgulljcyPOH-bYoA2dl-XAdZAsfhk04","shortId":"6bt85979e30d4fc2","spiderX":""},"grpcSettings":null,"quicSettings":null},"protocol":"vless","tag":"proxy"}"#
-        );
-    }
-}

src/parser/vless/models.rs

@@ -1,22 +1,25 @@
 pub struct VlessQuery {
-    pub security: String,
-    pub sni: String,
-    pub fp: String,
-    pub pbk: String,
-    pub sid: String,
-    pub r#type: String,
-    pub flow: String,
-    pub path: String,
-    pub encryption: String,
-    pub header_type: String,
-    pub host: String,
-    pub seed: String,
-    pub quic_security: String,
-    pub r#key: String,
-    pub mode: String,
-    pub service_name: String,
-    pub slpn: String,
-    pub spx: String,
+    pub security: Option<String>,
+    pub sni: Option<String>,
+    pub fp: Option<String>,
+    pub pbk: Option<String>,
+    pub sid: Option<String>,
+    pub r#type: Option<String>,
+    pub flow: Option<String>,
+    pub path: Option<String>,
+    pub encryption: Option<String>,
+    pub header_type: Option<String>,
+    pub host: Option<String>,
+    pub seed: Option<String>,
+    pub quic_security: Option<String>,
+    pub r#key: Option<String>,
+    pub mode: Option<String>,
+    pub service_name: Option<String>,
+    pub authority: Option<String>,
+    pub slpn: Option<String>,
+    pub spx: Option<String>,
+    pub alpn: Option<String>,
+    pub extra: Option<String>,
 }
 
 pub struct VlessAddress {

src/utils/mod.rs

@@ -1 +1,25 @@
 pub mod inbound_generator;
+
+pub fn url_decode(value: Option<String>) -> Option<String> {
+    return value.and_then(|s| {
+        urlencoding::decode(&s)
+            .ok()
+            .map(|decoded| decoded.into_owned())
+    });
+}
+
+pub fn parse_raw_json(input: &str) -> Option<serde_json::Value> {
+    serde_json::from_str::<serde_json::Value>(input)
+        .ok()
+        .and_then(|v| match v {
+            serde_json::Value::Object(_) => Some(v),
+            _ => None,
+        })
+}
+
+pub fn get_parameter_value(query: &Vec<(&str, &str)>, param: &str) -> Option<String> {
+    return query
+        .iter()
+        .find(|q| String::from(q.0) == String::from(param))
+        .map(|q| q.1.to_string());
+}