小编点评

## Summary of the Rust program: This program acts as a proxy, forwarding requests based on the provided protocol (http by default). It utilizes the tokio library for asynchronous operations. **Key functionalities:** * Parses command-line arguments containing the listen and forward addresses and ports. * Creates two connections, one for listening on the specified port and another for forwarding. * Forwards requests received on the listen port to the specified address and port on the other side. * Offers different handler implementations for various protocols (default, http, and https). **Components:** * **`Connection` struct:** Stores information about the connection, including protocol, transport, host, and port. * **`Listener` struct:** Creates and listens to a TCP listener on the specified address and port. * **`HttpHandler` struct:** Creates and handles HTTP requests by forwarding them to the backend server. * **`Handler` trait:** Defines a generic handler interface that specifies the `handle` method for handling incoming and outgoing data. **Usage:** 1. Run the program with the `cargo run` command. 2. Start an HTTP server using a Python script with the `hello.txt` file. 3. Access the forwarded page by visiting `http://localhost:8000/hello.txt` in your browser. **Notes:** * The code uses the `clap` library for parsing command-line arguments. * The `tokio` library is used for asynchronous operations. * Different handler implementations handle different protocols by forwarding the requests accordingly. * The program demonstrates forwarding requests between two different addresses and ports based on the provided protocol.

正文

学习Rust时练手的小程序，功能类似代理，将网络请求转发到新的地址和端口。

目前只有http请求的转发，未来希望能够代理各种常用的网络协议。
代码地址：https://gitee.com/wangyubin/mario

概要

程序主要有2个参数：

1. -L：监听的地址和端口
2. -F：转发的地址和端口

整体结构如下：

程序启动之后，解析 -L 和 -F 参数，获取相应的的地址和端口，然后生成2个 connection。
-L 参数对应的connection 生成监听器（listener）， -F 参数对应的 connection 生成转发器（handler）。

client不直接请求最终的服务器，而是请求listener监听的地址，listener调用handler转发请求，并将请求结果返回给client。

主要模块

程序的主要功能包括：

命令行参数解析

Rust的命令行参数解析常用的库是 clap。

#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Args {
    /// Listen host and port
    #[clap(short = 'L', value_parser)]
    listen: String,

    /// Forward host and port
    #[clap(short = 'F', value_parser)]
    forward: String,
}

// 解析参数，获取地址和端口信息 
fn parse_args(s: &str) -> Connection {
    let strs: Vec<&str> = s.split("://").collect();
    let hostport: Vec<&str> = strs[1].split(":").collect();

    let pt: Vec<&str> = strs[0].split("+").collect();
    let mut p = Protocol::Default;
    let mut t = Transport::Default;

    if pt.len() == 1 || pt.len() == 2 {
        p = match pt[0] {
            "http" => Protocol::Http,
            "http2" => Protocol::Http2,
            _ => Protocol::Default,
        }
    }

    if pt.len() == 2 {
        t = match pt[1] {
            "tcp" => Transport::Tcp,
            "tls" => Transport::Tls,
            _ => Transport::Default,
        }
    }

    let host = match hostport[0] {
        "" => "127.0.0.1",
        _ => hostport[0],
    };

    Connection::new(p, t, host, hostport[1].parse::<u32>().unwrap())
}

Connection 定义

Connection 保存了监听和转发所需要的相关信息，目前主要有4个字段

pub enum Protocol {
    Default,
    Http,
    Http2,
}
pub enum Transport {
    Default,
    Tcp,
    Tls,
}

// 监听或者转发的链接
pub struct Connection<'a> {
    pub protocol: Protocol,   // 通信协议
    pub transport: Transport, // 传输协议
    pub host: &'a str,        // 主机（ip或者域名）
    pub port: u32,            // 端口
}

Listener 定义

listener 是用来监听client请求的，目前是创建了一个简单的 TcpListener 来监听请求。
这里用到了另一个知名的Rust库：tokio。

pub struct HttpListener<'a> {
    conn: Connection<'a>,
}

impl<'a> HttpListener<'a> {
    pub fn new(conn: Connection) -> HttpListener {
        HttpListener { conn }
    }

    pub async fn listen(&self, handler: &dyn Handler) -> Result<(), Box<dyn Error>> {
        let addr = format!("{}:{}", self.conn.host, self.conn.port);
        let listener = TcpListener::bind(addr).await.unwrap();

        while let Ok((inbound, _)) = listener.accept().await {
            match handler.handle(inbound).await {
                Err(e) => println!("error={}", e),
                _ => println!("success"),
            }
        }

        Ok(())
    }
}

Handler 定义

handler是用来处理请求转发的，它的主要作用是将listener和真正的服务连接起来。

pub struct HttpHandler<'a> {
    conn: Connection<'a>,
}

impl<'a> HttpHandler<'a> {
    pub fn new(conn: Connection<'a>) -> HttpHandler<'a> {
        HttpHandler { conn }
    }
}

#[async_trait]
impl<'a> Handler for HttpHandler<'a> {
    async fn handle(&self, mut inbound: TcpStream) -> Result<(), Box<dyn Error>> {
        let proxy_addr = format!("{}:{}", self.conn.host, self.conn.port);
        let mut outbound = TcpStream::connect(proxy_addr).await?;

        let (mut ri, mut wi) = inbound.split();
        let (mut ro, mut wo) = outbound.split();

        let client_to_server = async {
            io::copy(&mut ri, &mut wo).await?;
            wo.shutdown().await
        };

        let server_to_client = async {
            io::copy(&mut ro, &mut wi).await?;
            wi.shutdown().await
        };

        tokio::try_join!(client_to_server, server_to_client)?;

        Ok(())
    }
}

对于不同的协议，会有不同的handler，所以封装了一个trait来解耦 listener和handler之间的联系。

#[async_trait]
pub trait Handler {
    async fn handle(&self, inbound: TcpStream) -> Result<(), Box<dyn Error>>;
}

这里需要安装 async_trait 这个额外的Rust库，因为Rust原生是不支持异步的trait的。

转发测试

最后看看测试的效果。

测试用的http服务

创建一个文本文件，然后用python在当前目录启动一个静态服务。

echo "hello rust" > hello.txt

python -m http.server 8080

在8080端口启动一个静态http服务，浏览器访问 http://localhost:8080/hello.txt，显示如下：

开启转发

下载 https://gitee.com/wangyubin/mario 的代码，在代码根目录下运行如下命令：

cargo run -- -L http://0.0.0.0:8000 -F http://:8080

再次访问浏览器：http://localhost:8000/hello.txt，显示结果和转发一样：