# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

### 项目设计目标
* HTTP转发
* HTTPS转发(证书在服务器,内网为HTTP)
* TCP转发(纯粹的TCP转发，保持原样的协议)
* PROXY转发(服务端接收数据，内网的客户端当成PROXY客户端，相当于逆向访问内网服务器，**[新增]**)

#### 实现方案
服务端提供客户端的连接端口，可加密`Tls`，可双向加密`mTls`，可账号密码认证，客户端连接服务端的端口等待数据的处理。主要有两个类[`服务端CenterServer`](https://github.com/tickbh/wmproxy/blob/main/src/streams/center_server.rs)及[`客户端CenterClient`](https://github.com/tickbh/wmproxy/blob/main/src/streams/center_client.rs)

一些细节可以参考第5篇，第6篇，第10篇，第12篇，有相关的内网穿透的细节。

#### 内网代理的实现
1. 首先添加一种模式
```RUST
#[serde_as]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MappingConfig {
 /// 其它字段....
 // 添加模块proxy
 pub mode: String,
}
```
2. 添加内网代理监听端口
```rust
#[serde_as]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProxyConfig {
 /// 其它字段....
 pub(crate) map_http_bind: Option<SocketAddr>,
 pub(crate) map_https_bind: Option<SocketAddr>,
 pub(crate) map_tcp_bind: Option<SocketAddr>,
 // 新加代理接口监听字段
 pub(crate) map_proxy_bind: Option<SocketAddr>,
 -
}
```
目前端口做唯一绑定，后续可根据配置动态响应相应的数据。

3. 做映射
> 由于代理和tcp类似，服务端均不做任务处理，只需将数据完全转发给客户端处理即可
```RUST
pub async fn server_new_prxoy(&mut self, stream: TcpStream) -> ProxyResult<()> {
 let trans = TransTcp::new(
 self.sender(),
 self.sender_work(),
 self.calc_next_id(),
 self.mappings.clone(),
 );
 tokio::spawn(async move {
 if let Err(e) = trans.process(stream, "proxy").await {
 log::warn!("内网穿透:转发Proxy转发时发生错误:{:?}", e);
 }
 });
 return Ok(());
}
```

4. 客户端处理
客户端将映射流转化成`VirtualStream`，把它当成一个虚拟流，然后逻辑均用代理的来处理
```RUST
let (virtual_sender, virtual_receiver) = channel::<ProtFrame>(10);
map.insert(p.sock_map(), virtual_sender);

if mapping.as_ref().unwrap().is_proxy() {
 let stream = VirtualStream::new(
 p.sock_map(),
 sender.clone(),
 virtual_receiver,
 );

 let (flag, username, password, udp_bind) = (
 option.flag,
 option.username.clone(),
 option.password.clone(),
 option.udp_bind.clone(),
 );
 tokio::spawn(async move {
 // 处理代理的能力
 let _ = WMCore::deal_proxy(
 stream, flag, username, password, udp_bind,
 )
 .await;
 });
}
```

> `VirtualStream`是一个虚拟出一个流连接，并实现AsyncRead及AsyncRead，可以和流一样正常操作，这也是`Trait`而不是继承的好处之一，定义就可以比较简单：
```RUST
pub struct VirtualStream
{
 // sock绑定的句柄
 id: u32,
 // 收到数据通过sender发送给中心端
 sender: PollSender<ProtFrame>,
 // 收到中心端的写入请求，转成write
 receiver: Receiver<ProtFrame>,
 // 读取的数据缓存，将转发成ProtFrame
 read: BinaryMut,
 // 写的数据缓存，直接写入到stream下，从ProtFrame转化而来
 write: BinaryMut,
}
```

5. 设计`ProxyServer`类
> 统一的代理服务类，剥离相关代码，使代码更清晰
```RUST
/// 代理服务器类, 提供代理服务
pub struct ProxyServer {
 flag: Flag,
 username: Option<String>,
 password: Option<String>,
 udp_bind: Option<IpAddr>,
 headers: Vec<ConfigHeader>,
}
```

6. 代理`HTTP`头信息的重写
在[`HTTP`类](https://github.com/tickbh/wmproxy/blob/0.2.3/src/proxy/http.rs)中添加相关代码以支持头信息重写
```RUST
impl Operate {
 fn deal_request(&self, req: &mut RecvRequest) -> ProtResult<()> {
 if let Some(headers) = &self.headers {
 // 复写Request的头文件信息
 Helper::rewrite_request(req, headers);
 }
 Ok(())
 }
 
 fn deal_response(&self, res: &mut RecvResponse) -> ProtResult<()> {
 if let Some(headers) = &self.headers {
 // 复写Request的头文件信息
 Helper::rewrite_response(res, headers);
 }
 Ok(())
 }
}
```

#### 内网代理流程图：
```mermaid
flowchart TD
 A[外部客户端] -->|以代理方式访问|B
 B[服务端监听Proxy] <-->|数据转发| C[中心服务端CenterServer]
 C <-->|协议传输|D[中心客户端CenterClient]
 D <-->|虚拟数据流|E[虚拟客户端]
 E <-->|处理数据|F[内网代理服务,可完全访问内网]
```
这样子我们就以代理的方式拥有了所有的内网HTTP相关服务的访问权限。可以简化我们网络的结构。

#### 自动化测试
内网穿透的自动化测试在 [`tests/mapping`](https://github.com/tickbh/wmproxy/blob/0.2.3/tests/mapping.rs)
将自动构建内网客户端服务，外网服务端服务做测试，以下部分代码节选：
```RUST
#[tokio::test]
async fn run_test() {
 let local_server_addr = run_server().await.unwrap();
 let addr = "127.0.0.1:0".parse().unwrap();
 let proxy = ProxyConfig::builder()
 .bind_addr(addr)
 .map_http_bind(Some(addr))
 .map_https_bind(Some(addr))
 .map_tcp_bind(Some(addr))
 .map_proxy_bind(Some(addr))
 .center(true)
 .mode("server".to_string())
 .into_value()
 .unwrap();

 let (server_addr, http_addr, https_addr, tcp_addr, proxy_addr, _sender) =
 run_mapping_server(proxy).await.unwrap();
 let mut mapping = MappingConfig::new(
 "test".to_string(),
 "http".to_string(),
 "soft.wm-proxy.com".to_string(),
 vec![],
 );
 mapping.local_addr = Some(local_server_addr);

 let mut mapping_tcp = MappingConfig::new(
 "tcp".to_string(),
 "tcp".to_string(),
 "soft.wm-proxy.com".to_string(),
 vec![],
 );
 mapping_tcp.local_addr = Some(local_server_addr);

 let mut mapping_proxy = MappingConfig::new(
 "proxy".to_string(),
 "proxy".to_string(),
 "soft.wm-proxy.com1".to_string(),
 vec![
 ConfigHeader::new(wmproxy::HeaderOper::Add, false, "from_proxy".to_string(), "mapping".to_string())
 ],
 );
 mapping_proxy.local_addr = Some(local_server_addr);

 let proxy = ProxyConfig::builder()
 .bind_addr(addr)
 .server(Some(server_addr))
 .center(true)
 .mode("client".to_string())
 .mapping(mapping)
 .mapping(mapping_tcp)
 .mapping(mapping_proxy)
 .into_value()
 .unwrap();
 let _client_sender = run_mapping_client(proxy).await.unwrap();

 fn do_build_req(url: &str, method: &str, body: &Vec<u8>) -> Request<Body> {
 let body = BinaryMut::from(body.clone());
 Request::builder()
 .method(method)
 .url(&*url)
 .body(Body::new_binary(body))
 .unwrap()
 }
 
 {
 let url = &*format!("http://{}/", local_server_addr);
 let client = Client::builder()
 // .http2(false)
 .http2_only(true)
 .add_proxy(&*format!("http://{}", proxy_addr.unwrap())).unwrap()
 .connect(&*url)
 .await
 .unwrap();

 let mut res = client
 .send_now(do_build_req(url, "GET", &vec![]))
 .await
 .unwrap();
 let mut result = BinaryMut::new();
 res.body_mut().read_all(&mut result).await;

 // 测试头信息来确认是否来源于代理
 assert_eq!(res.headers().get_value(&"from_proxy"), &"mapping");
 assert_eq!(result.remaining(), HELLO_WORLD.as_bytes().len());
 assert_eq!(result.as_slice(), HELLO_WORLD.as_bytes());
 assert_eq!(res.version(), Version::Http2);
 }
}
```

### 小结
内网代理可以实现不想暴露太多信息给外部，但是又能提供内部的完整信息支持，相当于建立了一条可用的HTTP通道。可以在有这方面需求的人优化网络结构。

点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

36干货系列从零用Rust编写负载均衡及代理，内网穿透中内网代理的实现

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

## HTTP限流
> HTTP限流是在HTTP请求处理过程中，对请求进行限制的一种技术手段。其目的是防止系统过载，保护系统的稳定性和可用性。HTTP限流可以基于不同的策略和方法，例如基于时间窗口、令牌桶、漏桶等。

常见的HTTP限流方法包括：

* **基于时间窗口**：这种方法将一段时间划分为若干个时间窗口，每个时间窗口内只允许一定数量的请求通过。例如，每秒只允许20个请求通过。
* **令牌桶**：令牌桶算法允许突发流量，只要有令牌就可以处理请求，当没有令牌时，请求就被拒绝。这种方法适用于处理突发流量的情况。和时间窗口结合时，如果当前时间段已经有20个请求，此时触发令牌桶`brust`，将当前的流量进行延时处理。
* **漏桶**：漏桶算法不允许突发流量，无论何时都只能按照一定的速率处理请求。这种方法适用于处理稳定流量的情况。

在进行HTTP限流时，需要考虑系统的实际情况和需求，选择合适的限流策略和方法。同时，还需要对系统的性能和负载进行充分的测试和评估，以确保系统的稳定性和可用性。

### 方案选择
在此项目中，选择的是基于时间窗口及令牌桶做组合使用进行限制，以下做个例子，配置
```
limit="rate=10r/s brust=10"
```
效果将是每秒钟限制10条请求，可以允许突发的10个令牌桶做一秒的延时，在下一秒允许通行。
```mermaid
sequenceDiagram
 participant C
 participant S
 C->>S: 第一秒请求数据10条
 Note right of S: 当前记录请求10条
 S->>C: 返回成功
 
 C->>S: 第一秒继续请求数据1条
 Note right of S: 当前记录请求10条+1条令牌桶
 S->>C: 延时一秒再进行后续处理返回成功
 
 C->>S: 第一秒继续请求数据9条
 Note right of S: 当前记录请求10条+10条令牌桶
 S->>C: 延时一秒再进行后续处理返回成功
 
 C->>S: 第一秒继续请求数据（1条-N条）
 Note right of S: 当前记录当前秒已满，返回拒绝
 S->>C: 直接返回错误，频率过快，已超时
 
 C-->>S: 第二秒请求数据1条
 Note right of S: 清除第一秒的记录10条 10条令牌桶转化第二秒10条记录 故当前为请求数10条+1条令牌桶
 S->>C: 延时一秒过时行后续处理返回成功
 
 C-->>S: 第三秒请求数据1条
 Note right of S: 清除第二秒的记录10条 1条令牌桶转化第三秒1条记录 故当前为请求数1条
 S->>C: 直接返回成功
```

以上是时序加令牌的请求数据和返回情况

### 限流配置
类似于nginx中的`limit_req`配置，分为`limit_req_zone`及`limit_req`两部分，可分为两个类，一个为zone，一个为关联到zone名称的具体项目
```RUST
#[derive(Debug, Clone)]
pub struct LimitReqZone {
 /// 键值的匹配方式
 pub key: String,
 /// IP个数
 pub limit: u64,
 /// 周期内可以通行的数据
 pub nums: u64,
 /// 每个周期的时间
 pub per: Duration,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LimitReq {
 zone: String,
 burst: u64,
}
```
然后在`http`的根目录下配置当前的`zone`空间，为一个`HashMap`结构，可以配置多种`zone`结构
```RUST
#[serde_as]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpConfig {
 // ...
 #[serde_as(as = "HashMap<_, DisplayFromStr>")]
 #[serde(default = "HashMap::new")]
 pub limit_req_zone: HashMap<String, LimitReqZone>,
}

#[serde_as]
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct CommonConfig {
 // ...
 #[serde_as(as = "Option<DisplayFromStr>")]
 pub limit_req: Option<LimitReq>,
}
```
因为并不是任何的请求都要进行限流，所以此处为Option，如果子级未配置，父级有配置，子级将会应用父级的配置。

以下展示在`toml`格式的配置
```TOML
# 反向代理相关，七层协议为http及https
[http]

[http.limit_req_zone]
limit = "{client_ip} limit=10m rate=10r/s"
less = "{client_ip} limit=10m rate=10r/min"


# 反向代理中的具体服务，可配置多个多组
[[http.server]]
bind_addr = "0.0.0.0:82"
server_name = "soft.wm-proxy.com"
limit_req = "zone=limit brust=10"

# 按请求路径进行rule匹配，可匹配method，看具体的处理的内容如文件服务或者负载均衡
[[http.server.location]]
limit_req = "zone=less brust=1"
rule = "/root"
file_server = { browse = true }

[[http.server.location]]
rule = "/api"
file_server = { browse = true }
```
这样子就可以实现api不同的进行不同的限速方案，可以实现更好的通用效果。

### 配置解析
* LimitReqZone解析
需要将`"{client_ip} limit=10m rate=10r/s"`转成LimitReqZone结构，此处我们用的是FromStr接口，用空格分割，第一个字段为key，后续用`=`做分割，得取相应的值
```RUST
impl FromStr for LimitReqZone {
 type Err = ProxyError;

 fn from_str(s: &str) -> Result<Self, Self::Err> {
 let v = s.split(" ").collect::<Vec<&str>>();
 let key = v[0].to_string();
 let mut limit = 0;
 let mut nums = 0;
 let mut per = Duration::new(0, 0);
 for idx in 1..v.len() {
 let key_value = v[idx].split("=").map(|k| k.trim()).collect::<Vec<&str>>();
 if key_value.len() <= 1 {
 return Err(ProxyError::Extension("未知的LimitReq"));
 }
 match key_value[0] {
 "limit" => {
 let s = ConfigSize::from_str(key_value[1])?;
 limit = s.0;
 }
 "rate" => {
 let rate_key = key_value[1]
 .split("/")
 .map(|k| k.trim())
 .collect::<Vec<&str>>();
 if rate_key.len() == 1 {
 return Err(ProxyError::Extension("未知的LimitReq"));
 }

 let rate = rate_key[0].trim_end_matches("r");
 nums = rate
 .parse::<u64>()
 .map_err(|_e| ProxyError::Extension("parse error"))?;
 
 let s = ConfigDuration::from_str(rate_key[1])?;
 per = s.0;
 }
 _ => {
 return Err(ProxyError::Extension("未知的LimitReq"));
 }
 }
 }

 Ok(LimitReqZone::new(key, limit, nums, per))
 }
}
```
* LimitReq解析

需要将`"zone=less brust=1"`转成LimitReq结构，此处我们用的是FromStr接口，用空格分割，将每个值用`=`做分割，得取相应的值
```rust
impl FromStr for LimitReq {
 type Err = ProxyError;
 fn from_str(s: &str) -> Result<Self, Self::Err> {
 let v = s.split(" ").collect::<Vec<&str>>();
 let mut zone = String::new();
 let mut brust = 0;
 for idx in 0..v.len() {
 let key_value = v[idx].split("=").map(|k| k.trim()).collect::<Vec<&str>>();
 if key_value.len() <= 1 {
 return Err(ProxyError::Extension("未知的LimitReq"));
 }
 match key_value[0] {
 "zone" => {
 zone = key_value[1].to_string();
 }
 "brust" => {
 brust = key_value[1]
 .parse::<u64>()
 .map_err(|_e| ProxyError::Extension("parse error"))?;
 }
 _ => {
 return Err(ProxyError::Extension("未知的LimitReq"));
 }
 }
 }

 Ok(LimitReq::new(zone, brust))
 }
}
```

### 限制实现
首先我们配置一个静态可访问的全局变量，因为所有的线程操作都需要汇总到此时判定是否合格

> 每个命名空间里，都将存储不超过规格数据的IP，如果超过将直接返回失败

```RUST
pub struct LimitReqData {
 /// 记录所有的ip数据的限制情况
 ips: HashMap<String, InnerLimit>,
 /// IP个数
 limit: u64,
 /// 周期内可以通行的数据
 nums: u64,
 /// 每个周期的时间
 per: Duration,
 /// 最后清理IP的时间
 last_remove: Instant,
}
```

> 全局静态数据

```RUST
lazy_static! {
 static ref GLOABL_LIMIT_REQ: RwLock<HashMap<&'static str, LimitReqData>> =
 RwLock::new(HashMap::new());
}

```

> 返回结果

```RUST
#[derive(Debug)]
pub enum LimitResult {
 Ok,
 Refuse,
 Delay(Duration),
}
```
所以的判断是否通过，我们将通过以下函数返回相应的结果，从而使外部的函数可以进行相应的处理。
```RUST
impl LimitReqData {
 pub fn recv_new_req(key: &str, ip: &String, burst: u64) -> ProtResult<LimitResult> {
 let mut write = GLOBAL_LIMIT_REQ
 .write()
 .map_err(|_| ProtError::Extension("unlock error"))?;
 if !write.contains_key(&*key) {
 return Ok(LimitResult::Ok);
 }
 write.get_mut(key).unwrap().inner_recv_new_req(ip, burst)
 }
}
```

#### 小结
我们通过全局共享数据，需要加锁获取该数据，来判定整体的KEY的流量情况，可能是IP，可能是IP+Cookie等，来灵活的针对用户限流还是针对IP限流或者其它的业务情况进行合理的安排。




点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

[build]
rustflags = ["--cfg", "tokio_unstable"]

31干货系列从零用Rust编写正反向代理，HTTP限流的实现(limit_req)

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

### 客户端代理
客户端代理常见的为http/https代理及socks代理，我们通常利用代理来隐藏客户端地址，或者通过代理来访问某些不可达的资源。

#### 定义类
```RUST
/// 客户端代理类
#[derive(Debug, Clone)]
pub enum ProxyScheme {
 Http {
 addr: SocketAddr,
 auth: Option<(String, String)>,
 },
 Https {
 addr: SocketAddr,
 auth: Option<(String, String)>,
 },
 Socks5 {
 addr: SocketAddr,
 auth: Option<(String, String)>,
 },
}
```

将字符串转成类，我们根据url的scheme来确定是何种类型，然后根据url中的用户密码来确定验证的用户密码
```RUST
impl TryFrom<&str> for ProxyScheme {
 type Error = ProtError;

 fn try_from(value: &str) -> Result<Self, Self::Error> {
 let url = Url::try_from(value)?;
 let (addr, auth) = if let Some(connect) = url.get_connect_url() {
 let addr = connect
 .parse::<SocketAddr>()
 .map_err(|_| ProtError::Extension("unknow parse"))?;
 let auth = if url.username.is_some() && url.password.is_some() {
 Some((url.username.unwrap(), url.password.unwrap()))
 } else {
 None
 };
 (addr, auth)
 } else {
 return Err(ProtError::Extension("unknow addr"))
 };
 match &url.scheme {
 webparse::Scheme::Http => Ok(ProxyScheme::Http {
 addr, auth
 }),
 webparse::Scheme::Https => Ok(ProxyScheme::Https {
 addr, auth
 }),
 webparse::Scheme::Extension(s) if s == "socks5" => {
 Ok(ProxyScheme::Socks5 { addr, auth })
 }
 _ => Err(ProtError::Extension("unknow scheme")),
 }
 }
}
```

#### 与原来的区别
原来的访问方式，访问百度的网站
```RUST
let url = "http://www.baidu.com";
let req = Request::builder().method("GET").url(url).body("").unwrap();
let client = Client::builder()
 .connect(url).await.unwrap();
let (mut recv, _sender) = client.send2(req.into_type()).await?;
let res = recv.recv().await;
```
那么我们添加代理可以用环境变量模式，以上代码保持不动，程序会自动读取环境变量数据自动访问代理
```BASH
export HTTP_PROXY="http://127.0.0.1:8090"
```
在我们的代码中添加代理地址：
```RUST
let url = "http://www.baidu.com";
let req = Request::builder().method("GET").url(url).body("").unwrap();
let client = Client::builder()
 .add_proxy("http://127.0.0.1:8090")?
 .connect(url).await.unwrap();
let (mut recv, _sender) = client.send2(req.into_type()).await?;
let res = recv.recv().await;
```
程序将会访问代理地址，如果访问失败，则请求失败。

#### 源码实现
我们将改造`connect`函数来支持我们代理请求，本质上原来没有经过代理的是一个`TcpStream`直接连接到目标网址，现在将是一个`TcpStream`连接到代理的地址，并进行相应的预处理函数，完全后将该`TcpStream`直接给http的客户端处理，代理端将进行双向绑定，不再处理内容数据的处理。

我们改造后的源码：
```RUST
pub async fn connect(self, url: U) -> ProtResult<Client>
where
 U: TryInto<Url>,
{
 let url = TryInto::<Url>::try_into(url)
 .map_err(|_e| ProtError::Extension("unknown connection url"))?;

 if self.inner.proxies.len() > 0 {
 for p in self.inner.proxies.iter() {
 match p.connect(&url).await? {
 Some(tcp) => {
 
 if url.scheme.is_https() {
 return self.connect_tls_by_stream(tcp, url).await;
 } else {
 return Ok(Client::new(self.inner, MaybeHttpsStream::Http(tcp)))
 }
 },
 None => continue,
 }
 }
 return Err(ProtError::Extension("not proxy error!"));
 } else {
 if !ProxyScheme::is_no_proxy(url.domain.as_ref().unwrap_or(&String::new())) {
 let proxies = ProxyScheme::get_env_proxies();
 for p in proxies.iter() {
 match p.connect(&url).await? {
 Some(tcp) => {
 if url.scheme.is_https() {
 return self.connect_tls_by_stream(tcp, url).await;
 } else {
 return Ok(Client::new(self.inner, MaybeHttpsStream::Http(tcp)))
 }
 },
 None => continue,
 }
 }
 }
 if url.scheme.is_https() {
 let connect = url.get_connect_url();
 let stream = self.inner_connect(&connect.unwrap()).await?;
 self.connect_tls_by_stream(stream, url).await
 } else {
 let tcp = self.inner_connect(url.get_connect_url().unwrap()).await?;
 Ok(Client::new(self.inner, MaybeHttpsStream::Http(tcp)))
 }
 }
}
```

通常配置代理相关的环境变量有如下变量
```BASH
# 设置请求http代理
export http_proxy="http://127.0.0.1:8090"
# 设置请求https代理
export https_proxy="http://127.0.0.1:8090"
# 设置哪些相关的网址或者ip不经过代理
export no_proxy="localhost, 127.0.0.1, ::1"
```

| 变量名 | 含义 | 示例 |
| --- | --- | --- |
| http_proxy | http的请求代理，如访问`http://www.baidu.com`时触发 | `http://127.0.0.1:8090` `socks5://127.0.0.1:8090` |
| https_proxy | http的请求代理，如访问`https://www.baidu.com`时触发 | `http://127.0.0.1:8090` `socks5://127.0.0.1:8090` |
| all_proxy | 两者都通用的代理地址 | 同上 |
| no_proxy | 配置哪些域名或者地址不经过代理，可配置泛域名 | `localhost` `127.0.0.1` `::1` `*.qq.com` |

#### 如何高效的读取环境变量数据
环境变量通过随着程序运行后就不会再发生变化，那么我们整个程序的运行周期内只需要完整的读取一次环境变量即可以，完成后我们可以将期保存下来，且我们还可以利用到使用才调用的原理，利用惰性的原理进行缓读，我们利用静态变量来存储其结构，[源码](https://github.com/tickbh/wenmeng/blob/0.2.1/src/protocol/proxy.rs)：
```RUST

pub fn get_env_proxies() -> &'static Vec<ProxyScheme> {
 lazy_static! {
 static ref ENV_PROXIES: Vec<ProxyScheme> = get_from_environment();
 }
 &ENV_PROXIES
}

fn get_from_environment() -> Vec<ProxyScheme> {
 let mut proxies = vec![];

 if !insert_from_env(&mut proxies, Scheme::Http, "HTTP_PROXY") {
 insert_from_env(&mut proxies, Scheme::Http, "http_proxy");
 }

 if !insert_from_env(&mut proxies, Scheme::Https, "HTTPS_PROXY") {
 insert_from_env(&mut proxies, Scheme::Https, "https_proxy");
 }

 if !(insert_from_env(&mut proxies, Scheme::Http, "ALL_PROXY")
 && insert_from_env(&mut proxies, Scheme::Https, "ALL_PROXY"))
 {
 insert_from_env(&mut proxies, Scheme::Http, "all_proxy");
 insert_from_env(&mut proxies, Scheme::Https, "all_proxy");
 }

 proxies
}


fn insert_from_env(proxies: &mut Vec<ProxyScheme>, scheme: Scheme, key: &str) -> bool {
 if let Ok(val) = env::var(key) {
 if let Ok(proxy) = ProxyScheme::try_from(&*val) {
 if scheme.is_http() {
 if let Ok(proxy) = proxy.trans_http() {
 proxies.push(proxy);
 return true;
 }
 } else {
 if let Ok(proxy) = proxy.trans_https() {
 proxies.push(proxy);
 return true;
 }
 }
 }
 }
 false
}
```

##### http请求的转化
在http请求时，代理会将我们的所有数据完整的转发到远程端，我们无需做任何的`TcpStream`的预处理，只需将数据一样的进行发送即可。

##### https请求的转化
在https请求中，因为要保证https的私密性也保证代理服务器无法嗅探其中的内容，所以代理先必须收到`connect`协议，确认和远程端做好双向绑定后，由客户端自行与远程端握手
```
CONNECT www.baidu.com:443 HTTP/1.1\r\n
Host: www.baidu.com:443\r\n\r\n
```
且代理服务器必须返回200，之后就和远端进行双向绑定，代理服务器不在处理相关内容。
```RUST

async fn tunnel<T>(
 mut conn: T,
 host: String,
 port: u16,
 user_agent: Option<HeaderValue>,
 auth: Option<HeaderValue>,
) -> ProtResult<T>
where
 T: AsyncRead + AsyncWrite + Unpin,
{
 use tokio::io::{AsyncReadExt, AsyncWriteExt};

 let mut buf = format!(
 "\
 CONNECT {0}:{1} HTTP/1.1\r\n\
 Host: {0}:{1}\r\n\
 ",
 host, port
 )
 .into_bytes();

 // user-agent
 if let Some(user_agent) = user_agent {
 buf.extend_from_slice(b"User-Agent: ");
 buf.extend_from_slice(user_agent.as_bytes());
 buf.extend_from_slice(b"\r\n");
 }

 // proxy-authorization
 if let Some(value) = auth {
 log::debug!("tunnel to {}:{} using basic auth", host, port);
 buf.extend_from_slice(b"Proxy-Authorization: ");
 buf.extend_from_slice(value.as_bytes());
 buf.extend_from_slice(b"\r\n");
 }

 // headers end
 buf.extend_from_slice(b"\r\n");

 conn.write_all(&buf).await?;

 let mut buf = [0; 8192];
 let mut pos = 0;

 loop {
 let n = conn.read(&mut buf[pos..]).await?;

 if n == 0 {
 return Err(ProtError::Extension("eof error"));
 }
 pos += n;

 let recvd = &buf[..pos];
 if recvd.starts_with(b"HTTP/1.1 200") || recvd.starts_with(b"HTTP/1.0 200") {
 if recvd.ends_with(b"\r\n\r\n") {
 return Ok(conn);
 }
 if pos == buf.len() {
 return Err(ProtError::Extension("proxy headers too long for tunnel"));
 }
 // else read more
 } else if recvd.starts_with(b"HTTP/1.1 407") {
 return Err(ProtError::Extension("proxy authentication required"));
 } else {
 return Err(ProtError::Extension("unsuccessful tunnel"));
 }
 }
}
```

##### socks5请求的转化
socks5是一种比较通用的代理服务器的能力，相对来说也都能实现http的代理请求，但是需要将其的数据做预处理，即做完认证交互等功能，会相应的多耗一些握手时间。
```RUST
async fn socks5_connect<T>(
 mut conn: T,
 url: &Url,
 auth: &Option<(String, String)>,
) -> ProtResult<T>
where
 T: AsyncRead + AsyncWrite + Unpin,
{
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use webparse::BufMut;
 let mut binary = BinaryMut::new();
 let mut data = vec![0;1024];
 if let Some(_auth) = auth {
 conn.write_all(&[5, 1, 2]).await?;
 } else {
 conn.write_all(&[5, 0]).await?;
 }

 conn.read_exact(&mut data[..2]).await?;
 if data[0] != 5 {
 return Err(ProtError::Extension("socks5 error"));
 }
 match data[1] {
 2 => {
 let (user, pass) = auth.as_ref().unwrap();
 binary.put_u8(1);
 binary.put_u8(user.as_bytes().len() as u8);
 binary.put_slice(user.as_bytes());
 binary.put_u8(pass.as_bytes().len() as u8);
 binary.put_slice(pass.as_bytes());
 conn.write_all(binary.as_slice()).await?;

 conn.read_exact(&mut data[..2]).await?;
 if data[0] != 1 || data[1] != 0 {
 return Err(ProtError::Extension("user password error"));
 }

 binary.clear();
 }
 0 => {},
 _ => {
 return Err(ProtError::Extension("no method for auth"));
 }
 }

 binary.put_slice(&[5, 1, 0, 3]);
 let domain = url.domain.as_ref().unwrap();
 let port = url.port.unwrap_or(80);
 binary.put_u8(domain.as_bytes().len() as u8);
 binary.put_slice(domain.as_bytes());
 binary.put_u16(port);
 conn.write_all(&binary.as_slice()).await?;
 conn.read_exact(&mut data[..10]).await?;
 if data[0] != 5 {
 return Err(ProtError::Extension("socks5 error"));
 }
 if data[1] != 0 {
 return Err(ProtError::Extension("network error"));
 }
 Ok(conn)
}

```


### 小结
至此，此时的http客户端已有代理请求的访问能力，可以实现通过代理请求数据，下一章我们将探讨如何通过自动化测试来增加系统的稳定性。


点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持


http代理中关于客户端是如何实现http代理的相关源码实现，详细说明了http/https/socks5代理的原理，及源码实现

33干货系列从零用Rust编写正反向代理，关于HTTP客户端代理的源码实现

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

### 关于栈`Stack`
`Stack`可以被认为是一堆书。当我们添加更多的书时，我们将它们添加到栈的顶部。当我们需要一本书时，我们从上面拿一本。 
* 添加数据称为压入栈
* 移除数据称为弹出栈
这种现象在编程中被称为后进先出（LIFO）。
存储在栈上的数据在编译时必须具有固定的大小。默认情况下，Rust在栈上为原始类型分配内存。所有存储在堆栈上的数据必须具有已知的固定大小。未知数据编译时的大小或可能更改的大小必须存储在堆中而不是栈中。

### 关于堆`Heap`
与栈相反，大多数情况下，我们需要将变量（内存）传递给不同的函数，并使它们保持比单个函数执行更长的时间。这就是我们可以使用heap的时候。

堆的组织性较差：当您将数据放在堆上时，您会请求一个一定的空间。内存分配器在堆中找到一个空位这是足够大的，标志着它正在使用，并返回一个指针，就是那个地方的地址此过程称为在堆，有时缩写为分配（将值推到堆栈不被认为是分配的）。因为指向堆的指针是已知的，固定大小的，你可以把指针存储在堆栈上，但是当你想要的时候，实际数据，您必须遵循指针。想象一下坐在一个餐厅当你进入时，你说明你的小组人数，主人会找到一张适合所有人的空桌子，然后把你带到那里。如果如果你的团队中有人迟到了，他们可以问你坐在哪里，找到你。

### 栈与堆对比
* 分配到栈比在堆上分配更快，因为分配器永远不必搜索存储新数据的位置;该位置总是在栈的顶部。相比之下，在堆上分配空间需要更多的工作，因为分配器必须首先找到足够大的空间，保存数据，然后进行簿记，为下一次配置。
* 在堆中访问数据比访问栈上的数据慢，因为你得跟着指示牌走。因为访问堆需要得到相应的指示牌，然后再根据相应的指示牌去寻找相应的位置，然后还要确定位置所占的大小。

| statck栈 | heap堆 |
| --- | --- |
| 在栈中存储数据的速度更快。| 在堆中存储数据的速度较慢。 |
| 管理栈中的内存是可预测的，也是微不足道的。| 管理堆的内存（任意大小）是非常重要的。 |
| Rust堆栈默认分配。| Box用于分配到堆。 |
| 函数的基元类型和局部变量在栈上分配。| 大小动态的数据类型，如`String`、`Vector`、`HashMap`、`Box`等，在heap上分配。 |

### 栈与堆的分配示例
> 让我们通过一个例子来直观地了解内存是如何在堆栈上分配和释放的。

```RUST
fn foo() {
 let y = 999;
 let z = 333;
}

fn main() {
 let x = 111;
 
 foo();
}
```
在上面的例子中，我们首先调用函数`main()`。`main()`函数有一个变量绑定`x`。 

| Address地址 | Name名称 | Value值 |
| --- | --- | --- |
| 0 | x | 111 |

在表中，“地址”列指的是RAM的内存地址。它从0开始，并转到您的计算机有多少RAM（字节数）。“名称”列是指变量，“值”列是指变量的值。

当`foo()`被调用时，一个新的栈帧被分配。`foo()`函数有两个变量绑定，`y`和`z`。

| Address地址 | Name名称 | Value值 |
| --- | --- | --- |
| 2 | z | 333 |
| 1 | y | 999 |
| 0 | x | 111 |

数字0、1和2不使用计算机实际使用的地址值。实际上，地址根据值由一定数量的字节分隔。

`foo()`完成后，其栈帧被释放。

| Address地址 | Name名称 | Value值 |
| --- | --- | --- |
| 0 | x | 111 |

`main()`完成后，其栈帧被释放。Rust自动在堆栈中分配和释放内存。


与堆栈相反，大多数情况下，我们需要将变量（内存）传递给不同的函数，并使它们保持比单个函数执行更长的时间。这就是我们可以使用heap的时候。


我们可以使用`Box<T>`类型在堆上分配内存。比如说，
```RUST
fn main() {
 let x = Box::new(100);
 let y = 222;
 
 println!("x = {}, y = {}", x, y);
}
```

让我们可视化在上面的例子中调用`main()`时的内存。

| Address地址 | Name名称 | Value值 |
| --- | --- | --- |
| 0 | x | ??? addr |
| 1 | y | 222 |

和前面一样，我们在堆栈上分配两个变量x和y。 
然而，当调用x时，Box::new()的值被分配在堆上。因此，x的实际值是指向堆的指针。

| Address地址 | Name名称 | Value值 |
| --- | --- | --- |
| 578 | | 100 |
| ... | ... | ... |
| 0 | x | -> 578 |
| 1 | y | 222 |


这里，变量x保存指向地址→578，这是用于演示的任意地址。堆可以以任何顺序分配和释放。因此，它可能会以不同的地址结束，并在地址之间产生漏洞。

因此，当x消失时，它首先释放堆上分配的内存。

| Address地址 | Name名称 | Value值 |
| --- | --- | --- |
| ... | ... | ... |
| 1 | y | 222 |

一旦main()完成，我们释放堆栈帧，所有东西都消失了，释放了所有内存。

### 如何排查问题
#### 堆内存的排查
关于堆内存的排查，堆内存的内存量比较大，因此数值相对会大很多，堆内存的大小通常小到几M，大到几个G，所以在堆内存排查的时候可以用宏观的内存管理器，有以下几种方法
* 如`TOP`查看内存，也可以通过调用系统的api，
* 如`memory-stats`实时查看进程当前占用内存数：
```RUST
use memory_stats::memory_stats;

fn main() {
 if let Some(usage) = memory_stats() {
 println!("Current physical memory usage: {}", usage.physical_mem);
 println!("Current virtual memory usage: {}", usage.virtual_mem);
 } else {
 println!("Couldn't get the current memory usage :(");
 }
}
```
* 可以自定义`Alloc`，因为Rust提供的全局`global_alloc`，我们可以通过自定义`Alloc`计算当前申请的内存数，以及可以用这种方式检查内存泄漏，典型的`jemalloc`就是通过这种方式来的，我们用这种方式实现简单的内存统计，我们定义了一个`Trallocator`：
```RUST

use std::alloc::{GlobalAlloc, Layout};
use std::sync::atomic::{AtomicU64, Ordering};

pub struct Trallocator<A: GlobalAlloc>(pub A, AtomicU64);

unsafe impl<A: GlobalAlloc> GlobalAlloc for Trallocator<A> {
 unsafe fn alloc(&self, l: Layout) -> *mut u8 {
 self.1.fetch_add(l.size() as u64, Ordering::SeqCst);
 self.0.alloc(l)
 }
 unsafe fn dealloc(&self, ptr: *mut u8, l: Layout) {
 self.0.dealloc(ptr, l);
 self.1.fetch_sub(l.size() as u64, Ordering::SeqCst);
 }
}

impl<A: GlobalAlloc> Trallocator<A> {
 pub const fn new(a: A) -> Self {
 Trallocator(a, AtomicU64::new(0))
 }

 pub fn reset(&self) {
 self.1.store(0, Ordering::SeqCst);
 }
 pub fn get(&self) -> u64 {
 self.1.load(Ordering::SeqCst)
 }
}
```
我们通过调用该类，实现
```RUST
use std::alloc::System;

// 这句使全局的的分配器变成我们自己的分配器
#[global_allocator]
static GLOBAL: Trallocator<System> = Trallocator::new(System);

fn main() {
 GLOBAL.reset();
 println!("memory used: {} bytes", GLOBAL.get());
 GLOBAL.reset();
 {
 let mut vec = vec![1, 2, 3, 4];
 for i in 5..20 {
 vec.push(i);
 println!("memory used: {} bytes", GLOBAL.get());
 }
 println!("{:?}", v);
 }
 
 println!("memory used: {} bytes", GLOBAL.get());
}
```
我们可以得到以下输出：
```
memory used: 0 bytes
memory used: 32 bytes
memory used: 32 bytes
memory used: 32 bytes
memory used: 32 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 64 bytes
memory used: 128 bytes
memory used: 128 bytes
memory used: 128 bytes
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
memory used: 0 bytes
```
可以看到分配完之后已经及时释放

#### 栈内存的排查
因为系统提供的栈内存通常只有8m左右，且Rust中的线程的默认栈内存只有2M，如果分配过大的栈内存将会导致栈溢出，比如
```RUST
fn main() {
 let bad = [0;10240000];
}
```
就会出现如下提示
```
thread 'main' has overflowed its stack
fatal runtime error: stack overflow
```
在现在的方法中，我并未找到有合适的检查当前进程占用的栈内存数。

* 测试用`alloc`看是否能测出栈内存：
```RUST
use std::alloc::System;
#[global_allocator]
static GLOBAL: Trallocator<System> = Trallocator::new(System);

fn main() {
 GLOBAL.reset();
 println!("memory used: {} bytes", GLOBAL.get());
 GLOBAL.reset();
 let x = 0;
 let bad = [0;10240];
 println!("memory used: {} bytes", GLOBAL.get());
}
```
运行上述程序，如下输出：
```
memory used: 0 bytes
memory used: 0 bytes
```
程序无法感知到栈内存的变化。

* 测试用`memory-stats`实时查看内存

```RUST
use memory_stats::memory_stats;

fn main() {

 if let Some(usage) = memory_stats() {
 println!("初始内存 usage: {}", usage.physical_mem);
 } else {
 println!("Couldn't get the current memory usage :(");
 }
 
 let value1 = vec![10;102400];
 
 std::thread::sleep(std::time::Duration::from_secs(1));

 if let Some(usage) = memory_stats() {
 println!("申请堆内存后 usage: {}", usage.physical_mem);
 } else {
 println!("Couldn't get the current memory usage :(");
 }
 
 let value = [10;102400];
 
 std::thread::sleep(std::time::Duration::from_secs(1));
 if let Some(usage) = memory_stats() {
 println!("申请栈内存后 usage: {}", usage.physical_mem);
 } else {
 println!("Couldn't get the current memory usage :(");
 }
 
}
```
以上程序会输出：
```
初始内存 usage: 1024000
申请堆内存后 usage: 1478656
申请栈内存后 usage: 1478656
```
我们可以感知到堆内存的变化，无法感知到栈内存的变化。

* 目前找到的可以测量类对象的栈内存值。可以用`std::mem::size_of_val`来测量类对象占用的栈内存大小，我们可以通过该方法进行栈大小的排查，看是否存在超级大的占用栈的对象，如果存在，需将其移动到堆，也就是用`Box`进行包裹。

```RUST
fn main() {
 let x = 0u32;
 assert_eq!(4, std::mem::size_of_val(&x));
 let val = vec![0u64;9999];
 assert_eq!(24, std::mem::size_of_val(&val));
 
 let mut hash = HashMap::new();
 hash.insert(1, 2);
 assert_eq!(48, std::mem::size_of_val(&hash));
 hash.insert(2, 4);
 assert_eq!(48, std::mem::size_of_val(&hash));
}
```
我们来分析下Vec的内存，为什么其占用大小为24个字节（64位的机器）

```RUST
pub struct Vec<T, A: Allocator = Global> {
 buf: RawVec<T, A>, /// 需要再进行类的分析
 len: usize, /// 占用64位，也就是8个字节
}

pub(crate) struct RawVec<T, A: Allocator = Global> {
 ptr: Unique<T>, /// 指针大小，占用64位，8字节
 cap: usize, /// 容量大小，占用64位，8字节
 alloc: A, /// 分配器，不占用栈内存
}
```
综上分析，每个`Vec`的栈大小占用内存均为24字节。程序测试一致。同样`HashMap`占用的栈大小均为48个字节，不受其Map大小的影响。

> 注意：如果用异步的Future的包围，如果返回的对象也就是`Furture<Output=xxx>`的栈大小过大，很容易在递进处理异步的情况下直接栈溢出，而此时完全还未执行到该函数，造成一种很难排查的景象
> 注意！！！异步的返回值千万栈大小不要过大！不要过大！不要过大！

* 另外还有一种是递归的函数调用，也会造成栈溢出，这类问题相对好定位：
```RUST
fn f(x: i32) {
 f(1);
}
fn main() {
 f(2);
}
```
直接会显示 
```
thread 'main' has overflowed its stack
fatal runtime error: stack overflow
```

### 小结
所以在排查内存泄漏还是排查栈大小时都需要对当前的数据进行分析，需要处理的东西较多，需要有比较好的耐心去处理，一步步的去排查推进。记得异步返回的`Output`如果过大，会导致代码还未执行，但已经栈溢出的情况。

点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

32干货系列从零用Rust编写正反向代理，关于堆和栈以及如何解决stack overflow

# wmproxy
`wmproxy`已用`Rust`实现`http/https`代理, `socks5`代理, 反向代理, 静态文件服务器，四层TCP/UDP转发，七层负载均衡，内网穿透，后续将实现`websocket`代理等，会将实现过程分享出来，感兴趣的可以一起造个轮子

## 项目地址

[国内: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)

## 旅程路线
&emsp;&emsp;大家好，我是这趟旅程的导游，可以叫我`导游`，我为大家来介绍HTTP的组装之旅。
&emsp;&emsp;大家好，我是这趟旅程的乘客，可以叫我`小H`，出来玩实在太开心了

#### 旅行开端
> 首先导游带我来了码头，说是我接一位神秘的来客

&emsp;&emsp;我问：“这个神秘的来客有什么来头？”

&emsp;&emsp;导游答：“这个神秘的来客，名字叫`socket`，这码头能正常的运营有一半的功劳是他的存在，等下他来了我们要赶紧麻溜的接待。”

&emsp;&emsp;只见远处来了一艘轮船正在缓缓的驶来，他看起来好壮观。

&emsp;&emsp;导游这时候急忙的说：“他马上就停靠进来了，这边码头的工人马上就会将他的货卸下了，去晚了就看不到全过程了。”

&emsp;&emsp;我们就立即来到了停靠点，只见有一套完善的流程正在对接着这一切，我想这是这码头能繁荣的原因吧，高效！

&emsp;&emsp;socket说：“这些东西是`http`大神要的东西，你们把它们按照指定的顺序转交给他，他会安排如何处理的！”

#### 旅行中转
> 接下来运送集装箱的过程又会碰到什么有趣的事呢？

&emsp;&emsp;我们跟随着运送车队前行，只见`http`大神安排了查验数据，但奇怪的是他只检查前面的一辆车，后面的就数一数就放行了。

&emsp;&emsp;于是我就好奇的问：“为什么前面一辆车要检查，后面的车就数一数都不用拿出来检查？”

&emsp;&emsp;http大神就笑着说：“我检查前面的车，因为我不知道这些车装了什么东西，第一辆车带有车队的信息，我就通过他来知道这趟车的内容是什么了。下面我跟你说下这辆车带的信息。”
```http
POST /report HTTP/1.1\r\n
Content-Type: application/x-www-form-urlencoded; charset=UTF-8\r\n
Accept: */*\r\n
Accept-Language: zh-CN,zh-Hans;q=0.9\r\n
Accept-Encoding: gzip, deflate, br\r\n
Host: www.wm-proxy.com\r\n
Origin: https://www.wm-proxy.com\r\n
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15\r\n
Referer: https://www.wm-proxy.com/\r\n
Content-Length: 218\r\n
Connection: keep-alive\r\n
\r\n
```
&emsp;&emsp;通过这第一辆车的信息，我就知道了他要找的是叫`/report`的，他用`POST`的方法去敲他家的门，他可以接受`Accept-Language: zh-CN,zh-Hans;q=0.9`这种格式的语言，接受`Accept-Encoding: gzip, deflate, br`这三种格式的压缩，及后面还带着`218`的数据，在他访问结束的时候不要立刻关闭`Connection: keep-alive`他可能还有话没说完，叫我再等等，然后通过`\r\n\r\n`表示他没有其它信息了。

&emsp;&emsp;我惊叹的答到：“原来这车上隐藏了这么多的信息吖，那接下来他们会遇到什么？”

&emsp;&emsp;http大神说：“我现在知道了他们的全部信息了，我现在会把这些车队组装成`Request<RecvStream>`的结构体，等下你看到那边的一扇扇门了没有，那个叫`中间件`。”

&emsp;&emsp;我来到这门前：“这怎么有两个门呢？他们等下走哪个门呢？”

&emsp;&emsp;http大神说：“他们这些门，都是有统一的规格的，他们需要按照我的规格来建这些门，左边是进的`process_request`，右边是出的`process_response`，要严格的按照这流程来，要不然会出错哦。下面我给你说下他这个门有哪些注意的”
```RUST
#[async_trait]
pub trait Middleware: Send + Sync {
 async fn process_request(&mut self, request: &mut RecvRequest) -> ProtResult<()>;
 async fn process_response(&mut self, request: &mut RecvRequest, response: &mut RecvResponse) -> ProtResult<()>;
}
```

&emsp;&emsp;他们按照这规格建起各种各样的门，他们可以规定进门后要怎么处理我组装的这个车队`RecvRequest`，比如要把车队变成红色之类等操作或者记录下有多少个车队经过等，这样我就可以不会显得臃肿，但是我的能力却是大大的提升了起来。

&emsp;&emsp;我表示羡慕到：“原来这种方式强大可以变得这么优雅。那通过这些门后会有什么好玩的？”

#### 旅程终点
> 过了`中间件`的门，我们就来到了这旅程的终点。我们来到了一个大广场，广场上有个神奇的装置，看起来像传送门。

&emsp;&emsp;我就很好奇的问：“这传送门看起来的有点高级，这边角好像和刚才那门有点像，难道也是要遵循你的规则？”

&emsp;&emsp;http大神回答：“观察力不错哦，这传送门也是同样的道理哦，因为我也不知道他们要把这个数据拿来干什么，所以我就弄了个传送门，让他们把数据加工好后再给我咯，我的要求就是建传送门必须要按以下格式”
```
#[async_trait]
pub trait OperateTrait {
 async fn operate(&mut self, req: &mut RecvRequest) -> ProtResult<RecvResponse>;
}
```
&emsp;&emsp;“他们必须返回给我一个`RecvResponse`或者一个错误，我等下好告诉`socket`要运送哪些东西回去。你看，从传送门里出来了一个对象`Ok(RecvResponse)`，那我们接下来把这个对象带回去。这对象类似这样子的内容：”
```HTTP
HTTP/1.1 200 OK\r\n
Content-Encoding: deflate\r\n
Date: Wed, 22 Nov 2023 11:30:23 GMT\r\n
Content-Type: application/json;charset=UTF-8\r\n
Content-Length: 31\r\n
Connection: keep-alive\r\n
Access-Control-Allow-Origin: *\r\n
\r\n
```

#### 旅程返程
> 得到了正在的返回结果，我们就马不停蹄的往回走了

&emsp;&emsp;我们又回到了`中间件`的门，但是此时是从另一侧的门回来，上面标注着`process_response`，我想这应该是处理我们刚刚从传送门回来的对象吧，这也是逻辑严密的结构。
```RUST
async fn process_response(&mut self, request: &mut RecvRequest, response: &mut RecvResponse) -> ProtResult<()>;
```

&emsp;&emsp;经过了`中间件`的门，对象`Ok(RecvResponse)`被重新粉刷了蓝色，也做了标记，我们就把他带到了`socket`的面前。

&emsp;&emsp;socket说：“你们回来的真快，这才过去了不到10ms，把我要的东西带过来了吗？”

&emsp;&emsp;http大神说：“都在这了，顺序不要乱了哦，他们可是被暗中标记过了，乱了的话，等下就还原不回来了。”

&emsp;&emsp;于是socket就把这些数据带回去了，看着这船来船往的码头，我就感慨到，原来他们都已经预处理好各种情况的应对了，难怪看起来那么的井井有条。只见HTTP大神给了例子：
```RUST
use std::{env, error::Error, time::Duration};
use async_trait::async_trait;

use tokio::{net::TcpListener};
use webparse::{Response};
use wenmeng::{self, ProtResult, Server, RecvRequest, RecvResponse, OperateTrait, Middleware};

struct Operate;
#[async_trait]
impl OperateTrait for Operate {
 async fn operate(&mut self, req: &mut RecvRequest) -> ProtResult<RecvResponse> {
 tokio::time::sleep(Duration::new(1, 1)).await;
 let response = Response::builder()
 .version(req.version().clone())
 .body("Hello World\r\n".to_string())?;
 Ok(response.into_type())
 }
}

struct HelloMiddleware;
#[async_trait]
impl Middleware for HelloMiddleware {
 async fn process_request(&mut self, request: &mut RecvRequest) -> ProtResult<()> {
 println!("hello request {}", request.url());
 Ok(())
 }

 async fn process_response(&mut self, _request: &mut RecvRequest, response: &mut RecvResponse) -> ProtResult<()> {
 println!("hello response {}", response.status());
 Ok(())
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 env_logger::init();
 let addr = env::args()
 .nth(1)
 .unwrap_or_else(|| "0.0.0.0:8080".to_string());
 let server = TcpListener::bind(&addr).await?;
 println!("Listening on: {}", addr);
 loop {
 let (stream, addr) = server.accept().await?;
 tokio::spawn(async move {
 let mut server = Server::new(stream, Some(addr));
 server.middle(HelloMiddleware);
 let operate = Operate;
 let e = server.incoming(operate).await;
 println!("close server ==== addr = {:?} e = {:?}", addr, e);
 });
 }
}

```

#### 小结
在http的处理过程中，还有其它的好玩的东西，需要注意的东西，这次我们介绍了中间件及回调处理的小小见闻。以下是一个小demo


点击 **[关注]**，**[在看]**，**[点赞]** 是对作者最大的支持

30干货系列从零用Rust编写正反向代理，HTTP的组装之旅（中间件）

用Rust实现http/https代理, socks5代理, 负载均衡, 反向代理, 静态文件服务器，四层TCP/UDP转发，websocket转发, 内网穿透nat 