Feature/remove panics

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rayconf"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2024"
 
 [dependencies]

src/cmd/perf.rs

@@ -103,7 +103,7 @@ impl PerfParams {
 
         let result = portman
             .lease_port(async move |port| -> anyhow::Result<Duration> {
-                let config_json = create_json_config(url.as_str(), Some(port), None, None);
+                let config_json = create_json_config(url.as_str(), Some(port), None, None)?;
                 let mut command = self.run_xray(config_json).await?;
                 let measure_result = ProxiedClient::try_new(PROXY_HOST, port, PROXY_TEST_TIMEOUT)?
                     .measure_first_successful(

src/cmd/select.rs

@@ -215,7 +215,7 @@ impl SelectParams {
         };
 
         let config_json =
-            create_json_config(url.as_str(), socks_port, http_port, Some(self.get_log()));
+            create_json_config(url.as_str(), socks_port, http_port, Some(self.get_log()))?;
 
         match self.dry_run {
             true => {

src/utils/mod.rs

@@ -1,2 +1,3 @@
 pub(crate) mod tap;
+pub(crate) mod to_err;
 pub(crate) mod urldecode;

src/utils/to_err.rs

@@ -0,0 +1,15 @@
+pub(crate) trait ToAnyhow<T> {
+    fn anyhow(self, description: &'static str) -> anyhow::Result<T>;
+}
+
+impl<T> ToAnyhow<T> for Option<T> {
+    fn anyhow(self, description: &'static str) -> anyhow::Result<T> {
+        self.ok_or_else(|| anyhow::Error::msg(description))
+    }
+}
+
+impl<T, E> ToAnyhow<T> for Result<T, E> {
+    fn anyhow(self, description: &'static str) -> anyhow::Result<T> {
+        self.map_err(|_| anyhow::Error::msg(description))
+    }
+}

src/v2parser/parser/mod.rs

@@ -17,6 +17,7 @@ use crate::v2parser::entities::xhttp_settings::XHTTPSettings;
 use crate::v2parser::utils::inbound_generator::{
     InboundGenerationOptions, generate_inbound_config,
 };
+use crate::v2parser::utils::incorrect_uri::IncorrectURI;
 use crate::v2parser::utils::parse_raw_json;
 
 mod shadow_socks;
@@ -45,19 +46,19 @@ pub fn create_json_config(
     socks_port: Option<u16>,
     http_port: Option<u16>,
     log: Option<Log>,
-) -> String {
-    let config = create_config(uri, socks_port, http_port, log);
-    let serialized = serde_json::to_string_pretty(&config).unwrap();
-    return serialized;
+) -> anyhow::Result<String> {
+    let config = create_config(uri, socks_port, http_port, log)?;
+    let serialized = serde_json::to_string_pretty(&config)?;
+    return Ok(serialized);
 }
 
 fn create_config(
     uri: &str,
     socks_port: Option<u16>,
     http_port: Option<u16>,
     log: Option<Log>,
-) -> Config {
-    let outbound_object = create_outbound_object(uri);
+) -> anyhow::Result<Config> {
+    let outbound_object = create_outbound_object(uri)?;
     let inbound_config = generate_inbound_config(InboundGenerationOptions {
         socks_port,
         http_port,
@@ -67,11 +68,11 @@ fn create_config(
         outbounds: vec![outbound_object],
         inbounds: inbound_config,
     };
-    return config;
+    return Ok(config);
 }
 
-fn create_outbound_object(uri: &str) -> Outbound {
-    let (name, data, outbound_settings) = get_uri_data(uri);
+fn create_outbound_object(uri: &str) -> anyhow::Result<Outbound> {
+    let (name, data, outbound_settings) = get_uri_data(uri)?;
 
     let network_type = data.r#type.clone().unwrap_or(String::from(""));
     let allow_insecure = data.allow_insecure == Some(String::from("true"))
@@ -178,42 +179,96 @@ fn create_outbound_object(uri: &str) -> Outbound {
         settings: outbound_settings,
     };
 
-    return outbound;
+    return Ok(outbound);
 }
 
-fn get_uri_data(uri: &str) -> (String, RawData, OutboundSettings) {
+fn get_uri_data(uri: &str) -> anyhow::Result<(String, RawData, OutboundSettings)> {
     let protocol = uri_identifier::get_uri_protocol(uri);
     return match protocol {
         Some(uri_identifier::Protocols::Vless) => {
-            let d = vless::data::get_data(uri);
+            let d = vless::data::get_data(uri).incorrect_uri()?;
             let s = vless::create_outbound_settings(&d);
-            (String::from("vless"), d, s)
+            Ok((String::from("vless"), d, s))
         }
         Some(uri_identifier::Protocols::Vmess) => {
-            let d = vmess::data::get_data(uri);
+            let d = vmess::data::get_data(uri)?;
             let s = vmess::create_outbound_settings(&d);
-            (String::from("vmess"), d, s)
+            Ok((String::from("vmess"), d, s))
         }
         Some(uri_identifier::Protocols::Trojan) => {
-            let d = trojan::data::get_data(uri);
+            let d = trojan::data::get_data(uri)?;
             let s = trojan::create_outbound_settings(&d);
-            (String::from("trojan"), d, s)
+            Ok((String::from("trojan"), d, s))
         }
         Some(uri_identifier::Protocols::Shadowsocks) => {
-            let d = shadow_socks::data::get_data(uri);
+            let d = shadow_socks::data::get_data(uri)?;
             let s = shadow_socks::create_outbound_settings(&d);
-            (String::from("shadowsocks"), d, s)
+            Ok((String::from("shadowsocks"), d, s))
         }
         Some(uri_identifier::Protocols::Socks) => {
-            let d = socks::data::get_data(uri);
+            let d = socks::data::get_data(uri)?;
             let s = socks::create_outbound_settings(&d);
-            (String::from("socks"), d, s)
+            Ok((String::from("socks"), d, s))
         }
         Some(_) => {
-            panic!("The protocol was recognized but is not supported yet");
+            anyhow::bail!("The protocol was recognized but is not supported yet");
         }
         None => {
-            panic!("The protocol is not supported");
+            anyhow::bail!("The protocol is not supported")
         }
     };
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_uri_data_vless() {
+        let uri = "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";
+        let (name, _data, _settings) = get_uri_data(uri).unwrap();
+        assert_eq!(name, "vless");
+    }
+
+    #[test]
+    fn test_get_uri_data_vmess() {
+        let uri = "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIwIiwiaG9zdCI6IiIsImlkIjoiOHM2OTdlMmMtZXMxNy00MDNkLTI0ZjMtZHMyYzYwc2I4ZjUiLCJuZXQiOiJ0Y3AiLCJwYXRoIjoiIiwicG9ydCI6IjgwODAiLCJwcyI6InRlc3QiLCJzY3kiOiJhdXRvIiwic25pIjoiIiwidGxzIjoiIiwidHlwZSI6Im5vbmUiLCJ2IjoiMiJ9";
+        let (name, _data, _settings) = get_uri_data(uri).unwrap();
+        assert_eq!(name, "vmess");
+    }
+
+    #[test]
+    fn test_get_uri_data_trojan() {
+        let uri = "trojan://test-pw@13.50.100.84:22222?security=tls&sni=trj.rollingnext.co.uk&type=tcp#test";
+        let (name, _data, _settings) = get_uri_data(uri).unwrap();
+        assert_eq!(name, "trojan");
+    }
+
+    #[test]
+    fn test_get_uri_data_shadowsocks() {
+        let uri = "ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpXNzRYRkFMS0t1dzZtNUlB@www.outline.aasf.cyou:443#test";
+        let (name, _data, _settings) = get_uri_data(uri).unwrap();
+        assert_eq!(name, "shadowsocks");
+    }
+
+    #[test]
+    fn test_get_uri_data_socks() {
+        let uri = "socks5://username:password@127.0.0.1:1080";
+        let (name, _data, _settings) = get_uri_data(uri).unwrap();
+        assert_eq!(name, "socks");
+    }
+
+    #[test]
+    fn test_get_uri_data_http_unimplemented() {
+        let uri = "http://example.com";
+        let res = get_uri_data(uri);
+        assert_eq!(res.is_ok(), false);
+    }
+
+    #[test]
+    fn test_get_uri_data_unknown() {
+        let uri = "ftp://example.com";
+        let res = get_uri_data(uri);
+        assert_eq!(res.is_ok(), false);
+    }
+}

src/v2parser/parser/shadow_socks/data.rs

@@ -1,16 +1,17 @@
 use http::Uri;
 
-use base64::{engine::general_purpose, Engine};
 use crate::v2parser::entities::raw_data::RawData;
 use crate::v2parser::parser::shadow_socks::models::ShadowSocksAddress;
+use crate::v2parser::utils::incorrect_uri::IncorrectURI;
 use crate::v2parser::utils::{url_decode, url_decode_str};
+use base64::{Engine, engine::general_purpose};
 
-pub fn get_data(uri: &str) -> RawData {
-    let data = uri.split_once("ss://").unwrap().1;
+pub fn get_data(uri: &str) -> anyhow::Result<RawData> {
+    let data = uri.split_once("ss://").incorrect_uri()?.1;
     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 {
+    let parsed_address = parse_ss_address(raw_uri)?;
+    let raw_data = 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),
@@ -41,18 +42,20 @@ pub fn get_data(uri: &str) -> RawData {
         vnext_security: None,
         username: None,
     };
+
+    Ok(raw_data)
 }
 
-fn parse_ss_address(raw_data: &str) -> ShadowSocksAddress {
+fn parse_ss_address(raw_data: &str) -> anyhow::Result<ShadowSocksAddress> {
     let (userinfo, raw_address): (String, &str) = match raw_data.split_once("@") {
         None => {
-            panic!("Wrong shadowsocks format, no `@` found in the address");
+            anyhow::bail!("Wrong shadowsocks 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();
+    let parsed = address_wo_slash.parse::<Uri>().incorrect_uri()?;
 
     let method_and_password = general_purpose::STANDARD
         .decode(url_decode_str(&userinfo).unwrap_or(userinfo))
@@ -63,10 +66,66 @@ fn parse_ss_address(raw_data: &str) -> ShadowSocksAddress {
         .split_once(":")
         .expect("No `:` found in the decoded base64");
 
-    return ShadowSocksAddress {
+    return Ok(ShadowSocksAddress {
         method: String::from(method),
         password: String::from(password),
-        address: parsed.host().unwrap().to_string(),
-        port: parsed.port().unwrap().as_u16(),
-    };
+        address: parsed.host().incorrect_uri()?.to_string(),
+        port: parsed.port().incorrect_uri()?.as_u16(),
+    });
+}
+
+// Tests for the internal `parse_ss_address` function
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use base64::{Engine, engine::general_purpose};
+    use urlencoding;
+
+    #[test]
+    fn errors_when_missing_at_symbol() {
+        let raw = "example.com:8388";
+        let result = parse_ss_address(&raw);
+        assert!(result.is_err());
+    }
+
+    fn encode_userinfo(method: &str, password: &str) -> String {
+        let combined = format!("{}:{}", method, password);
+        general_purpose::STANDARD.encode(combined.as_bytes())
+    }
+
+    #[test]
+    fn parses_basic_address_without_trailing_slash() {
+        let method = "aes-256-cfb";
+        let password = "myPass";
+        let userinfo = encode_userinfo(method, password);
+        let raw = format!("{}@example.com:8388", userinfo);
+        let result = parse_ss_address(&raw).unwrap();
+        assert_eq!(result.method, method);
+        assert_eq!(result.password, password);
+        assert_eq!(result.address, "example.com");
+        assert_eq!(result.port, 8388);
+    }
+
+    #[test]
+    fn parses_address_with_trailing_slash() {
+        let method = "aes-256-cfb";
+        let password = "myPass";
+        let userinfo = encode_userinfo(method, password);
+        let raw = format!("{}@example.com:8388/", userinfo);
+        let result = parse_ss_address(&raw).unwrap();
+        assert_eq!(result.address, "example.com");
+        assert_eq!(result.port, 8388);
+    }
+
+    #[test]
+    fn parses_percent_encoded_userinfo() {
+        let method = "aes-256-cfb";
+        let password = "myPass";
+        let userinfo = encode_userinfo(method, password);
+        let encoded = urlencoding::encode(&userinfo).into_owned();
+        let raw = format!("{}@example.com:8388", encoded);
+        let result = parse_ss_address(&raw).unwrap();
+        assert_eq!(result.method, method);
+        assert_eq!(result.password, password);
+    }
 }