mirror of
https://github.com/shadowsocks/shadowsocks-rust.git
synced 2026-11-21 08:05:41 +00:00
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:
Generated
+21
@@ -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"
|
||||
|
||||
@@ -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(),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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! {
|
||||
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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,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(
|
||||
|
||||
@@ -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')
|
||||
|
||||
Reference in New Issue
Block a user