From 500f6ef21f781d6d0a6286edfcac4de741c96fbf Mon Sep 17 00:00:00 2001
From: "B. Blechschmidt" <git@blechschmidt.io>
Date: Mon, 10 Apr 2023 23:24:53 +0200
Subject: [PATCH 1/6] Add file descriptor support

---
 Cargo.toml       |  2 +-
 src/lib.rs       | 19 +++++++++++++++++--
 src/main.rs      |  5 +++--
 src/tun2proxy.rs | 11 ++++++++---
 tests/proxy.rs   |  4 ++--
 5 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 76e744a..2e85def 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,7 +20,7 @@ log = "0.4"
 mio = { version = "0.8", features = ["os-poll", "net", "os-ext"] }
 nix = { version = "0.26", features = ["process", "signal"] }
 prctl = "1.0"
-smoltcp = { version = "0.9", git = "https://github.com/smoltcp-rs/smoltcp.git", features = ["std"] }
+smoltcp = { version = "0.9", git = "https://github.com/blechschmidt/smoltcp", branch = "android", features = ["std"] }
 thiserror = "1.0"
 url = "2.3"
 
diff --git a/src/lib.rs b/src/lib.rs
index 5c2ad60..1f167a2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -18,6 +18,11 @@ pub struct Proxy {
     pub credentials: Option<Credentials>,
 }
 
+pub enum NetworkInterface {
+    Named(String),
+    Fd(std::os::fd::RawFd),
+}
+
 impl Proxy {
     pub fn from_url(s: &str) -> Result<Proxy, Error> {
         let e = format!("`{s}` is not a valid proxy URL");
@@ -83,6 +88,7 @@ impl std::fmt::Display for ProxyType {
 #[derive(Default)]
 pub struct Options {
     virtdns: Option<virtdns::VirtualDns>,
+    mtu: Option<usize>,
 }
 
 impl Options {
@@ -94,6 +100,11 @@ impl Options {
         self.virtdns = Some(virtdns::VirtualDns::new());
         self
     }
+
+    pub fn with_mtu(mut self, mtu: usize) -> Self {
+        self.mtu = Some(mtu);
+        self
+    }
 }
 
 #[derive(Default, Clone, Debug)]
@@ -111,8 +122,12 @@ impl Credentials {
     }
 }
 
-pub fn main_entry(tun: &str, proxy: &Proxy, options: Options) -> Result<(), Error> {
-    let mut ttp = TunToProxy::new(tun, options)?;
+pub fn main_entry(
+    interface: &NetworkInterface,
+    proxy: &Proxy,
+    options: Options,
+) -> Result<(), Error> {
+    let mut ttp = TunToProxy::new(interface, options)?;
     match proxy.proxy_type {
         ProxyType::Socks4 => {
             ttp.add_connection_manager(SocksManager::new(
diff --git a/src/main.rs b/src/main.rs
index d62913f..166012c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,8 +5,8 @@ use std::net::IpAddr;
 use std::process::ExitCode;
 
 use tun2proxy::error::Error;
-use tun2proxy::Options;
 use tun2proxy::{main_entry, Proxy};
+use tun2proxy::{NetworkInterface, Options};
 
 #[cfg(target_os = "linux")]
 use tun2proxy::setup::{get_default_cidrs, Setup};
@@ -89,7 +89,8 @@ fn main() -> ExitCode {
             }
         }
 
-        main_entry(&args.tun, &args.proxy, options)?;
+        let interface = NetworkInterface::Named(args.tun);
+        main_entry(&interface, &args.proxy, options)?;
 
         Ok(())
     })() {
diff --git a/src/tun2proxy.rs b/src/tun2proxy.rs
index b98f03a..3940e3a 100644
--- a/src/tun2proxy.rs
+++ b/src/tun2proxy.rs
@@ -1,6 +1,6 @@
 use crate::error::Error;
 use crate::virtdevice::VirtualTunDevice;
-use crate::{Credentials, Options};
+use crate::{Credentials, NetworkInterface, Options};
 use log::{error, info};
 use mio::event::Event;
 use mio::net::TcpStream;
@@ -260,8 +260,13 @@ pub(crate) struct TunToProxy<'a> {
 }
 
 impl<'a> TunToProxy<'a> {
-    pub(crate) fn new(interface: &str, options: Options) -> Result<Self, Error> {
-        let tun = TunTapInterface::new(interface, Medium::Ip)?;
+    pub(crate) fn new(interface: &NetworkInterface, options: Options) -> Result<Self, Error> {
+        let tun = match interface {
+            NetworkInterface::Named(name) => TunTapInterface::new(name.as_str(), Medium::Ip)?,
+            NetworkInterface::Fd(fd) => {
+                TunTapInterface::from_fd(*fd, Medium::Ip, options.mtu.unwrap_or(1500))?
+            }
+        };
         let poll = Poll::new()?;
         poll.registry().register(
             &mut SourceFd(&tun.as_raw_fd()),
diff --git a/tests/proxy.rs b/tests/proxy.rs
index 82589d7..8e1f71c 100644
--- a/tests/proxy.rs
+++ b/tests/proxy.rs
@@ -12,7 +12,7 @@ mod tests {
     use serial_test::serial;
 
     use tun2proxy::setup::{get_default_cidrs, Setup};
-    use tun2proxy::{main_entry, Options, Proxy, ProxyType};
+    use tun2proxy::{main_entry, NetworkInterface, Options, Proxy, ProxyType};
 
     #[derive(Clone, Debug)]
     struct Test {
@@ -85,7 +85,7 @@ mod tests {
                         Ok(Fork::Child) => {
                             prctl::set_death_signal(signal::SIGINT as isize).unwrap();
                             let _ = main_entry(
-                                TUN_TEST_DEVICE,
+                                &NetworkInterface::Named(TUN_TEST_DEVICE.into()),
                                 &test.proxy,
                                 Options::new().with_virtual_dns(),
                             );

From fb3ad33b53b12028ffbac8b5e466d024357802a9 Mon Sep 17 00:00:00 2001
From: "B. Blechschmidt" <git@blechschmidt.io>
Date: Thu, 13 Apr 2023 21:54:02 +0200
Subject: [PATCH 2/6] Add file descriptor and MTU to CLI arguments

---
 src/main.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/main.rs b/src/main.rs
index 166012c..43b128e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -19,6 +19,14 @@ struct Args {
     #[arg(short, long, value_name = "name", default_value = "tun0")]
     tun: String,
 
+    /// File descriptor of the tun interface
+    #[arg(long, value_name = "fd")]
+    tun_fd: Option<i32>,
+
+    /// MTU of the tun interface (only with tunnel file descriptor)
+    #[arg(long, value_name = "mtu", default_value = "1500")]
+    tun_mtu: usize,
+
     /// Proxy URL in the form proto://[username[:password]@]host:port
     #[arg(short, long, value_parser = Proxy::from_url, value_name = "URL")]
     proxy: Proxy,
@@ -67,6 +75,14 @@ fn main() -> ExitCode {
         options = options.with_virtual_dns();
     }
 
+    let interface = match args.tun_fd {
+        None => NetworkInterface::Named(args.tun.clone()),
+        Some(fd) => {
+            options = options.with_mtu(args.tun_mtu);
+            NetworkInterface::Fd(fd)
+        }
+    };
+
     if let Err(e) = (|| -> Result<(), Error> {
         #[cfg(target_os = "linux")]
         {
@@ -89,7 +105,6 @@ fn main() -> ExitCode {
             }
         }
 
-        let interface = NetworkInterface::Named(args.tun);
         main_entry(&interface, &args.proxy, options)?;
 
         Ok(())

From 62a04229db7c9570d650f708961b7a8ae56d0545 Mon Sep 17 00:00:00 2001
From: ssrlive <30760636+ssrlive@users.noreply.github.com>
Date: Fri, 14 Apr 2023 17:27:37 +0800
Subject: [PATCH 3/6] shutdown function

---
 src/lib.rs       |  4 ++++
 src/tun2proxy.rs | 21 ++++++++++++++++++++-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
index 1f167a2..c0a5c30 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -149,3 +149,7 @@ pub fn main_entry(
     }
     ttp.run()
 }
+
+pub fn shutdown() -> Result<(), Error> {
+    TunToProxy::shutdown()
+}
diff --git a/src/tun2proxy.rs b/src/tun2proxy.rs
index 3940e3a..4e17711 100644
--- a/src/tun2proxy.rs
+++ b/src/tun2proxy.rs
@@ -244,6 +244,9 @@ pub(crate) trait ConnectionManager {
 
 const TCP_TOKEN: Token = Token(0);
 const UDP_TOKEN: Token = Token(1);
+const EXIT_TOKEN: Token = Token(34255);
+
+const EXIT_LISTENER: &str = "127.0.0.1:34255";
 
 pub(crate) struct TunToProxy<'a> {
     tun: TunTapInterface,
@@ -257,6 +260,7 @@ pub(crate) struct TunToProxy<'a> {
     device: VirtualTunDevice,
     options: Options,
     write_sockets: HashSet<Token>,
+    _exit_listener: mio::net::TcpListener,
 }
 
 impl<'a> TunToProxy<'a> {
@@ -274,6 +278,10 @@ impl<'a> TunToProxy<'a> {
             Interest::READABLE,
         )?;
 
+        let mut _exit_listener = mio::net::TcpListener::bind(EXIT_LISTENER.parse()?)?;
+        poll.registry()
+            .register(&mut _exit_listener, EXIT_TOKEN, Interest::READABLE)?;
+
         let config = match tun.capabilities().medium {
             Medium::Ethernet => Config::new(
                 smoltcp::wire::EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]).into(),
@@ -305,6 +313,7 @@ impl<'a> TunToProxy<'a> {
             device: virt,
             options,
             write_sockets: HashSet::default(),
+            _exit_listener,
         };
         Ok(tun)
     }
@@ -762,6 +771,10 @@ impl<'a> TunToProxy<'a> {
                 Ok(()) => {
                     for event in events.iter() {
                         match event.token() {
+                            EXIT_TOKEN => {
+                                log::info!("exiting...");
+                                return Ok(());
+                            }
                             TCP_TOKEN => self.tun_event(event)?,
                             UDP_TOKEN => self.udp_event(event),
                             _ => self.mio_socket_event(event)?,
@@ -773,10 +786,16 @@ impl<'a> TunToProxy<'a> {
                     if e.kind() != std::io::ErrorKind::Interrupted {
                         return Err(e.into());
                     } else {
-                        log::warn!("Poll interrupted")
+                        log::warn!("Poll interrupted: {e}")
                     }
                 }
             }
         }
     }
+
+    pub(crate) fn shutdown() -> Result<(), Error> {
+        let addr: SocketAddr = EXIT_LISTENER.parse()?;
+        let _ = std::net::TcpStream::connect(addr)?;
+        Ok(())
+    }
 }

From 7442abece583b19ac21e8e858a70c665d25d0403 Mon Sep 17 00:00:00 2001
From: ssrlive <30760636+ssrlive@users.noreply.github.com>
Date: Fri, 14 Apr 2023 18:44:41 +0800
Subject: [PATCH 4/6] integrate to android

---
 Cargo.toml     |  4 +++
 src/android.rs | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/error.rs   |  7 +++++
 src/lib.rs     |  1 +
 4 files changed, 86 insertions(+)
 create mode 100644 src/android.rs

diff --git a/Cargo.toml b/Cargo.toml
index 2e85def..095ed9b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,10 @@ smoltcp = { version = "0.9", git = "https://github.com/blechschmidt/smoltcp", br
 thiserror = "1.0"
 url = "2.3"
 
+[target.'cfg(target_os="android")'.dependencies]
+android_logger = "0.13"
+jni = { version = "0.21", default-features = false }
+
 [dev-dependencies]
 ctor = "0.1"
 reqwest = { version = "0.11", features = ["blocking", "json"] }
diff --git a/src/android.rs b/src/android.rs
new file mode 100644
index 0000000..ea7f165
--- /dev/null
+++ b/src/android.rs
@@ -0,0 +1,74 @@
+#![cfg(target_os = "android")]
+
+use crate::{error::Error, main_entry, shutdown, NetworkInterface, Options, Proxy};
+use jni::{
+    objects::{JClass, JString},
+    sys::{jboolean, jint},
+    JNIEnv,
+};
+
+/// # Safety
+///
+/// Running tun2proxy
+#[no_mangle]
+pub unsafe extern "C" fn Java_com_github_shadowsocks_bg_Tun2proxy_run(
+    mut env: JNIEnv,
+    _clazz: JClass,
+    proxy_url: JString,
+    tun_fd: jint,
+    tun_mtu: jint,
+    verbose: jboolean,
+) -> jint {
+    let log_level = if verbose != 0 { "trace" } else { "info" };
+    let filter_str = &format!("off,tun2proxy={log_level}");
+    let filter = android_logger::FilterBuilder::new()
+        .parse(filter_str)
+        .build();
+    android_logger::init_once(
+        android_logger::Config::default()
+            .with_tag("tun2proxy")
+            .with_max_level(log::LevelFilter::Trace)
+            .with_filter(filter),
+    );
+
+    let mut block = || -> Result<(), Error> {
+        let proxy_url = get_java_string(&mut env, &proxy_url)?;
+        let proxy = Proxy::from_url(proxy_url)?;
+
+        let addr = proxy.addr;
+        let proxy_type = proxy.proxy_type;
+        log::info!("Proxy {proxy_type} server: {addr}");
+
+        let options = Options::new().with_virtual_dns().with_mtu(tun_mtu as usize);
+
+        let interface = NetworkInterface::Fd(tun_fd);
+        _ = main_entry(&interface, &proxy, options)?;
+        Ok::<(), Error>(())
+    };
+    if let Err(error) = block() {
+        log::error!("failed to run tun2proxy with error: {:?}", error);
+    }
+    0
+}
+
+/// # Safety
+///
+/// Shutdown tun2proxy
+#[no_mangle]
+pub unsafe extern "C" fn Java_com_github_shadowsocks_bg_Tun2proxy_stop(
+    _env: JNIEnv,
+    _clazz: JClass,
+) -> jint {
+    if let Err(e) = shutdown() {
+        log::error!("failed to shutdown tun2proxy with error: {:?}", e);
+        1
+    } else {
+        0
+    }
+}
+
+unsafe fn get_java_string<'a>(env: &'a mut JNIEnv, string: &'a JString) -> Result<&'a str, Error> {
+    let str_ptr = env.get_string(string)?.as_ptr();
+    let s: &str = std::ffi::CStr::from_ptr(str_ptr).to_str()?;
+    Ok(s)
+}
diff --git a/src/error.rs b/src/error.rs
index 0b48fcd..de014e8 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -27,6 +27,13 @@ pub enum Error {
     #[error("smoltcp::socket::tcp::SendError {0:?}")]
     Send(#[from] smoltcp::socket::tcp::SendError),
 
+    #[error("std::str::Utf8Error {0:?}")]
+    Utf8(#[from] std::str::Utf8Error),
+
+    #[cfg(target_os = "android")]
+    #[error("jni::errors::Error {0:?}")]
+    Jni(#[from] jni::errors::Error),
+
     #[error("&str {0}")]
     Str(String),
 
diff --git a/src/lib.rs b/src/lib.rs
index c0a5c30..6f5a740 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,6 +3,7 @@ use crate::socks5::SocksVersion;
 use crate::{http::HttpManager, socks5::SocksManager, tun2proxy::TunToProxy};
 use std::net::{SocketAddr, ToSocketAddrs};
 
+mod android;
 pub mod error;
 mod http;
 pub mod setup;

From cba6ba7318a7f3d41143326c1a72916cb2fd587d Mon Sep 17 00:00:00 2001
From: ssrlive <30760636+ssrlive@users.noreply.github.com>
Date: Sat, 15 Apr 2023 11:46:54 +0800
Subject: [PATCH 5/6] new_token function

---
 src/tun2proxy.rs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/tun2proxy.rs b/src/tun2proxy.rs
index 4e17711..7ceb256 100644
--- a/src/tun2proxy.rs
+++ b/src/tun2proxy.rs
@@ -244,7 +244,7 @@ pub(crate) trait ConnectionManager {
 
 const TCP_TOKEN: Token = Token(0);
 const UDP_TOKEN: Token = Token(1);
-const EXIT_TOKEN: Token = Token(34255);
+const EXIT_TOKEN: Token = Token(2);
 
 const EXIT_LISTENER: &str = "127.0.0.1:34255";
 
@@ -306,7 +306,7 @@ impl<'a> TunToProxy<'a> {
             poll,
             iface,
             connections: HashMap::default(),
-            next_token: 2,
+            next_token: usize::from(EXIT_TOKEN) + 1,
             token_to_connection: HashMap::default(),
             connection_managers: Vec::default(),
             sockets: SocketSet::new([]),
@@ -318,6 +318,12 @@ impl<'a> TunToProxy<'a> {
         Ok(tun)
     }
 
+    fn new_token(&mut self) -> Token {
+        let token = Token(self.next_token);
+        self.next_token += 1;
+        token
+    }
+
     pub(crate) fn add_connection_manager(&mut self, manager: Rc<dyn ConnectionManager>) {
         self.connection_managers.push(manager);
     }
@@ -509,8 +515,7 @@ impl<'a> TunToProxy<'a> {
 
                                 let client = TcpStream::connect(server)?;
 
-                                let token = Token(self.next_token);
-                                self.next_token += 1;
+                                let token = self.new_token();
 
                                 let mut state = ConnectionState {
                                     smoltcp_handle: handle,

From 0027c5ac4e36d5c765dd8c22ce4e18df47e2ba2f Mon Sep 17 00:00:00 2001
From: "B. Blechschmidt" <git@blechschmidt.io>
Date: Mon, 17 Apr 2023 22:37:39 +0200
Subject: [PATCH 6/6] Use smoltcp origin after feature merge

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 095ed9b..67bf2ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,7 +20,7 @@ log = "0.4"
 mio = { version = "0.8", features = ["os-poll", "net", "os-ext"] }
 nix = { version = "0.26", features = ["process", "signal"] }
 prctl = "1.0"
-smoltcp = { version = "0.9", git = "https://github.com/blechschmidt/smoltcp", branch = "android", features = ["std"] }
+smoltcp = { version = "0.9", git = "https://github.com/smoltcp-rs/smoltcp", features = ["std"] }
 thiserror = "1.0"
 url = "2.3"