From 00c926d2829f0d5dd32958f74efe4fb664eb5fc8 Mon Sep 17 00:00:00 2001 From: zonyitoo Date: Sun, 16 Jan 2022 03:54:52 +0800 Subject: [PATCH] refactored tun local with smoltcp (user-space network stack) ref #744, probably could fix compatibility issue on R4S (OpenWRT) and IPv6 support. --- Cargo.lock | 21 + crates/shadowsocks-service/Cargo.toml | 3 +- .../src/local/tun/async_interface.rs | 105 +++++ .../src/local/tun/ip_packet.rs | 57 +++ .../shadowsocks-service/src/local/tun/mod.rs | 380 +++++++++------- .../src/local/tun/sys/mod.rs | 2 + .../shadowsocks-service/src/local/tun/tcp.rs | 429 ++++++++++-------- .../src/local/tun/virt_device.rs | 78 ++++ src/service/local.rs | 4 +- src/service/manager.rs | 3 +- src/service/server.rs | 5 +- 11 files changed, 724 insertions(+), 363 deletions(-) create mode 100644 crates/shadowsocks-service/src/local/tun/async_interface.rs create mode 100644 crates/shadowsocks-service/src/local/tun/ip_packet.rs create mode 100644 crates/shadowsocks-service/src/local/tun/virt_device.rs diff --git a/Cargo.lock b/Cargo.lock index 1c020290..0d649490 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -906,6 +906,12 @@ version = "0.11.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9106e1d747ffd48e6be5bb2d97fa706ed25b144fbee4d5c02eae110cd8d6badd" +[[package]] +name = "managed" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ca88d725a0a943b096803bd34e73a4437208b6077654cc4ecb2947a5f91618d" + [[package]] name = "maplit" version = "1.0.2" @@ -1734,6 +1740,7 @@ dependencies = [ "rustls-native-certs", "serde", "shadowsocks", + "smoltcp", "socket2 0.4.2", "spin 0.9.2", "thiserror", @@ -1774,6 +1781,20 @@ version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83" +[[package]] +name = "smoltcp" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2308a1657c8db1f5b4993bab4e620bdbe5623bd81f254cf60326767bb243237" +dependencies = [ + "bitflags", + "byteorder", + "libc", + "log", + "managed", + "rand_core", +] + [[package]] name = "snmalloc-rs" version = "0.2.28" diff --git a/crates/shadowsocks-service/Cargo.toml b/crates/shadowsocks-service/Cargo.toml index cbad23f3..fd7c590d 100644 --- a/crates/shadowsocks-service/Cargo.toml +++ b/crates/shadowsocks-service/Cargo.toml @@ -56,7 +56,7 @@ local-tunnel = ["local"] # Enable socks4 protocol for sslocal local-socks4 = ["local"] # Enable Tun interface protocol for sslocal -local-tun = ["local", "etherparse", "tun", "rand"] +local-tun = ["local", "etherparse", "tun", "rand", "smoltcp"] # Enable Stream Cipher Protocol # WARN: Stream Cipher Protocol is proved to be insecure @@ -115,6 +115,7 @@ regex = "1.4" tun = { version = "0.5.3", optional = true, features = ["async"] } etherparse = { version = "0.10", optional = true } +smoltcp = { version = "0.8", optional = true, features = [] } serde = { version = "1.0", features = ["derive"] } json5 = "0.4" diff --git a/crates/shadowsocks-service/src/local/tun/async_interface.rs b/crates/shadowsocks-service/src/local/tun/async_interface.rs new file mode 100644 index 00000000..2898b3f4 --- /dev/null +++ b/crates/shadowsocks-service/src/local/tun/async_interface.rs @@ -0,0 +1,105 @@ +//! Asynchronous wrapper of tun interface + +use std::{ + io, + ops::{Deref, DerefMut}, + os::unix::io::{AsRawFd, RawFd}, +}; + +use smoltcp::{ + phy::{Device, DeviceCapabilities, Medium, RxToken, TunTapInterface, TxToken}, + time::Instant, +}; +use tokio::io::unix::AsyncFd; + +struct SendableTunTapInterface(TunTapInterface); + +/// TunTapInterface is not Sendable because it contains a Rc field. +/// The Rc field will be shared between all TxToken. +/// +/// But in this wrapper, we won't expose the RxToken and TxToken, so it is safe to Send between threads. +unsafe impl Send for SendableTunTapInterface {} + +impl AsRawFd for SendableTunTapInterface { + fn as_raw_fd(&self) -> RawFd { + self.0.as_raw_fd() + } +} + +impl Deref for SendableTunTapInterface { + type Target = TunTapInterface; + + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl DerefMut for SendableTunTapInterface { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.0 + } +} + +pub struct TunInterface { + iface: AsyncFd, +} + +impl TunInterface { + pub fn new(name: &str) -> io::Result { + let iface = SendableTunTapInterface(TunTapInterface::new(name, Medium::Ip)?); + Ok(TunInterface { + iface: AsyncFd::new(iface)?, + }) + } + + pub async fn receive(&mut self, timestamp: Instant, consume: F) -> io::Result + where + F: FnOnce(&mut [u8]) -> smoltcp::Result, + { + loop { + let mut ready = self.iface.readable_mut().await?; + let result = ready.try_io(|iface| match iface.get_mut().receive() { + Some(token) => return Ok(token), + None => Err(io::ErrorKind::WouldBlock.into()), + }); + + match result { + Ok(Ok((token, _))) => { + return token + .consume(timestamp, consume) + .map_err(|err| io::Error::new(io::ErrorKind::Other, err)) + } + Ok(Err(err)) => return Err(err), + Err(..) => continue, + } + } + } + + pub async fn transmit(&mut self, timestamp: Instant, buffer: &[u8]) -> io::Result<()> { + loop { + let mut ready = self.iface.writable_mut().await?; + + let result = ready.try_io(|iface| match iface.get_mut().transmit() { + Some(token) => Ok(token), + None => Err(io::ErrorKind::WouldBlock.into()), + }); + + match result { + Ok(Ok(token)) => { + return token + .consume(timestamp, buffer.len(), |xbuf| { + xbuf.copy_from_slice(buffer); + Ok(()) + }) + .map_err(|err| io::Error::new(io::ErrorKind::Other, err)) + } + Ok(Err(err)) => return Err(err), + Err(..) => continue, + } + } + } + + pub fn capabilities(&self) -> DeviceCapabilities { + self.iface.get_ref().capabilities() + } +} diff --git a/crates/shadowsocks-service/src/local/tun/ip_packet.rs b/crates/shadowsocks-service/src/local/tun/ip_packet.rs new file mode 100644 index 00000000..546307ca --- /dev/null +++ b/crates/shadowsocks-service/src/local/tun/ip_packet.rs @@ -0,0 +1,57 @@ +//! IP packet encapsulation + +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; + +use smoltcp::wire::{IpProtocol, Ipv4Packet, Ipv6Packet}; + +#[derive(Debug)] +pub enum IpPacket> { + Ipv4(Ipv4Packet), + Ipv6(Ipv6Packet), +} + +impl + Copy> IpPacket { + pub fn new_checked(packet: T) -> Option> { + if let Ok(ipv4) = Ipv4Packet::new_checked(packet) { + return Some(IpPacket::Ipv4(ipv4)); + } + + if let Ok(ipv6) = Ipv6Packet::new_checked(packet) { + return Some(IpPacket::Ipv6(ipv6)); + } + + None + } + + pub fn src_addr(&self) -> IpAddr { + match *self { + IpPacket::Ipv4(ref packet) => IpAddr::from(Ipv4Addr::from(packet.src_addr())), + IpPacket::Ipv6(ref packet) => IpAddr::from(Ipv6Addr::from(packet.src_addr())), + } + } + + pub fn dst_addr(&self) -> IpAddr { + match *self { + IpPacket::Ipv4(ref packet) => IpAddr::from(Ipv4Addr::from(packet.dst_addr())), + IpPacket::Ipv6(ref packet) => IpAddr::from(Ipv6Addr::from(packet.dst_addr())), + } + } + + pub fn protocol(&self) -> IpProtocol { + match *self { + IpPacket::Ipv4(ref packet) => packet.protocol(), + IpPacket::Ipv6(ref packet) => packet.next_header(), + } + } +} + +impl<'a, T: AsRef<[u8]> + ?Sized> IpPacket<&'a T> { + /// Return a pointer to the payload. + #[inline] + pub fn payload(&self) -> &'a [u8] { + match *self { + IpPacket::Ipv4(ref packet) => packet.payload(), + IpPacket::Ipv6(ref packet) => packet.payload(), + } + } +} diff --git a/crates/shadowsocks-service/src/local/tun/mod.rs b/crates/shadowsocks-service/src/local/tun/mod.rs index 64e69bb1..c5336283 100644 --- a/crates/shadowsocks-service/src/local/tun/mod.rs +++ b/crates/shadowsocks-service/src/local/tun/mod.rs @@ -3,33 +3,34 @@ #[cfg(unix)] use std::os::unix::io::RawFd; use std::{ - io::{self, Cursor, ErrorKind}, - net::{Ipv4Addr, Ipv6Addr, SocketAddr}, + io::{self, ErrorKind}, + net::SocketAddr, sync::Arc, time::Duration, }; use byte_string::ByteStr; -use bytes::BytesMut; -use etherparse::{IpHeader, PacketHeaders, ReadError, TransportHeader}; -use futures::future; -use ipnet::{IpNet, Ipv4Net}; -use log::{error, info, trace, warn}; +use ipnet::IpNet; +use log::{debug, error, info, trace, warn}; use shadowsocks::config::Mode; -use tokio::io::{AsyncReadExt, AsyncWriteExt}; -use tun::{AsyncDevice, Configuration as TunConfiguration, Device, Error as TunError, Layer}; +use smoltcp::wire::{IpProtocol, TcpPacket, UdpPacket}; +use tokio::io::AsyncReadExt; +use tun::{AsyncDevice, Configuration as TunConfiguration, Device as TunDevice, Error as TunError, Layer}; use crate::local::{context::ServiceContext, loadbalancing::PingBalancer}; use self::{ - sys::{set_route_configuration, write_packet_with_pi, IFF_PI_PREFIX_LEN}, + ip_packet::IpPacket, + sys::{write_packet_with_pi, IFF_PI_PREFIX_LEN}, tcp::TcpTun, udp::UdpTun, }; +mod ip_packet; mod sys; mod tcp; mod udp; +mod virt_device; pub struct TunBuilder { context: Arc, @@ -98,60 +99,23 @@ impl TunBuilder { Err(err) => return Err(io::Error::new(ErrorKind::Other, err)), }; - let tun_address = match device.get_ref().address() { - Ok(t) => t, - Err(err) => { - error!( - "tun device doesn't have address, error: {}, set it by tun_interface_address", - err - ); - return Err(io::Error::new(ErrorKind::Other, err)); - } - }; + let udp = UdpTun::new( + self.context.clone(), + self.balancer.clone(), + self.udp_expiry_duration, + self.udp_capacity, + ); - let tun_netmask = match device.get_ref().netmask() { - Ok(m) => m, - Err(err) => { - error!( - "tun device doesn't have netmask, error: {}, set it by tun_interface_address", - err - ); - return Err(io::Error::new(ErrorKind::Other, err)); - } - }; - - let tun_name = device.get_ref().name(); - - trace!("tun {}, address: {}, netmask: {}", tun_name, tun_address, tun_netmask); - - if let Err(err) = set_route_configuration(device.get_ref()).await { - warn!( - "failed to set system route for {}, consider set it manually, error: {}", - tun_name, err - ); - } - - let tun_netmask_u32: u32 = tun_netmask.into(); - - let tun_network = Ipv4Net::new(tun_address, tun_netmask_u32.leading_ones() as u8).expect("Ipv4Net::new"); + let tcp = TcpTun::new( + self.context, + self.balancer, + device.get_ref().mtu().unwrap_or(1500) as u32, + ); Ok(Tun { device, - tcp: if self.mode.enable_tcp() { - Some(TcpTun::new(self.context.clone(), tun_network.into(), self.balancer.clone()).await?) - } else { - None - }, - udp: if self.mode.enable_udp() { - Some(UdpTun::new( - self.context, - self.balancer, - self.udp_expiry_duration, - self.udp_capacity, - )) - } else { - None - }, + tcp, + udp, mode: self.mode, }) } @@ -159,8 +123,8 @@ impl TunBuilder { pub struct Tun { device: AsyncDevice, - tcp: Option, - udp: Option, + tcp: TcpTun, + udp: UdpTun, mode: Mode, } @@ -170,10 +134,8 @@ impl Tun { assert!(mtu > 0 && mtu as usize > IFF_PI_PREFIX_LEN); info!( - "shadowsocks tun device {}, address {}, netmask {}, mtu {}, mode {}", + "shadowsocks tun device {}, mtu {}, mode {}", self.device.get_ref().name(), - self.device.get_ref().address().expect("address"), - self.device.get_ref().netmask().expect("netmask"), mtu, self.mode, ); @@ -181,14 +143,6 @@ impl Tun { let mut packet_buffer = vec![0u8; mtu as usize + IFF_PI_PREFIX_LEN].into_boxed_slice(); loop { - #[inline(always)] - async fn udp_recv_packet(udp: &mut Option) -> BytesMut { - match *udp { - Some(ref mut udp) => udp.recv_packet().await, - None => future::pending().await, - } - } - tokio::select! { // tun device n = self.device.read(&mut packet_buffer) => { @@ -205,129 +159,217 @@ impl Tun { let packet = &mut packet_buffer[IFF_PI_PREFIX_LEN..n]; trace!("[TUN] received IP packet {:?}", ByteStr::new(packet)); - if self.handle_packet(packet).await? { - self.device.write_all(&packet_buffer[..n]).await?; + if let Err(err) = self.handle_tun_frame(packet).await { + error!("[TUN] handle IP frame failed, error: {}", err); } } - // channel sent back - packet = udp_recv_packet(&mut self.udp) => { + // UDP channel sent back + packet = self.udp.recv_packet() => { if let Err(err) = write_packet_with_pi(&mut self.device, &packet).await { - error!("failed to set packet information, error: {}, {:?}", err, ByteStr::new(&packet)); + error!("[TUN] failed to set packet information, error: {}, {:?}", err, ByteStr::new(&packet)); + } + } + + // TCP channel sent back + packet = self.tcp.recv_packet() => { + if let Err(err) = write_packet_with_pi(&mut self.device, &packet).await { + error!("[TUN] failed to set packet information, error: {}, {:?}", err, ByteStr::new(&packet)); } } } } } - async fn handle_packet(&mut self, packet: &mut [u8]) -> io::Result { - let mut ph = match PacketHeaders::from_ip_slice(packet) { - Ok(ph) => ph, - Err(ReadError::IoError(err)) => return Err(err), - Err(err) => { - error!("invalid IP packet, error: {:?}, {:?}", err, ByteStr::new(packet)); - return Err(io::Error::new(ErrorKind::Other, err)); - } - }; - - let payload_len = ph.payload.len(); - - let mut ip_header = match ph.ip { - Some(ref mut i) => i, + async fn handle_tun_frame(&mut self, frame: &[u8]) -> smoltcp::Result<()> { + let packet = match IpPacket::new_checked(frame) { + Some(packet) => packet, None => { - error!("unrecognized ethernet packet {:?}", ph); - return Err(io::Error::new(ErrorKind::Other, "unrecognized ethernet packet")); + warn!("unrecognized IP packet {:?}", ByteStr::new(frame)); + return Ok(()); } }; - let (src_ip, dst_ip) = match *ip_header { - IpHeader::Version4(ref v4, ..) => (Ipv4Addr::from(v4.source).into(), Ipv4Addr::from(v4.destination).into()), - IpHeader::Version6(ref v6, ..) => (Ipv6Addr::from(v6.source).into(), Ipv6Addr::from(v6.destination).into()), - }; - - match ph.transport { - Some(TransportHeader::Tcp(ref mut tcp_header)) => { - let tcp = match self.tcp { - Some(ref mut tcp) => tcp, - None => return Ok(false), - }; - - let src_addr = SocketAddr::new(src_ip, tcp_header.source_port); - let dst_addr = SocketAddr::new(dst_ip, tcp_header.destination_port); - - let (mod_src_addr, mod_dst_addr) = match tcp.handle_packet(src_addr, dst_addr, tcp_header).await { - Ok(Some(a)) => a, - Ok(None) => return Ok(false), + match packet.protocol() { + IpProtocol::Tcp => { + let tcp_packet = match TcpPacket::new_checked(packet.payload()) { + Ok(p) => p, Err(err) => { - error!("handle TCP/IP packet failed, error: {}", err); - return Ok(false); + error!( + "invalid TCP packet err: {}, src_ip: {}, dst_ip: {}, payload: {:?}", + err, + packet.src_addr(), + packet.dst_addr(), + ByteStr::new(packet.payload()) + ); + return Ok(()); } }; - // Replaces IP_HEADER, TRANSPORT_HEADER directly into packet - match (mod_src_addr, &mut ip_header) { - (SocketAddr::V4(v4addr), IpHeader::Version4(v4ip, ..)) => v4ip.source = v4addr.ip().octets(), - (SocketAddr::V6(v6addr), IpHeader::Version6(v6ip, ..)) => v6ip.source = v6addr.ip().octets(), - _ => { - unreachable!( - "modified TCP saddr not match, addr: {}, header: {:?}", - mod_src_addr, ip_header - ); - } - } - tcp_header.source_port = mod_src_addr.port(); - match (mod_dst_addr, &mut ip_header) { - (SocketAddr::V4(v4addr), IpHeader::Version4(v4ip, ..)) => v4ip.destination = v4addr.ip().octets(), - (SocketAddr::V6(v6addr), IpHeader::Version6(v6ip, ..)) => v6ip.destination = v6addr.ip().octets(), - _ => { - unreachable!( - "modified TCP daddr not match, addr: {}, header: {:?}", - mod_dst_addr, ip_header - ); - } - } - tcp_header.destination_port = mod_dst_addr.port(); - match ip_header { - IpHeader::Version4(v4, ..) => { - tcp_header.checksum = tcp_header - .calc_checksum_ipv4(v4, ph.payload) - .expect("calc_checksum_ipv4") - } - IpHeader::Version6(v6, ..) => { - tcp_header.checksum = tcp_header - .calc_checksum_ipv6(v6, ph.payload) - .expect("calc_checksum_ipv6") - } + let src_port = tcp_packet.src_port(); + let dst_port = tcp_packet.dst_port(); + + let src_addr = SocketAddr::new(packet.src_addr(), src_port); + let dst_addr = SocketAddr::new(packet.dst_addr(), dst_port); + + trace!("[TUN] TCP packet {} -> {} {}", src_addr, dst_addr, tcp_packet); + + // TCP first handshake packet. + if let Err(err) = self.tcp.handle_packet(src_addr, dst_addr, &tcp_packet).await { + error!( + "handle TCP packet failed, error: {}, {} <-> {}, packet: {:?}", + err, src_addr, dst_addr, tcp_packet + ); } - let (headers, _) = packet.split_at_mut(packet.len() - payload_len); - let mut cursor = Cursor::new(headers); - - ip_header.write(&mut cursor).expect("ip_header.write"); - tcp_header.write(&mut cursor).expect("tcp_header.write"); - - Ok(true) + self.tcp.drive_interface_state(frame); } - Some(TransportHeader::Udp(ref udp_header)) => { - // UDP proxies directly - let udp = match self.udp { - Some(ref mut udp) => udp, - None => return Ok(false), + IpProtocol::Udp => { + let udp_packet = match UdpPacket::new_checked(packet.payload()) { + Ok(p) => p, + Err(err) => { + error!( + "invalid UDP packet err: {}, src_ip: {}, dst_ip: {}, payload: {:?}", + err, + packet.src_addr(), + packet.dst_addr(), + ByteStr::new(packet.payload()) + ); + return Ok(()); + } }; - let src_addr = SocketAddr::new(src_ip, udp_header.source_port); - let dst_addr = SocketAddr::new(dst_ip, udp_header.destination_port); + let src_port = udp_packet.src_port(); + let dst_port = udp_packet.dst_port(); - if let Err(err) = udp.handle_packet(src_addr, dst_addr, ph.payload).await { - error!("handle UDP/IP packet failed, error: {}", err); + let src_addr = SocketAddr::new(packet.src_addr(), src_port); + let dst_addr = SocketAddr::new(packet.dst_addr(), dst_port); + + let payload = udp_packet.payload(); + trace!("[TUN] UDP packet {} -> {} {}", src_addr, dst_addr, udp_packet); + + if let Err(err) = self.udp.handle_packet(src_addr, dst_addr, payload).await { + error!("handle UDP packet failed, err: {}, packet: {:?}", err, udp_packet); } - - Ok(false) } - None => { - trace!("no transport layer in ethernet packet {:?}", ph); - Ok(false) + IpProtocol::Icmp => {} + _ => { + debug!("IP packet ignored (protocol: {:?})", packet.protocol()); + return Ok(()); } } + + Ok(()) } + + // async fn handle_packet(&mut self, packet: &mut [u8]) -> io::Result { + // let mut ph = match PacketHeaders::from_ip_slice(packet) { + // Ok(ph) => ph, + // Err(ReadError::IoError(err)) => return Err(err), + // Err(err) => { + // error!("invalid IP packet, error: {:?}, {:?}", err, ByteStr::new(packet)); + // return Err(io::Error::new(ErrorKind::Other, err)); + // } + // }; + + // let payload_len = ph.payload.len(); + + // let mut ip_header = match ph.ip { + // Some(ref mut i) => i, + // None => { + // error!("unrecognized ethernet packet {:?}", ph); + // return Err(io::Error::new(ErrorKind::Other, "unrecognized ethernet packet")); + // } + // }; + + // let (src_ip, dst_ip) = match *ip_header { + // IpHeader::Version4(ref v4, ..) => (Ipv4Addr::from(v4.source).into(), Ipv4Addr::from(v4.destination).into()), + // IpHeader::Version6(ref v6, ..) => (Ipv6Addr::from(v6.source).into(), Ipv6Addr::from(v6.destination).into()), + // }; + + // match ph.transport { + // Some(TransportHeader::Tcp(ref mut tcp_header)) => { + // let tcp = match self.tcp { + // Some(ref mut tcp) => tcp, + // None => return Ok(false), + // }; + + // let src_addr = SocketAddr::new(src_ip, tcp_header.source_port); + // let dst_addr = SocketAddr::new(dst_ip, tcp_header.destination_port); + + // let (mod_src_addr, mod_dst_addr) = match tcp.handle_packet(src_addr, dst_addr, tcp_header).await { + // Ok(Some(a)) => a, + // Ok(None) => return Ok(false), + // Err(err) => { + // error!("handle TCP/IP packet failed, error: {}", err); + // return Ok(false); + // } + // }; + + // // Replaces IP_HEADER, TRANSPORT_HEADER directly into packet + // match (mod_src_addr, &mut ip_header) { + // (SocketAddr::V4(v4addr), IpHeader::Version4(v4ip, ..)) => v4ip.source = v4addr.ip().octets(), + // (SocketAddr::V6(v6addr), IpHeader::Version6(v6ip, ..)) => v6ip.source = v6addr.ip().octets(), + // _ => { + // unreachable!( + // "modified TCP saddr not match, addr: {}, header: {:?}", + // mod_src_addr, ip_header + // ); + // } + // } + // tcp_header.source_port = mod_src_addr.port(); + // match (mod_dst_addr, &mut ip_header) { + // (SocketAddr::V4(v4addr), IpHeader::Version4(v4ip, ..)) => v4ip.destination = v4addr.ip().octets(), + // (SocketAddr::V6(v6addr), IpHeader::Version6(v6ip, ..)) => v6ip.destination = v6addr.ip().octets(), + // _ => { + // unreachable!( + // "modified TCP daddr not match, addr: {}, header: {:?}", + // mod_dst_addr, ip_header + // ); + // } + // } + // tcp_header.destination_port = mod_dst_addr.port(); + // match ip_header { + // IpHeader::Version4(v4, ..) => { + // tcp_header.checksum = tcp_header + // .calc_checksum_ipv4(v4, ph.payload) + // .expect("calc_checksum_ipv4") + // } + // IpHeader::Version6(v6, ..) => { + // tcp_header.checksum = tcp_header + // .calc_checksum_ipv6(v6, ph.payload) + // .expect("calc_checksum_ipv6") + // } + // } + + // let (headers, _) = packet.split_at_mut(packet.len() - payload_len); + // let mut cursor = Cursor::new(headers); + + // ip_header.write(&mut cursor).expect("ip_header.write"); + // tcp_header.write(&mut cursor).expect("tcp_header.write"); + + // Ok(true) + // } + // Some(TransportHeader::Udp(ref udp_header)) => { + // // UDP proxies directly + // let udp = match self.udp { + // Some(ref mut udp) => udp, + // None => return Ok(false), + // }; + + // let src_addr = SocketAddr::new(src_ip, udp_header.source_port); + // let dst_addr = SocketAddr::new(dst_ip, udp_header.destination_port); + + // if let Err(err) = udp.handle_packet(src_addr, dst_addr, ph.payload).await { + // error!("handle UDP/IP packet failed, error: {}", err); + // } + + // Ok(false) + // } + // None => { + // trace!("no transport layer in ethernet packet {:?}", ph); + // Ok(false) + // } + // } + // } } diff --git a/crates/shadowsocks-service/src/local/tun/sys/mod.rs b/crates/shadowsocks-service/src/local/tun/sys/mod.rs index 0f9a1a2a..27507266 100644 --- a/crates/shadowsocks-service/src/local/tun/sys/mod.rs +++ b/crates/shadowsocks-service/src/local/tun/sys/mod.rs @@ -1,3 +1,5 @@ +#![allow(unused)] + use cfg_if::cfg_if; cfg_if! { diff --git a/crates/shadowsocks-service/src/local/tun/tcp.rs b/crates/shadowsocks-service/src/local/tun/tcp.rs index 9630cb82..88e685ed 100644 --- a/crates/shadowsocks-service/src/local/tun/tcp.rs +++ b/crates/shadowsocks-service/src/local/tun/tcp.rs @@ -1,16 +1,28 @@ use std::{ + collections::BTreeMap, io::{self, ErrorKind}, net::{IpAddr, SocketAddr}, - sync::Arc, - time::Duration, + pin::Pin, + sync::{Arc, Mutex as StdMutex}, + task::{Context, Poll}, + time::Duration as StdDuration, }; -use etherparse::TcpHeader; -use ipnet::IpNet; -use log::{debug, error, trace}; -use lru_time_cache::LruCache; -use shadowsocks::{net::TcpListener, relay::socks5::Address}; -use tokio::{net::TcpStream, sync::Mutex, task::JoinHandle, time}; +use log::{error, trace}; +use shadowsocks::relay::socks5::Address; +use smoltcp::{ + iface::{Interface, InterfaceBuilder, Routes, SocketHandle}, + phy::{DeviceCapabilities, Medium}, + socket::{TcpSocket, TcpSocketBuffer, TcpState}, + time::{Duration, Instant}, + wire::{IpAddress, IpCidr, Ipv4Address, Ipv6Address, TcpPacket}, +}; +use tokio::{ + io::{AsyncRead, AsyncWrite, ReadBuf}, + sync::{mpsc, Notify}, + task::JoinHandle, + time, +}; use crate::local::{ context::ServiceContext, @@ -19,197 +31,254 @@ use crate::local::{ utils::{establish_tcp_tunnel, to_ipv4_mapped}, }; -struct TcpAddressTranslator { - connections: LruCache, - mapping: LruCache<(SocketAddr, SocketAddr), SocketAddr>, +use super::virt_device::VirtTunDevice; + +struct TcpSocketManager { + iface: Interface<'static, VirtTunDevice>, + manager_notify: Arc, } -impl TcpAddressTranslator { - fn new() -> TcpAddressTranslator { - TcpAddressTranslator { - connections: LruCache::with_expiry_duration(Duration::from_secs(24 * 60 * 60)), - mapping: LruCache::with_expiry_duration(Duration::from_secs(24 * 60 * 60)), +impl TcpSocketManager { + fn notify(&self) { + self.manager_notify.notify_waiters(); + } +} + +type SharedTcpSocketManager = Arc>; + +struct TcpConnection { + socket_handle: SocketHandle, + manager: SharedTcpSocketManager, +} + +impl Drop for TcpConnection { + fn drop(&mut self) { + let mut manager = self.manager.lock().unwrap(); + let socket = manager.iface.get_socket::(self.socket_handle); + socket.close(); + } +} + +impl TcpConnection { + fn new(socket: TcpSocket<'static>, manager: SharedTcpSocketManager) -> TcpConnection { + let socket_handle = { + let mut manager = manager.lock().unwrap(); + manager.iface.add_socket(socket) + }; + + TcpConnection { socket_handle, manager } + } +} + +impl AsyncRead for TcpConnection { + fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll> { + let mut manager = self.manager.lock().unwrap(); + { + let socket = manager.iface.get_socket::(self.socket_handle); + if !socket.is_open() { + return Ok(()).into(); + } + + if socket.can_recv() { + let recv_buf = buf.initialize_unfilled(); + let n = match socket.recv_slice(recv_buf) { + Ok(n) => n, + Err(err) => return Err(io::Error::new(ErrorKind::Other, err)).into(), + }; + buf.advance(n); + } else { + socket.register_recv_waker(cx.waker()); + return Poll::Pending; + } } + + manager.notify(); + Ok(()).into() + } +} + +impl AsyncWrite for TcpConnection { + fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll> { + let mut manager = self.manager.lock().unwrap(); + let n = { + let socket = manager.iface.get_socket::(self.socket_handle); + if !socket.is_open() { + return Err(ErrorKind::BrokenPipe.into()).into(); + } + if socket.can_send() { + match socket.send_slice(buf) { + Ok(n) => n, + Err(err) => return Err(io::Error::new(ErrorKind::Other, err)).into(), + } + } else { + socket.register_send_waker(cx.waker()); + return Poll::Pending; + } + }; + + manager.notify(); + Ok(n).into() + } + + fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { + Ok(()).into() + } + + fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + let mut manager = self.manager.lock().unwrap(); + { + let socket = manager.iface.get_socket::(self.socket_handle); + // close the transmission half. + if socket.is_open() { + socket.close(); + } + + if socket.state() != TcpState::Closed { + socket.register_send_waker(cx.waker()); + return Poll::Pending; + } + } + manager.notify(); + Ok(()).into() } } pub struct TcpTun { - tcp_daddr: SocketAddr, - free_addrs: Vec, - translator: Arc>, - abortable: JoinHandle>, + context: Arc, + manager: SharedTcpSocketManager, + manager_handle: JoinHandle<()>, + manager_notify: Arc, + balancer: PingBalancer, + iface_rx: mpsc::UnboundedReceiver>, } impl Drop for TcpTun { fn drop(&mut self) { - self.abortable.abort(); + self.manager_handle.abort(); } } impl TcpTun { - pub async fn new(context: Arc, tun_network: IpNet, balancer: PingBalancer) -> io::Result { - let mut hosts = tun_network.hosts(); - let tcp_daddr = match hosts.next() { - Some(d) => d, - None => return Err(io::Error::new(ErrorKind::Other, "tun network doesn't have any hosts")), + pub fn new(context: Arc, balancer: PingBalancer, mtu: u32) -> TcpTun { + let mut capabilities = DeviceCapabilities::default(); + capabilities.medium = Medium::Ip; + capabilities.max_transmission_unit = mtu as usize; + + let (iface_tx, iface_rx) = mpsc::unbounded_channel::>(); + let virt = VirtTunDevice::new(capabilities, iface_tx); + + let iface_builder = InterfaceBuilder::new(virt, vec![]); + let iface_ipaddrs = [ + IpCidr::new(IpAddress::v4(0, 0, 0, 1), 0), + IpCidr::new(IpAddress::v6(0, 0, 0, 0, 0, 0, 0, 1), 0), + ]; + let mut iface_routes = Routes::new(BTreeMap::new()); + iface_routes + .add_default_ipv4_route(Ipv4Address::new(0, 0, 0, 1)) + .expect("IPv4 route"); + iface_routes + .add_default_ipv6_route(Ipv6Address::new(0, 0, 0, 0, 0, 0, 0, 1)) + .expect("IPv6 route"); + let iface = iface_builder + .any_ip(true) + .ip_addrs(iface_ipaddrs) + .routes(iface_routes) + .finalize(); + + let manager_notify = Arc::new(Notify::new()); + let manager = Arc::new(StdMutex::new(TcpSocketManager { + iface, + manager_notify: manager_notify.clone(), + })); + + let manager_handle = { + let manager = manager.clone(); + let manager_notify = manager_notify.clone(); + tokio::spawn(async move { + loop { + let next_duration = { + let mut manager = manager.lock().unwrap(); + + if let Err(err) = manager.iface.poll(Instant::now()) { + error!("virtual device error: {}", err); + } + + let next_duration = manager + .iface + .poll_delay(Instant::now()) + .unwrap_or(Duration::from_millis(50)); + + next_duration + }; + + tokio::select! { + _ = time::sleep(StdDuration::from(next_duration)) => {} + _ = manager_notify.notified() => {} + } + } + }) }; - // Take up to 10 IPs as saddr for NAT allocating - let free_addrs = hosts.take(10).collect::>(); - if free_addrs.is_empty() { - return Err(io::Error::new( - ErrorKind::InvalidInput, - "tun network doesn't have enough free addresses", - )); + TcpTun { + context, + manager, + manager_handle, + manager_notify, + balancer, + iface_rx, } - - let listener = TcpListener::bind_with_opts(&SocketAddr::new(tcp_daddr, 0), context.accept_opts()).await?; - let tcp_daddr = listener.local_addr()?; - - debug!("tun tcp listener bind {}", tcp_daddr); - - let translator = Arc::new(Mutex::new(TcpAddressTranslator::new())); - - let abortable = { - let translator = translator.clone(); - tokio::spawn(TcpTun::tunnel(context, listener, balancer, translator)) - }; - - Ok(TcpTun { - tcp_daddr, - free_addrs, - translator, - abortable, - }) } pub async fn handle_packet( &mut self, src_addr: SocketAddr, dst_addr: SocketAddr, - tcp_header: &TcpHeader, - ) -> io::Result> { - let TcpAddressTranslator { - ref mut connections, - ref mut mapping, - } = *(self.translator.lock().await); - - let (conn, is_reply) = if tcp_header.syn && !tcp_header.ack { - // 1st SYN, creating a new connection - // Allocate a `saddr` for it - let saddr = loop { - let addr_idx = rand::random::() % self.free_addrs.len(); - let port = rand::random::() % (65535 - 1024) + 1024; - - let addr = SocketAddr::new(self.free_addrs[addr_idx], port); - if !connections.contains_key(&addr) { - trace!("allocated tcp addr {} for {} -> {}", addr, src_addr, dst_addr); - - // Create one in the connection map. - connections.insert( - addr, - TcpConnection { - saddr: src_addr, - daddr: dst_addr, - faked_saddr: addr, - state: TcpState::Established, - }, - ); - - // Record the fake address mapping - mapping.insert((src_addr, dst_addr), addr); - - break addr; - } - }; - - (connections.get_mut(&saddr).unwrap(), false) - } else { - // Find if it is an existed connection, ignore it otherwise - match mapping.get(&(src_addr, dst_addr)) { - Some(saddr) => match connections.get_mut(saddr) { - Some(c) => (c, false), - None => { - debug!("unknown tcp connection {} -> {}", src_addr, dst_addr); - return Ok(None); - } - }, - None => { - // Check if it is a reply packet - match connections.get_mut(&dst_addr) { - Some(c) => (c, true), - None => { - debug!("unknown tcp connection {} -> {}", src_addr, dst_addr); - return Ok(None); - } - } - } - } - }; - - let (trans_saddr, trans_daddr) = if is_reply { - trace!("TCP {} <- {} {:?}", conn.saddr, conn.daddr, tcp_header); - (conn.daddr, conn.saddr) - } else { - trace!("TCP {} -> {} {:?}", conn.saddr, conn.daddr, tcp_header); - (conn.faked_saddr, self.tcp_daddr) - }; - - if tcp_header.rst || (tcp_header.ack && conn.state == TcpState::LastAck) { - // Connection closed. - trace!("tcp connection closed {} -> {}", conn.saddr, conn.daddr); - - mapping.remove(&(src_addr, dst_addr)); - let faked_saddr = conn.faked_saddr; - connections.remove(&faked_saddr); - } else if tcp_header.fin { - match conn.state { - TcpState::Established => conn.state = TcpState::FinWait, - TcpState::FinWait => conn.state = TcpState::LastAck, - _ => {} - } - } - - Ok(Some((trans_saddr, trans_daddr))) - } - - async fn tunnel( - context: Arc, - listener: TcpListener, - balancer: PingBalancer, - translator: Arc>, + tcp_packet: &TcpPacket<&[u8]>, ) -> io::Result<()> { - loop { - let (stream, peer_addr) = match listener.accept().await { - Ok(s) => s, - Err(err) => { - error!("accept failed, error: {}", err); - time::sleep(Duration::from_secs(1)).await; - continue; - } - }; + // TCP first handshake packet, create a new Connection + if tcp_packet.syn() && !tcp_packet.ack() { + let accept_opts = self.context.accept_opts(); + let send_buffer_size = accept_opts.tcp.send_buffer_size.unwrap_or(4096); + let recv_buffer_size = accept_opts.tcp.recv_buffer_size.unwrap_or(4096); - // Try to translate - let (saddr, daddr) = { - let mut translator = translator.lock().await; - match translator.connections.get(&peer_addr) { - Some(c) => (c.saddr, c.daddr), - None => { - error!("unknown connection from {}", peer_addr); - continue; - } - } - }; + let mut socket = TcpSocket::new( + TcpSocketBuffer::new(vec![0u8; recv_buffer_size as usize]), + TcpSocketBuffer::new(vec![0u8; send_buffer_size as usize]), + ); + socket.set_ack_delay(None); + if let Err(err) = socket.listen(dst_addr) { + return Err(io::Error::new(ErrorKind::Other, err)); + } - debug!("establishing tcp tunnel {} -> {}", saddr, daddr); + trace!("created TCP connection for {} <-> {}", src_addr, dst_addr); - let context = context.clone(); - let balancer = balancer.clone(); + let connection = TcpConnection::new(socket, self.manager.clone()); + + // establish a tunnel + let context = self.context.clone(); + let balancer = self.balancer.clone(); tokio::spawn(async move { - if let Err(err) = handle_redir_client(context, balancer, stream, peer_addr, daddr).await { - debug!("TCP redirect client, error: {:?}", err); + if let Err(err) = handle_redir_client(context, balancer, connection, src_addr, dst_addr).await { + error!("TCP tunnel failure, {} <-> {}, error: {}", src_addr, dst_addr, err); } }); + + // Wake up and poll the interface. + self.manager_notify.notify_waiters(); + } + + Ok(()) + } + + pub fn drive_interface_state(&mut self, frame: &[u8]) { + let mut manager = self.manager.lock().unwrap(); + manager.iface.device_mut().inject_packet(frame.to_vec()); + } + + pub async fn recv_packet(&mut self) -> Vec { + match self.iface_rx.recv().await { + Some(v) => v, + None => unreachable!("channel closed unexpectedly"), } } } @@ -220,7 +289,7 @@ impl TcpTun { async fn establish_client_tcp_redir<'a>( context: Arc, balancer: PingBalancer, - mut stream: TcpStream, + mut stream: TcpConnection, peer_addr: SocketAddr, addr: &Address, ) -> io::Result<()> { @@ -235,7 +304,7 @@ async fn establish_client_tcp_redir<'a>( async fn handle_redir_client( context: Arc, balancer: PingBalancer, - s: TcpStream, + s: TcpConnection, peer_addr: SocketAddr, mut daddr: SocketAddr, ) -> io::Result<()> { @@ -250,23 +319,3 @@ async fn handle_redir_client( let target_addr = Address::from(daddr); establish_client_tcp_redir(context, balancer, s, peer_addr, &target_addr).await } - -#[derive(Debug, Eq, PartialEq)] -enum TcpState { - /// TCP state `ESTABLISHED` - /// - /// When receiving the first SYN then the state will be set to `ESTABLISHED`. - /// The detailed state like (SYN_SEND, SYN_RCVD) will be handled properly by the `TcpListener`. - Established, - /// When receiving from the first FIN will be transferred from Established - FinWait, - /// When receiving the last ACK of FIN will be transferred from FinWait - LastAck, -} - -struct TcpConnection { - saddr: SocketAddr, - daddr: SocketAddr, - faked_saddr: SocketAddr, - state: TcpState, -} diff --git a/crates/shadowsocks-service/src/local/tun/virt_device.rs b/crates/shadowsocks-service/src/local/tun/virt_device.rs new file mode 100644 index 00000000..a6a9e66c --- /dev/null +++ b/crates/shadowsocks-service/src/local/tun/virt_device.rs @@ -0,0 +1,78 @@ +//! Virtual Device for receiving packets from tun + +use std::collections::VecDeque; + +use smoltcp::{ + phy::{self, Device, DeviceCapabilities}, + time::Instant, +}; +use tokio::sync::mpsc; + +pub struct VirtTunDevice { + capabilities: DeviceCapabilities, + in_buf: VecDeque>, + out_buf: mpsc::UnboundedSender>, +} + +impl VirtTunDevice { + pub fn new(capabilities: DeviceCapabilities, iface_tx: mpsc::UnboundedSender>) -> Self { + Self { + capabilities, + in_buf: VecDeque::new(), + out_buf: iface_tx, + } + } + + pub fn inject_packet(&mut self, buffer: Vec) { + self.in_buf.push_back(buffer); + } +} + +impl<'a> Device<'a> for VirtTunDevice { + type RxToken = VirtRxToken; + type TxToken = VirtTxToken<'a>; + + fn receive(&'a mut self) -> Option<(Self::RxToken, Self::TxToken)> { + if let Some(buffer) = self.in_buf.pop_front() { + let rx = Self::RxToken { buffer }; + let tx = VirtTxToken(self); + return Some((rx, tx)); + } + None + } + + fn transmit(&'a mut self) -> Option { + return Some(VirtTxToken(self)); + } + + fn capabilities(&self) -> DeviceCapabilities { + self.capabilities.clone() + } +} + +pub struct VirtRxToken { + buffer: Vec, +} + +impl phy::RxToken for VirtRxToken { + fn consume(mut self, _timestamp: Instant, f: F) -> smoltcp::Result + where + F: FnOnce(&mut [u8]) -> smoltcp::Result, + { + f(&mut self.buffer[..]) + } +} + +pub struct VirtTxToken<'a>(&'a mut VirtTunDevice); + +impl<'a> phy::TxToken for VirtTxToken<'a> { + fn consume(self, _timestamp: Instant, len: usize, f: F) -> smoltcp::Result + where + F: FnOnce(&mut [u8]) -> smoltcp::Result, + { + let mut buffer = vec![0u8; len]; + let result = f(&mut buffer); + self.0.out_buf.send(buffer).expect("channel closed unexpectly"); + result + } +} diff --git a/src/service/local.rs b/src/service/local.rs index 8723931e..64ec25aa 100644 --- a/src/service/local.rs +++ b/src/service/local.rs @@ -2,7 +2,7 @@ use std::{net::IpAddr, path::PathBuf, process, time::Duration}; -use clap::{App, Arg, ArgMatches, ErrorKind as ClapErrorKind}; +use clap::{App, Arg, ArgGroup, ArgMatches, ErrorKind as ClapErrorKind}; use futures::future::{self, Either}; use log::{info, trace}; use tokio::{self, runtime::Builder}; @@ -129,6 +129,8 @@ pub fn define_command_line_options(mut app: App<'_>) -> App<'_> { .validator(validator::validate_server_url) .help("Server address in SIP002 (https://shadowsocks.org/en/wiki/SIP002-URI-Scheme.html) URL"), ) + .group(ArgGroup::new("SERVER_CONFIG") + .arg("SERVER_ADDR").arg("URL").multiple(true)) .arg( Arg::new("ACL") .long("acl") diff --git a/src/service/manager.rs b/src/service/manager.rs index 49d92dfa..fdd965a0 100644 --- a/src/service/manager.rs +++ b/src/service/manager.rs @@ -2,7 +2,7 @@ use std::{net::IpAddr, path::PathBuf, process, time::Duration}; -use clap::{App, Arg, ArgMatches, ErrorKind as ClapErrorKind}; +use clap::{App, Arg, ArgGroup, ArgMatches, ErrorKind as ClapErrorKind}; use futures::future::{self, Either}; use log::{info, trace}; use tokio::{self, runtime::Builder}; @@ -74,6 +74,7 @@ pub fn define_command_line_options(mut app: App<'_>) -> App<'_> { .validator(validator::validate_manager_addr) .help("ShadowSocks Manager (ssmgr) address, could be ip:port, domain:port or /path/to/unix.sock"), ) + .group(ArgGroup::new("SERVER_CONFIG").arg("MANAGER_ADDR")) .arg(Arg::new("ENCRYPT_METHOD").short('m').long("encrypt-method").takes_value(true).possible_values(available_ciphers()).help("Default encryption method")) .arg(Arg::new("TIMEOUT").long("timeout").takes_value(true).validator(validator::validate_u64).help("Default timeout seconds for TCP relay")) .arg( diff --git a/src/service/server.rs b/src/service/server.rs index 5e347daf..64874cb1 100644 --- a/src/service/server.rs +++ b/src/service/server.rs @@ -2,7 +2,7 @@ use std::{net::IpAddr, path::PathBuf, process, time::Duration}; -use clap::{App, Arg, ArgMatches, ErrorKind as ClapErrorKind}; +use clap::{App, Arg, ArgGroup, ArgMatches, ErrorKind as ClapErrorKind}; use futures::future::{self, Either}; use log::{info, trace}; use tokio::{self, runtime::Builder}; @@ -85,6 +85,9 @@ pub fn define_command_line_options(mut app: App<'_>) -> App<'_> { .requires("SERVER_ADDR") .help("Server's timeout seconds for TCP relay"), ) + .group( + ArgGroup::new("SERVER_CONFIG").arg("SERVER_ADDR") + ) .arg( Arg::new("UDP_ONLY") .short('u')