refactored tun local with smoltcp (user-space network stack)

ref #744, probably could fix compatibility issue on R4S (OpenWRT) and
IPv6 support.
This commit is contained in:
zonyitoo
2022-01-16 03:54:52 +08:00
parent 312faea756
commit 00c926d282
11 changed files with 724 additions and 363 deletions
Generated
+21
View File
@@ -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"
+2 -1
View File
@@ -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"
@@ -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<SendableTunTapInterface>,
}
impl TunInterface {
pub fn new(name: &str) -> io::Result<TunInterface> {
let iface = SendableTunTapInterface(TunTapInterface::new(name, Medium::Ip)?);
Ok(TunInterface {
iface: AsyncFd::new(iface)?,
})
}
pub async fn receive<R, F>(&mut self, timestamp: Instant, consume: F) -> io::Result<R>
where
F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
{
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()
}
}
@@ -0,0 +1,57 @@
//! IP packet encapsulation
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use smoltcp::wire::{IpProtocol, Ipv4Packet, Ipv6Packet};
#[derive(Debug)]
pub enum IpPacket<T: AsRef<[u8]>> {
Ipv4(Ipv4Packet<T>),
Ipv6(Ipv6Packet<T>),
}
impl<T: AsRef<[u8]> + Copy> IpPacket<T> {
pub fn new_checked(packet: T) -> Option<IpPacket<T>> {
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(),
}
}
}
+211 -169
View File
@@ -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<ServiceContext>,
@@ -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<TcpTun>,
udp: Option<UdpTun>,
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<UdpTun>) -> 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<bool> {
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<bool> {
// 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)
// }
// }
// }
}
@@ -1,3 +1,5 @@
#![allow(unused)]
use cfg_if::cfg_if;
cfg_if! {
+239 -190
View File
@@ -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<SocketAddr, TcpConnection>,
mapping: LruCache<(SocketAddr, SocketAddr), SocketAddr>,
use super::virt_device::VirtTunDevice;
struct TcpSocketManager {
iface: Interface<'static, VirtTunDevice>,
manager_notify: Arc<Notify>,
}
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<StdMutex<TcpSocketManager>>;
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::<TcpSocket>(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<io::Result<()>> {
let mut manager = self.manager.lock().unwrap();
{
let socket = manager.iface.get_socket::<TcpSocket>(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<io::Result<usize>> {
let mut manager = self.manager.lock().unwrap();
let n = {
let socket = manager.iface.get_socket::<TcpSocket>(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<io::Result<()>> {
Ok(()).into()
}
fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
let mut manager = self.manager.lock().unwrap();
{
let socket = manager.iface.get_socket::<TcpSocket>(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<IpAddr>,
translator: Arc<Mutex<TcpAddressTranslator>>,
abortable: JoinHandle<io::Result<()>>,
context: Arc<ServiceContext>,
manager: SharedTcpSocketManager,
manager_handle: JoinHandle<()>,
manager_notify: Arc<Notify>,
balancer: PingBalancer,
iface_rx: mpsc::UnboundedReceiver<Vec<u8>>,
}
impl Drop for TcpTun {
fn drop(&mut self) {
self.abortable.abort();
self.manager_handle.abort();
}
}
impl TcpTun {
pub async fn new(context: Arc<ServiceContext>, tun_network: IpNet, balancer: PingBalancer) -> io::Result<TcpTun> {
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<ServiceContext>, 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::<Vec<u8>>();
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::<Vec<IpAddr>>();
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<Option<(SocketAddr, SocketAddr)>> {
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::<usize>() % self.free_addrs.len();
let port = rand::random::<u16>() % (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<ServiceContext>,
listener: TcpListener,
balancer: PingBalancer,
translator: Arc<Mutex<TcpAddressTranslator>>,
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<u8> {
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<ServiceContext>,
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<ServiceContext>,
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,
}
@@ -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<Vec<u8>>,
out_buf: mpsc::UnboundedSender<Vec<u8>>,
}
impl VirtTunDevice {
pub fn new(capabilities: DeviceCapabilities, iface_tx: mpsc::UnboundedSender<Vec<u8>>) -> Self {
Self {
capabilities,
in_buf: VecDeque::new(),
out_buf: iface_tx,
}
}
pub fn inject_packet(&mut self, buffer: Vec<u8>) {
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<Self::TxToken> {
return Some(VirtTxToken(self));
}
fn capabilities(&self) -> DeviceCapabilities {
self.capabilities.clone()
}
}
pub struct VirtRxToken {
buffer: Vec<u8>,
}
impl phy::RxToken for VirtRxToken {
fn consume<R, F>(mut self, _timestamp: Instant, f: F) -> smoltcp::Result<R>
where
F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
{
f(&mut self.buffer[..])
}
}
pub struct VirtTxToken<'a>(&'a mut VirtTunDevice);
impl<'a> phy::TxToken for VirtTxToken<'a> {
fn consume<R, F>(self, _timestamp: Instant, len: usize, f: F) -> smoltcp::Result<R>
where
F: FnOnce(&mut [u8]) -> smoltcp::Result<R>,
{
let mut buffer = vec![0u8; len];
let result = f(&mut buffer);
self.0.out_buf.send(buffer).expect("channel closed unexpectly");
result
}
}
+3 -1
View File
@@ -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")
+2 -1
View File
@@ -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(
+4 -1
View File
@@ -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')