第22章 Rust：基于 tokio 的高性能 TCP 代理

// Cargo.toml: tokio = { version = "1", features = ["full"] }
use tokio::io::copy_bidirectional;
use tokio::net::{TcpListener, TcpStream};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("0.0.0.0:8088").await?;
    println!("L4 代理监听 :8088 → 转发 example.com:80");

    loop {
        let (mut inbound, peer) = listener.accept().await?;
        // 每个连接一个异步任务（对应 Go 的 go handle(c)）
        tokio::spawn(async move {
            match TcpStream::connect("93.184.216.34:80").await {
                Ok(mut outbound) => {
                    // 双向拷贝，任一端关闭即返回（对应 Go 的两个 io.Copy）
                    if let Err(e) = copy_bidirectional(&mut inbound, &mut outbound).await {
                        eprintln!("{peer} 转发结束: {e}");
                    }
                }
                Err(e) => eprintln!("连后端失败: {e}"),
            }
        });
    }
}

use tokio::io::{copy_bidirectional, AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("0.0.0.0:1080").await?;
    println!("SOCKS5 代理监听 :1080");
    loop {
        let (client, _) = listener.accept().await?;
        tokio::spawn(async move {
            if let Err(e) = handle(client).await {
                eprintln!("会话错误: {e}");
            }
        });
    }
}

async fn handle(mut client: TcpStream) -> std::io::Result<()> {
    // 阶段1：方法协商  VER NMETHODS METHODS...
    let mut head = [0u8; 2];
    client.read_exact(&mut head).await?;
    if head[0] != 0x05 {
        return Ok(());
    }
    let mut methods = vec![0u8; head[1] as usize];
    client.read_exact(&mut methods).await?;
    client.write_all(&[0x05, 0x00]).await?; // 选 0x00 无认证

    // 阶段2：请求  VER CMD RSV ATYP ...
    let mut req = [0u8; 4];
    client.read_exact(&mut req).await?;
    if req[1] != 0x01 {
        // 只支持 CONNECT
        client.write_all(&[0x05, 0x07, 0, 0x01, 0, 0, 0, 0, 0, 0]).await?;
        return Ok(());
    }
    // 按 ATYP 解析目标地址（对应第06章报文）
    let host = match req[3] {
        0x01 => {
            let mut a = [0u8; 4];
            client.read_exact(&mut a).await?;
            format!("{}.{}.{}.{}", a[0], a[1], a[2], a[3])
        }
        0x03 => {
            let mut l = [0u8; 1];
            client.read_exact(&mut l).await?;
            let mut d = vec![0u8; l[0] as usize];
            client.read_exact(&mut d).await?;
            String::from_utf8_lossy(&d).into_owned()
        }
        0x04 => {
            let mut a = [0u8; 16];
            client.read_exact(&mut a).await?;
            std::net::Ipv6Addr::from(a).to_string()
        }
        _ => {
            client.write_all(&[0x05, 0x08, 0, 0x01, 0, 0, 0, 0, 0, 0]).await?;
            return Ok(());
        }
    };
    let mut port = [0u8; 2];
    client.read_exact(&mut port).await?;
    let port = u16::from_be_bytes(port);

    // 阶段3：拨号 + 应答 + 转发
    let mut server = match TcpStream::connect((host.as_str(), port)).await {
        Ok(s) => s,
        Err(_) => {
            client.write_all(&[0x05, 0x05, 0, 0x01, 0, 0, 0, 0, 0, 0]).await?;
            return Ok(());
        }
    };
    client.write_all(&[0x05, 0x00, 0, 0x01, 0, 0, 0, 0, 0, 0]).await?; // 成功
    copy_bidirectional(&mut client, &mut server).await?;
    Ok(())
}