refactor FFI

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tun2proxy"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -23,7 +23,7 @@ ipstack = { version = "0.0", features = ["log"] }
 log = { version = "0.4", features = ["std"] }
 socks5-impl = { version = "0.5" }
 thiserror = "1.0"
-tokio = { version = "1.35", features = ["full"] }
+tokio = { version = "1.36", features = ["full"] }
 tproxy-config = { version = "0.1", features = ["log"] }
 trust-dns-proto = "0.23"
 tun2 = { version = "1.0", features = ["async"] }

apple/readme.md

@@ -17,5 +17,5 @@ cd tun2proxy
 cargo build --release --target aarch64-apple-ios
 cargo build --release --target x86_64-apple-ios
 lipo -create target/aarch64-apple-ios/release/libtun2proxy.a target/x86_64-apple-ios/release/libtun2proxy.a -output target/libtun2proxy.a
-cbindgen --config cbindgen.toml -l C -o target/tun2proxy-sys.h
+cbindgen --config cbindgen.toml -l C -o target/tun2proxy-ffi.h
 ```

apple/tun2proxy.xcodeproj/project.pbxproj

@@ -161,7 +161,7 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/bash;
-			shellScript = "set -e\nPATH=\"$PATH:${HOME}/.cargo/bin\"\nRUST_PROJ=${PROJECT_DIR}/..\ncd \"${RUST_PROJ}\"\ncargo build --release --target aarch64-apple-ios\ncargo build --release --target x86_64-apple-ios\nlipo -create target/aarch64-apple-ios/release/libtun2proxy.a target/x86_64-apple-ios/release/libtun2proxy.a -output target/libtun2proxy.a\ncbindgen --config cbindgen.toml -l C -o target/tun2proxy-sys.h\n";
+			shellScript = "set -e\nPATH=\"$PATH:${HOME}/.cargo/bin\"\nRUST_PROJ=${PROJECT_DIR}/..\ncd \"${RUST_PROJ}\"\ncargo build --release --target aarch64-apple-ios\ncargo build --release --target x86_64-apple-ios\nlipo -create target/aarch64-apple-ios/release/libtun2proxy.a target/x86_64-apple-ios/release/libtun2proxy.a -output target/libtun2proxy.a\ncbindgen --config cbindgen.toml -l C -o target/tun2proxy-ffi.h\n";
 		};
 /* End PBXShellScriptBuildPhase section */
 

apple/tun2proxy/Tun2proxyWrapper.m

@@ -8,16 +8,16 @@
 #import <Foundation/Foundation.h>
 
 #import "Tun2proxyWrapper.h"
-#include "tun2proxy-sys.h"
+#include "tun2proxy-ffi.h"
 
 @implementation Tun2proxyWrapper
 
 + (void)startWithConfig:(NSString *)proxy_url
                  tun_fd:(int)tun_fd
                 tun_mtu:(uint32_t)tun_mtu
-           dns_over_tcp:(bool)dns_over_tcp
-                verbose:(bool)verbose {
-  tun2proxy_run(proxy_url.UTF8String, tun_fd, tun_mtu, dns_over_tcp, verbose);
+           dns_strategy:(ArgDns)dns_strategy
+              verbosity:(ArgVerbosity)verbosity {
+  tun2proxy_run(proxy_url.UTF8String, tun_fd, tun_mtu, dns_strategy, verbosity);
 }
 
 + (void)shutdown {

src/android.rs

@@ -1,13 +1,13 @@
 #![cfg(target_os = "android")]
 
 use crate::{
-    args::{ArgDns, ArgProxy},
+    args::ArgProxy,
     error::{Error, Result},
-    ArgVerbosity, Args,
+    Args,
 };
 use jni::{
     objects::{JClass, JString},
-    sys::{jboolean, jint},
+    sys::jint,
     JNIEnv,
 };
 
@@ -21,11 +21,11 @@ pub unsafe extern "C" fn Java_com_github_shadowsocks_bg_Tun2proxy_run(
     proxy_url: JString,
     tun_fd: jint,
     tun_mtu: jint,
-    verbose: jboolean,
-    dns_over_tcp: jboolean,
+    verbosity: jint,
+    dns_strategy: jint,
 ) -> jint {
-    let dns = if dns_over_tcp != 0 { ArgDns::OverTcp } else { ArgDns::Direct };
-    let verbosity = if verbose != 0 { ArgVerbosity::Trace } else { ArgVerbosity::Info };
+    let dns = dns_strategy.try_into().unwrap();
+    let verbosity = verbosity.try_into().unwrap();
     let filter_str = &format!("off,tun2proxy={verbosity}");
     let filter = android_logger::FilterBuilder::new().parse(filter_str).build();
     android_logger::init_once(

src/args.rs

@@ -81,9 +81,10 @@ impl Args {
     }
 }
 
+#[repr(C)]
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
 pub enum ArgVerbosity {
-    Off,
+    Off = 0,
     Error,
     Warn,
     #[default]
@@ -92,6 +93,47 @@ pub enum ArgVerbosity {
     Trace,
 }
 
+#[cfg(target_os = "android")]
+impl TryFrom<jni::sys::jint> for ArgVerbosity {
+    type Error = Error;
+    fn try_from(value: jni::sys::jint) -> Result<Self> {
+        match value {
+            0 => Ok(ArgVerbosity::Off),
+            1 => Ok(ArgVerbosity::Error),
+            2 => Ok(ArgVerbosity::Warn),
+            3 => Ok(ArgVerbosity::Info),
+            4 => Ok(ArgVerbosity::Debug),
+            5 => Ok(ArgVerbosity::Trace),
+            _ => Err(Error::from("Invalid verbosity level")),
+        }
+    }
+}
+
+impl From<ArgVerbosity> for log::LevelFilter {
+    fn from(verbosity: ArgVerbosity) -> Self {
+        match verbosity {
+            ArgVerbosity::Off => log::LevelFilter::Off,
+            ArgVerbosity::Error => log::LevelFilter::Error,
+            ArgVerbosity::Warn => log::LevelFilter::Warn,
+            ArgVerbosity::Info => log::LevelFilter::Info,
+            ArgVerbosity::Debug => log::LevelFilter::Debug,
+            ArgVerbosity::Trace => log::LevelFilter::Trace,
+        }
+    }
+}
+
+impl From<log::Level> for ArgVerbosity {
+    fn from(level: log::Level) -> Self {
+        match level {
+            log::Level::Error => ArgVerbosity::Error,
+            log::Level::Warn => ArgVerbosity::Warn,
+            log::Level::Info => ArgVerbosity::Info,
+            log::Level::Debug => ArgVerbosity::Debug,
+            log::Level::Trace => ArgVerbosity::Trace,
+        }
+    }
+}
+
 impl std::fmt::Display for ArgVerbosity {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
@@ -109,14 +151,28 @@ impl std::fmt::Display for ArgVerbosity {
 /// - Virtual: Use a virtual DNS server to handle DNS queries, also known as Fake-IP mode
 /// - OverTcp: Use TCP to send DNS queries to the DNS server
 /// - Direct: Do not handle DNS by relying on DNS server bypassing
+#[repr(C)]
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
 pub enum ArgDns {
-    Virtual,
+    Virtual = 0,
     OverTcp,
     #[default]
     Direct,
 }
 
+#[cfg(target_os = "android")]
+impl TryFrom<jni::sys::jint> for ArgDns {
+    type Error = Error;
+    fn try_from(value: jni::sys::jint) -> Result<Self> {
+        match value {
+            0 => Ok(ArgDns::Virtual),
+            1 => Ok(ArgDns::OverTcp),
+            2 => Ok(ArgDns::Direct),
+            _ => Err(Error::from("Invalid DNS strategy")),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct ArgProxy {
     pub proxy_type: ProxyType,

src/bin/main.rs

@@ -62,7 +62,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         tproxy_config::tproxy_setup(&tproxy_args)?;
     }
 
-    let tun2proxy = Builder::new(device, args).mtu(MTU).build();
+    let tun2proxy = Builder::new(device, args).mtu(MTU as _).build();
     let (join_handle, quit) = tun2proxy.start();
 
     ctrlc2::set_async_handler(async move {

src/dump_logger.rs

@@ -1,5 +1,6 @@
+use crate::ArgVerbosity;
 use std::{
-    os::raw::{c_char, c_int, c_void},
+    os::raw::{c_char, c_void},
     sync::Mutex,
 };
 
@@ -10,17 +11,17 @@ pub(crate) static DUMP_CALLBACK: Mutex<Option<DumpCallback>> = Mutex::new(None);
 /// set dump log info callback.
 #[no_mangle]
 pub unsafe extern "C" fn tun2proxy_set_log_callback(
-    callback: Option<unsafe extern "C" fn(c_int, *const c_char, *mut c_void)>,
+    callback: Option<unsafe extern "C" fn(ArgVerbosity, *const c_char, *mut c_void)>,
     ctx: *mut c_void,
 ) {
     *DUMP_CALLBACK.lock().unwrap() = Some(DumpCallback(callback, ctx));
 }
 
 #[derive(Clone)]
-pub struct DumpCallback(Option<unsafe extern "C" fn(c_int, *const c_char, *mut c_void)>, *mut c_void);
+pub struct DumpCallback(Option<unsafe extern "C" fn(ArgVerbosity, *const c_char, *mut c_void)>, *mut c_void);
 
 impl DumpCallback {
-    unsafe fn call(self, dump_level: c_int, info: *const c_char) {
+    unsafe fn call(self, dump_level: ArgVerbosity, info: *const c_char) {
         if let Some(cb) = self.0 {
             cb(dump_level, info, self.1);
         }
@@ -64,7 +65,7 @@ impl DumpLogger {
         let ptr = c_msg.as_ptr();
         if let Some(cb) = DUMP_CALLBACK.lock().unwrap().clone() {
             unsafe {
-                cb.call(record.level() as c_int, ptr);
+                cb.call(record.level().into(), ptr);
             }
         }
     }

src/ios.rs

@@ -14,20 +14,16 @@ pub unsafe extern "C" fn tun2proxy_run(
     proxy_url: *const c_char,
     tun_fd: c_int,
     tun_mtu: c_uint,
-    dns_over_tcp: c_char,
-    verbose: c_char,
+    dns_strategy: ArgDns,
+    verbosity: ArgVerbosity,
 ) -> c_int {
-    use log::LevelFilter;
-    let log_level = if verbose != 0 { LevelFilter::Trace } else { LevelFilter::Info };
-    log::set_max_level(log_level);
+    log::set_max_level(verbosity.into());
     log::set_boxed_logger(Box::<crate::dump_logger::DumpLogger>::default()).unwrap();
 
-    let dns = if dns_over_tcp != 0 { ArgDns::OverTcp } else { ArgDns::Direct };
-    let verbosity = if verbose != 0 { ArgVerbosity::Trace } else { ArgVerbosity::Info };
     let proxy_url = std::ffi::CStr::from_ptr(proxy_url).to_str().unwrap();
     let proxy = ArgProxy::from_url(proxy_url).unwrap();
 
-    let args = Args::new(Some(tun_fd), proxy, dns, verbosity);
+    let args = Args::new(Some(tun_fd), proxy, dns_strategy, verbosity);
 
     crate::api::tun2proxy_internal_run(args, tun_mtu as _)
 }