Supply Proxy type to main_entry instead of individual args and adapt test cases

src/lib.rs

@@ -1,12 +1,64 @@
 use crate::tun2proxy::Credentials;
 use crate::{http::HttpManager, socks5::Socks5Manager, tun2proxy::TunToProxy};
-use std::net::SocketAddr;
+use std::net::{SocketAddr, ToSocketAddrs};
 
 pub mod http;
 pub mod socks5;
 pub mod tun2proxy;
 pub mod virtdevice;
 
+#[derive(Clone, Debug)]
+pub struct Proxy {
+    pub proxy_type: ProxyType,
+    pub addr: SocketAddr,
+    pub credentials: Option<Credentials>,
+}
+
+impl Proxy {
+    pub fn from_url(s: &str) -> Result<Proxy, String> {
+        let url = url::Url::parse(s).map_err(|_| format!("`{s}` is not a valid proxy URL"))?;
+        let host = url
+            .host_str()
+            .ok_or(format!("`{s}` does not contain a host"))?;
+
+        let mut url_host = String::from(host);
+        let port = url.port().ok_or(format!("`{s}` does not contain a port"))?;
+        url_host.push(':');
+        url_host.push_str(port.to_string().as_str());
+
+        let mut addr_iter = url_host
+            .to_socket_addrs()
+            .map_err(|_| format!("`{host}` could not be resolved"))?;
+
+        let addr = addr_iter
+            .next()
+            .ok_or(format!("`{host}` does not resolve to a usable IP address"))?;
+
+        let credentials = if url.username() == "" && url.password().is_none() {
+            None
+        } else {
+            let username = String::from(url.username());
+            let password = String::from(url.password().unwrap_or(""));
+            Some(Credentials::new(&username, &password))
+        };
+
+        let scheme = url.scheme();
+
+        let proxy_type = match url.scheme().to_ascii_lowercase().as_str() {
+            "socks5" => Some(ProxyType::Socks5),
+            "http" => Some(ProxyType::Http),
+            _ => None,
+        }
+        .ok_or(format!("`{scheme}` is an invalid proxy type"))?;
+
+        Ok(Proxy {
+            proxy_type,
+            addr,
+            credentials,
+        })
+    }
+}
+
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
 pub enum ProxyType {
     Socks5,
@@ -22,19 +74,14 @@ impl std::fmt::Display for ProxyType {
     }
 }
 
-pub fn main_entry(
-    tun: &str,
-    addr: SocketAddr,
-    proxy_type: ProxyType,
-    credentials: Option<Credentials>,
-) {
+pub fn main_entry(tun: &str, proxy: Proxy) {
     let mut ttp = TunToProxy::new(tun);
-    match proxy_type {
+    match proxy.proxy_type {
         ProxyType::Socks5 => {
-            ttp.add_connection_manager(Socks5Manager::new(addr, credentials));
+            ttp.add_connection_manager(Socks5Manager::new(proxy.addr, proxy.credentials));
         }
         ProxyType::Http => {
-            ttp.add_connection_manager(HttpManager::new(addr, credentials));
+            ttp.add_connection_manager(HttpManager::new(proxy.addr, proxy.credentials));
         }
     }
     ttp.run();

src/main.rs

@@ -1,10 +1,7 @@
-use std::net::{SocketAddr, ToSocketAddrs};
-
 use clap::Parser;
 use env_logger::Env;
 
-use tun2proxy::tun2proxy::Credentials;
-use tun2proxy::{main_entry, ProxyType};
+use tun2proxy::{main_entry, Proxy};
 
 /// Tunnel interface to proxy
 #[derive(Parser)]
@@ -15,58 +12,8 @@ struct Args {
     tun: String,
 
     /// The proxy URL in the form proto://[username[:password]@]host:port
-    #[arg(short, long = "proxy", value_parser = proxy_url_parser, value_name = "URL")]
-    proxy: ArgProxy,
-}
-
-#[derive(Clone)]
-struct ArgProxy {
-    proxy_type: ProxyType,
-    addr: SocketAddr,
-    credentials: Option<Credentials>,
-}
-
-fn proxy_url_parser(s: &str) -> Result<ArgProxy, String> {
-    let url = url::Url::parse(s).map_err(|_| format!("`{s}` is not a valid proxy URL"))?;
-    let host = url
-        .host_str()
-        .ok_or(format!("`{s}` does not contain a host"))?;
-
-    let mut url_host = String::from(host);
-    let port = url.port().ok_or(format!("`{s}` does not contain a port"))?;
-    url_host.push(':');
-    url_host.push_str(port.to_string().as_str());
-
-    let mut addr_iter = url_host
-        .to_socket_addrs()
-        .map_err(|_| format!("`{host}` could not be resolved"))?;
-
-    let addr = addr_iter
-        .next()
-        .ok_or(format!("`{host}` does not resolve to a usable IP address"))?;
-
-    let credentials = if url.username() == "" && url.password().is_none() {
-        None
-    } else {
-        let username = String::from(url.username());
-        let password = String::from(url.password().unwrap_or(""));
-        Some(Credentials::new(&username, &password))
-    };
-
-    let scheme = url.scheme();
-
-    let proxy_type = match url.scheme().to_ascii_lowercase().as_str() {
-        "socks5" => Some(ProxyType::Socks5),
-        "http" => Some(ProxyType::Http),
-        _ => None,
-    }
-    .ok_or(format!("`{scheme}` is an invalid proxy type"))?;
-
-    Ok(ArgProxy {
-        proxy_type,
-        addr,
-        credentials,
-    })
+    #[arg(short, long = "proxy", value_parser = Proxy::from_url, value_name = "URL")]
+    proxy: Proxy,
 }
 
 fn main() {
@@ -77,5 +24,5 @@ fn main() {
     let proxy_type = args.proxy.proxy_type;
     log::info!("Proxy {proxy_type} server: {addr}");
 
-    main_entry(&args.tun, addr, proxy_type, args.proxy.credentials);
+    main_entry(&args.tun, args.proxy);
 }

src/tun2proxy.rs

@@ -162,7 +162,7 @@ struct ConnectionState {
     handler: std::boxed::Box<dyn TcpProxy>,
 }
 
-#[derive(Default, Clone)]
+#[derive(Default, Clone, Debug)]
 pub struct Credentials {
     pub(crate) username: Vec<u8>,
     pub(crate) password: Vec<u8>,