增加安卓端支持、优化广播、增加停止监听

switch/src/tun_tap_device/android.rs

@@ -0,0 +1,42 @@
+use std::io;
+use std::os::unix::io::RawFd;
+
+#[derive(Clone)]
+pub struct DeviceWriter(RawFd);
+
+pub struct DeviceReader(RawFd);
+
+impl DeviceWriter {
+    pub fn write_ipv4_tun(&self, buf: &[u8]) -> io::Result<()> {
+        unsafe {
+            let amount = libc::write(self.0, buf.as_ptr() as *const _, buf.len() );
+            if amount < 0 {
+                return Err(io::Error::last_os_error());
+            }
+            Ok(())
+        }
+    }
+    ///写入ipv4数据，为了兼容其他代码，头部空了14个字节
+    pub fn write_ipv4(&self, buf: &[u8]) -> io::Result<()> {
+        let buf = &buf[14..];
+        self.write_ipv4_tun(buf)
+    }
+}
+
+impl DeviceReader {
+    pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
+        unsafe {
+            let amount = libc::read(self.0, buf.as_mut_ptr() as *mut _, buf.len() );
+
+            if amount < 0 {
+                return Err(io::Error::last_os_error());
+            }
+
+            Ok(amount as usize)
+        }
+    }
+}
+
+pub fn create(fd: i32) -> (DeviceWriter, DeviceReader) {
+    (DeviceWriter(fd as _), DeviceReader(fd as _))
+}

switch/src/tun_tap_device/linux.rs

@@ -1,11 +1,11 @@
 use std::io;
 use std::net::Ipv4Addr;
-use crate::tun_tap_device::{DeviceReader, DeviceType, DeviceWriter};
+use crate::tun_tap_device::{DeviceReader, DeviceType, DeviceWriter, DriverInfo};
 use tun::Device;
 use parking_lot::Mutex;
 use std::process::Command;
 use std::sync::Arc;
-use crate::tun_tap_device::unix::DeviceW;
+use crate::tun_tap_device::linux_mac::DeviceW;
 
 impl DeviceWriter {
     pub fn change_ip(&self, address: Ipv4Addr, netmask: Ipv4Addr,
@@ -56,8 +56,7 @@ pub fn create_device(device_type: DeviceType,
                      netmask: Ipv4Addr,
                      gateway: Ipv4Addr,
                      in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
-) -> io::Result<(DeviceWriter, DeviceReader)> {
-    println!("========网卡配置========");
+) -> io::Result<(DeviceWriter, DeviceReader,DriverInfo)> {
     let mut config = tun::Configuration::default();
 
     config
@@ -79,7 +78,6 @@ pub fn create_device(device_type: DeviceType,
     let reader = queue.reader();
     let writer = queue.writer();
     let name = dev.name();
-    println!("name:{:?}", name);
     for (address, netmask) in &in_ips {
         add_route(name, *address, *netmask)?;
     }
@@ -111,10 +109,16 @@ pub fn create_device(device_type: DeviceType,
             DeviceW::Tap((writer, mac))
         }
     };
-    println!("========TUN网卡配置========");
+    let driver_info = DriverInfo {
+        device_type,
+        name:name.to_string(),
+        version:String::new(),
+        mac: None,
+    };
     Ok((
         DeviceWriter::new(device_w, Arc::new(Mutex::new(dev)), in_ips, address, packet_information),
         DeviceReader::new(reader),
+        driver_info,
     ))
 }
 

switch/src/tun_tap_device/linux_mac.rs

@@ -6,9 +6,9 @@ use tun::platform::posix::{Reader, Writer};
 use std::net::Ipv4Addr;
 use std::os::unix::io::AsRawFd;
 use crossbeam_utils::atomic::AtomicCell;
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux"))]
 use tun::platform::linux::Device;
-#[cfg(any(target_os = "macos", target_os = "ios"))]
+#[cfg(any(target_os = "macos"))]
 use tun::platform::macos::Device;
 use parking_lot::Mutex;
 use packet::ethernet;
@@ -128,7 +128,6 @@ impl DeviceWriter {
     }
 }
 
-#[derive(Clone)]
 pub struct DeviceReader(Reader);
 
 impl DeviceReader {

switch/src/tun_tap_device/mac.rs

@@ -1,11 +1,11 @@
 use std::io;
 use std::net::Ipv4Addr;
-use crate::tun_tap_device::{DeviceReader, DeviceType, DeviceWriter};
+use crate::tun_tap_device::{DeviceReader, DeviceType, DeviceWriter, DriverInfo};
 use tun::Device;
 use parking_lot::Mutex;
 use std::process::Command;
 use std::sync::Arc;
-use crate::tun_tap_device::unix::DeviceW;
+use crate::tun_tap_device::linux_mac::DeviceW;
 
 impl DeviceWriter {
     pub fn change_ip(&self, address: Ipv4Addr, netmask: Ipv4Addr,
@@ -42,14 +42,13 @@ pub fn create_device(device_type: DeviceType,
                      netmask: Ipv4Addr,
                      gateway: Ipv4Addr,
                      in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
-) -> io::Result<(DeviceWriter, DeviceReader)> {
+) -> io::Result<(DeviceWriter, DeviceReader,DriverInfo)> {
     match device_type {
         DeviceType::Tun => {}
         DeviceType::Tap => {
             unimplemented!()
         }
     }
-    println!("========TUN网卡配置========");
     let mut config = tun::Configuration::default();
 
     config
@@ -74,11 +73,16 @@ pub fn create_device(device_type: DeviceType,
     let queue = dev.queue(0).unwrap();
     let reader = queue.reader();
     let writer = queue.writer();
-    println!("name:{:?}", name);
-    println!("========TUN网卡配置========");
+    let driver_info = DriverInfo {
+        device_type,
+        name:name.to_string(),
+        version:String::new(),
+        mac: None,
+    };
     Ok((
         DeviceWriter::new(DeviceW::Tun(writer), Arc::new(Mutex::new(dev)), in_ips, address, packet_information),
         DeviceReader::new(reader),
+        driver_info
     ))
 }
 

switch/src/tun_tap_device/mod.rs

@@ -1,19 +1,25 @@
 #[cfg(target_os = "windows")]
-pub mod windows;
-#[cfg(any(target_os = "linux", target_os = "android"))]
-pub mod linux;
+mod windows;
+#[cfg(any(target_os = "linux"))]
+mod linux;
 #[cfg(target_os = "macos")]
-pub mod mac;
-#[cfg(any(unix))]
-pub mod unix;
+mod mac;
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+mod linux_mac;
+#[cfg(target_os = "android")]
+mod android;
 
-#[cfg(any(target_os = "linux", target_os = "android"))]
+
+#[cfg(any(target_os = "linux"))]
 pub use linux::create_device;
-#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg(any(target_os = "linux"))]
 pub use linux::delete_device;
-#[cfg(any(unix))]
-pub use unix::{DeviceWriter, DeviceReader};
-
+#[cfg(target_os = "android")]
+pub use android::create;
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+pub use linux_mac::{DeviceWriter, DeviceReader};
+#[cfg(target_os = "android")]
+pub use android::{DeviceWriter, DeviceReader};
 #[cfg(target_os = "macos")]
 pub use mac::create_device;
 #[cfg(target_os = "macos")]
@@ -26,7 +32,21 @@ pub use windows::delete_device;
 #[cfg(target_os = "windows")]
 pub use windows::{DeviceWriter, DeviceReader};
 
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum DeviceType {
     Tun,
     Tap,
+}
+
+impl DeviceType {
+    pub fn is_tun(&self) -> bool {
+        *self == DeviceType::Tun
+    }
+}
+
+pub struct DriverInfo {
+    pub device_type: DeviceType,
+    pub name: String,
+    pub version: String,
+    pub mac: Option<String>,
 }

switch/src/tun_tap_device/windows.rs

@@ -8,7 +8,7 @@ use parking_lot::Mutex;
 use packet::ethernet;
 use packet::ethernet::packet::EthernetPacket;
 use win_tun_tap::{IFace, TapDevice, TunDevice};
-use crate::tun_tap_device::DeviceType;
+use crate::tun_tap_device::{DriverInfo, DeviceType};
 
 pub const TUN_INTERFACE_NAME: &str = "Switch-Tun-V1";
 pub const TUN_POOL_NAME: &str = "Switch-Tun-V1";
@@ -161,7 +161,6 @@ fn dest(ip: Ipv4Addr, mask: Ipv4Addr) -> Ipv4Addr {
     ])
 }
 
-#[derive(Clone)]
 pub struct DeviceReader {
     device: Arc<Device>,
 }
@@ -199,9 +198,8 @@ fn create_tun(
     netmask: Ipv4Addr,
     gateway: Ipv4Addr,
     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
-) -> io::Result<(DeviceWriter, DeviceReader)> {
+) -> io::Result<(DeviceWriter, DeviceReader, DriverInfo)> {
     unsafe {
-        println!("========TUN网卡配置========");
         match Library::new("wintun.dll") {
             Ok(lib) => match TunDevice::delete_for_name(lib, TUN_INTERFACE_NAME) {
                 Ok(_) => {
@@ -210,7 +208,6 @@ fn create_tun(
                 Err(_) => {}
             },
             Err(e) => {
-                log::error!("wintun.dll not found");
                 return Err(io::Error::new(
                     io::ErrorKind::Other,
                     format!("wintun.dll not found {:?}", e),
@@ -240,8 +237,8 @@ fn create_tun(
                 }
             }
         };
-        println!("name:{:?}", tun_device.get_name()?);
-        println!("version:{:?}", tun_device.version()?);
+        let name = tun_device.get_name()?;
+        let version = format!("{:?}", tun_device.version()?);
         tun_device.set_ip(address, netmask)?;
         tun_device.set_metric(1)?;
         tun_device.set_mtu(1420)?;
@@ -256,14 +253,21 @@ fn create_tun(
         tun_device.add_route(Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]), gateway, 1)?;
         delete_cache();
         let device = Arc::new(Device::Tun(tun_device));
-        println!("========TUN网卡配置========");
+        let driver_info = DriverInfo {
+            device_type: DeviceType::Tun,
+            name,
+            version,
+            mac: None,
+        };
         Ok((
             DeviceWriter::new(device.clone(), in_ips, address),
             DeviceReader::new(device),
+            driver_info
         ))
     }
 }
-fn delete_cache(){
+
+fn delete_cache() {
     //清除路由缓存
     let delete_cache = "netsh interface ip delete destinationcache";
     let out = std::process::Command::new("cmd")
@@ -271,7 +275,7 @@ fn delete_cache(){
         .arg(delete_cache)
         .output()
         .unwrap();
-    if !out.status.success(){
+    if !out.status.success() {
         log::warn!("删除缓存失败:{:?}",out);
     }
 }
@@ -293,8 +297,7 @@ fn create_tap(
     netmask: Ipv4Addr,
     gateway: Ipv4Addr,
     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>,
-) -> io::Result<(DeviceWriter, DeviceReader)> {
-    println!("========TAP网卡配置========");
+) -> io::Result<(DeviceWriter, DeviceReader, DriverInfo)> {
     let tap_device = match TapDevice::open(TAP_INTERFACE_NAME) {
         Ok(tap_device) => tap_device,
         Err(e) => {
@@ -305,9 +308,9 @@ fn create_tap(
         }
     };
     let mac = tap_device.get_mac()?;
-    println!("name:{:?}", tap_device.get_name()?);
-    println!("version:{:x?}", tap_device.get_version()?);
-    println!("mac:{:x?}", mac);
+    let name = tap_device.get_name()?;
+    let version = format!("{:?}", tap_device.get_version()?);
+    let mac_str = format!("mac:{:x?}", mac);
     tap_device.set_ip(address, netmask)?;
     tap_device.set_metric(1)?;
     tap_device.set_mtu(1420)?;
@@ -321,10 +324,16 @@ fn create_tap(
     tap_device.add_route(Ipv4Addr::from([224, 0, 0, 0]), Ipv4Addr::from([240, 0, 0, 0]), gateway, 1)?;
     delete_cache();
     let tap = Arc::new(Device::Tap((tap_device, mac)));
-    println!("========TAP网卡配置========");
+    let driver_info = DriverInfo {
+        device_type: DeviceType::Tap,
+        name,
+        version,
+        mac: Some(mac_str),
+    };
     Ok((
         DeviceWriter::new(tap.clone(), in_ips, address),
-        DeviceReader::new(tap)
+        DeviceReader::new(tap),
+        driver_info
     ))
 }
 
@@ -341,7 +350,7 @@ fn delete_tap() {
 pub fn create_device(device_type: DeviceType, address: Ipv4Addr,
                      netmask: Ipv4Addr,
                      gateway: Ipv4Addr,
-                     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>, ) -> io::Result<(DeviceWriter, DeviceReader)> {
+                     in_ips: Vec<(Ipv4Addr, Ipv4Addr)>, ) -> io::Result<(DeviceWriter, DeviceReader, DriverInfo)> {
     match device_type {
         DeviceType::Tun => {
             create_tun(address, netmask, gateway, in_ips)