Enable tvOS support (#117)

* added tvos

* store address and netmask for Android tun device

* update ios asyc device

* bump version

* no message

* update errors

* mode logs

* remove logs, bump version

* some cleanup

* fix clippy and format error

* add ci to build on tvos

* minor changes

---------

Co-authored-by: Enoch Carter <[email protected]>
Co-authored-by: Thomas Yau <[email protected]>

Author: 3 people

.cargo/config.toml

@@ -2,6 +2,7 @@
 protocol = "sparse"
 
 [build]
+# target = ["aarch64-apple-tvos"]
 # target = ["x86_64-unknown-linux-musl"]
 # target = ["x86_64-unknown-linux-gnu"]
 # target = ["aarch64-linux-android"] # arm64-v8a 

.github/workflows/rust.yml

@@ -85,6 +85,29 @@ jobs:
       if: ${{ failure() }}
       run: echo "iOS build job failed" && false
 
+  build_n_test_tvos:
+    strategy:
+      matrix:
+        target: [aarch64-apple-tvos, aarch64-apple-tvos-sim, x86_64-apple-tvos]
+      fail-fast: false
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@nightly
+      with:
+        components: clippy, rust-src
+    - name: clippy
+      if: ${{ !cancelled() }}
+      run: cargo +nightly clippy -Zbuild-std --target ${{matrix.target}} --all-features --features="async tokio/rt-multi-thread" -- -D warnings
+    - name: Build
+      if: ${{ !cancelled() }}
+      run: |
+        cargo +nightly build -Zbuild-std --verbose --target ${{matrix.target}} --all-features --features="async tokio/rt-multi-thread"
+    - name: Abort on error
+      if: ${{ failure() }}
+      run: echo "tvOS build job failed" && false
+
   build_n_test_openharmony:
     strategy:
       matrix:

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tun"
-version = "0.7.13"
+version = "0.7.17"
 edition = "2024"
 authors = ["meh. <[email protected]>", "@ssrlive"]
 license = "WTFPL"

src/error.rs

@@ -80,7 +80,7 @@ impl From<Error> for std::io::Error {
     fn from(value: Error) -> Self {
         match value {
             Error::Io(err) => err,
-            _ => std::io::Error::new(std::io::ErrorKind::Other, value),
+            _ => std::io::Error::other(value),
         }
     }
 }

src/platform/android/device.rs

@@ -13,18 +13,19 @@
 //  0. You just DO WHAT THE FUCK YOU WANT TO.
 #![allow(unused_variables)]
 
-use std::io::{Read, Write};
-use std::net::IpAddr;
-use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
-
 use crate::configuration::Configuration;
 use crate::device::AbstractDevice;
 use crate::error::{Error, Result};
 use crate::platform::posix::{self, Fd, Tun};
+use std::io::{Read, Write};
+use std::net::IpAddr;
+use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd};
 
 /// A TUN device for Android.
 pub struct Device {
     pub(crate) tun: Tun,
+    pub(crate) address: Option<IpAddr>,
+    pub(crate) netmask: Option<IpAddr>,
 }
 
 impl AsRef<dyn AbstractDevice + 'static> for Device {
@@ -53,6 +54,8 @@ impl Device {
 
             Device {
                 tun: Tun::new(tun, mtu, false),
+                address: config.address,
+                netmask: config.netmask,
             }
         };
 
@@ -114,7 +117,7 @@ impl AbstractDevice for Device {
     }
 
     fn address(&self) -> Result<IpAddr> {
-        Err(Error::NotImplemented)
+        self.address.ok_or(Error::NotImplemented)
     }
 
     fn set_address(&mut self, _value: IpAddr) -> Result<()> {
@@ -138,7 +141,7 @@ impl AbstractDevice for Device {
     }
 
     fn netmask(&self) -> Result<IpAddr> {
-        Err(Error::NotImplemented)
+        self.netmask.ok_or(Error::NotImplemented)
     }
 
     fn set_netmask(&mut self, _value: IpAddr) -> Result<()> {

src/platform/ios/device.rs

@@ -28,6 +28,9 @@ use std::{
 /// A TUN device for iOS.
 pub struct Device {
     pub(crate) tun: Tun,
+    pub(crate) address: Option<IpAddr>,
+    pub(crate) netmask: Option<IpAddr>,
+    pub(crate) tun_name: Option<String>,
 }
 
 impl AsRef<dyn AbstractDevice + 'static> for Device {
@@ -55,6 +58,9 @@ impl Device {
             let fd = Fd::new(fd, close_fd_on_drop).map_err(|_| std::io::Error::last_os_error())?;
             Device {
                 tun: Tun::new(fd, mtu, config.platform_config.packet_information),
+                address: config.address,
+                netmask: config.netmask,
+                tun_name: config.tun_name.clone(),
             }
         };
 
@@ -108,47 +114,47 @@ impl Write for Device {
 
 impl AbstractDevice for Device {
     fn tun_index(&self) -> Result<i32> {
-        Err(Error::NotImplemented)
+        Err("no tun_index".into())
     }
 
     fn tun_name(&self) -> Result<String> {
-        Ok("".to_string())
+        Ok(self.tun_name.clone().unwrap_or("".to_string()))
     }
 
     fn set_tun_name(&mut self, value: &str) -> Result<()> {
-        Err(Error::NotImplemented)
+        Err("set_tun_name".into())
     }
 
     fn enabled(&mut self, value: bool) -> Result<()> {
         Ok(())
     }
 
     fn address(&self) -> Result<IpAddr> {
-        Err(Error::NotImplemented)
+        self.address.ok_or("no address".into())
     }
 
     fn set_address(&mut self, _value: IpAddr) -> Result<()> {
         Ok(())
     }
 
     fn destination(&self) -> Result<IpAddr> {
-        Err(Error::NotImplemented)
+        Err("no destination".into())
     }
 
     fn set_destination(&mut self, _value: IpAddr) -> Result<()> {
         Ok(())
     }
 
     fn broadcast(&self) -> Result<IpAddr> {
-        Err(Error::NotImplemented)
+        Err("no broadcast".into())
     }
 
     fn set_broadcast(&mut self, _value: IpAddr) -> Result<()> {
         Ok(())
     }
 
     fn netmask(&self) -> Result<IpAddr> {
-        Err(Error::NotImplemented)
+        self.netmask.ok_or("no netmask".into())
     }
 
     fn set_netmask(&mut self, _value: IpAddr) -> Result<()> {

src/platform/mod.rs

@@ -34,9 +34,9 @@ pub(crate) mod macos;
 #[cfg(target_os = "macos")]
 pub use self::macos::{Device, PlatformConfig, create};
 
-#[cfg(target_os = "ios")]
+#[cfg(any(target_os = "ios", target_os = "tvos"))]
 pub(crate) mod ios;
-#[cfg(target_os = "ios")]
+#[cfg(any(target_os = "ios", target_os = "tvos"))]
 pub use self::ios::{Device, PlatformConfig, create};
 
 #[cfg(target_os = "android")]

src/platform/posix/split.rs

@@ -41,9 +41,9 @@ pub(crate) fn generate_packet_information(
     #[cfg(any(target_os = "linux", target_os = "android"))]
     const TUN_PROTO_IP4: [u8; PIL] = (libc::ETH_P_IP as u32).to_be_bytes();
 
-    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    #[cfg(any(target_os = "macos", target_os = "ios", target_os = "tvos"))]
     const TUN_PROTO_IP6: [u8; PIL] = (libc::AF_INET6 as u32).to_be_bytes();
-    #[cfg(any(target_os = "macos", target_os = "ios"))]
+    #[cfg(any(target_os = "macos", target_os = "ios", target_os = "tvos"))]
     const TUN_PROTO_IP4: [u8; PIL] = (libc::AF_INET as u32).to_be_bytes();
 
     // FIXME: Currently, the FreeBSD we test (FreeBSD-14.0-RELEASE) seems to have no PI. Here just a dummy.

src/run_command.rs

@@ -19,7 +19,7 @@ pub fn run_command(command: &str, args: &[&str]) -> std::io::Result<Vec<u8>> {
         });
         let info = format!("Run command: \"{full_cmd}\" failed with {err}");
         log::error!("{}", info);
-        return Err(std::io::Error::new(std::io::ErrorKind::Other, info));
+        return Err(std::io::Error::other(info));
     }
     Ok(out.stdout)
 }