# wmproxy
`wmproxy`是由`Rust`编写，已实现`http/https`代理，`socks5`代理， 反向代理，静态文件服务器，内网穿透，配置热更新等， 后续将实现`websocket`代理等，同时会将实现过程分享出来， 感兴趣的可以一起造个轮子法

## 项目 ++wmproxy++
[gite: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)


## 健康检查的意义
健康检查维持着系统的稳定运行, 极大的加速着服务的响应时间, 并保证服务器不会把消息包转发到不能响应的服务器上, 从而使系统快速稳定的运转
在LINUX系统中，系统默认TCP建立连接超时时间为127秒。通常网络不可达或者网络连接被拒绝或者网络连接超时需要耗时的时长较长。此时会超成服务器的响应时间变长很多，而且重复发起不可达的连接尝试也在耗着大量的IO资源。
当健康检查介入后，如果短时间内多次建立连接失败，则暂时判定该地址不可达，状态设置为不可达。如果此时接收到该地址的请求时直接返回错误。大大提高了响应的时间。
所以健康检查是必不可少的存在。

## 如何实现
由于健康状态需要调用的地方可能在任意处需要发起连接的地方，如果通过参数透传也会涉及到多线程的数据共用，如```Arc<Mutex<Data>>```，取用的时候也是要通过锁共用，且编码的复杂度和理解成本急剧升高，所以此处健康检查选用的是多线程共用的静态处理变量。

## Rust中的静态变量
在Rust中，全局变量可以分为两种：
- 编译期初始化的全局变量
- 运行期初始化的全局变量

编译期初始化的全局变量有：
```
const创建的常量，如 const MAX_ID:usize=usize::MAX/2;
static创建的静态变量，如 static mut REQUEST_RECV:usize=0;
```

运行期初始化的全局变量有```lazy_static```用于懒初始化。例如：

```rust
lazy_static! {
    static ref HEALTH_CHECK: RwLock<HealthCheck> = RwLock::new(HealthCheck::new(60, 3, 2));
}
```
此外还有
- 实现你自己的运行时初始化：```std::sync::Once + static mut T```
- 单线程运行时初始化的特殊情况：```thread_local```

我们此处维持一个HealthCheck的全局变量，因为程序是多线程，用thread_local，无法共用其它线程的检测，不条例预期，所以此处用读写锁来保证全局变量的正确性，读写锁的特点是允许存在多个读，但如果获取写必须保证唯一。

## 源码解析，暂时不做主动性的健康检查
接下来我们看```HealthCheck```的定义
```rust
pub struct HealthCheck {
    /// 健康检查的重置时间, 失败超过该时间会重新检查, 统一单位秒
    fail_timeout: usize,
    /// 最大失败次数, 一定时间内超过该次数认为不可访问
    max_fails: usize,
    /// 最小上线次数, 到达这个次数被认为存活
    min_rises: usize,
    /// 记录跟地址相关的信息
    health_map: HashMap<SocketAddr, HealthRecord>,
}

/// 每个SocketAddr的记录值
struct HealthRecord {
    /// 最后的记录时间
    last_record: Instant,
    /// 失败的恢复时间
    fail_timeout: Duration,
    /// 当前连续失败的次数
    fall_times: usize,
    /// 当前连续成功的次数
    rise_times: usize,
    /// 当前的状态
    failed: bool,
}
```
> 主要有最后记录时间，失败次数，成功次数，最大失败惩罚时间等元素组成

我们通过函数```is_fall_down```判定是否是异常状态，未检查前默认为正常状态，超出一定时间后，解除异常状态。
```rust
/// 检测状态是否能连接
pub fn is_fall_down(addr: &SocketAddr) -> bool {
    // 只读，获取读锁
    if let Ok(h) = HEALTH_CHECK.read() {
        if !h.health_map.contains_key(addr) {
            return false;
        }
        let value = h.health_map.get(&addr).unwrap();
        if Instant::now().duration_since(value.last_record) > value.fail_timeout {
            return false;
        }
        h.health_map[addr].failed
    } else {
        false
    }
}
```

如果连接TCP失败则调用```add_fall_down```将该地址失败连接次数+1，如果失败次数达到最大失败次数将状态置为不可用。
```rust
/// 失败时调用
pub fn add_fall_down(addr: SocketAddr) {
    // 需要写入，获取写入锁
    if let Ok(mut h) = HEALTH_CHECK.write() {
        if !h.health_map.contains_key(&addr) {
            let mut health = HealthRecord::new(h.fail_timeout);
            health.fall_times = 1;
            h.health_map.insert(addr, health);
        } else {
            let max_fails = h.max_fails;
            let value = h.health_map.get_mut(&addr).unwrap();
            // 超出最大的失败时长，重新计算状态
            if Instant::now().duration_since(value.last_record) > value.fail_timeout {
                value.clear_status();
            }
            value.last_record = Instant::now();
            value.fall_times += 1;
            value.rise_times = 0;

            if value.fall_times >= max_fails {
                value.failed = true;
            }
        }
    }
}

```

如果连接TCP成功则调用```add_rise_up```将该地址成功连接次数+1，如果成功次数达到最小次数将状态置为不可用。
```rust
/// 成功时调用
pub fn add_rise_up(addr: SocketAddr) {
    // 需要写入，获取写入锁
    if let Ok(mut h) = HEALTH_CHECK.write() {
        if !h.health_map.contains_key(&addr) {
            let mut health = HealthRecord::new(h.fail_timeout);
            health.rise_times = 1;
            h.health_map.insert(addr, health);
        } else {
            let min_rises = h.min_rises;
            let value = h.health_map.get_mut(&addr).unwrap();
            // 超出最大的失败时长，重新计算状态
            if Instant::now().duration_since(value.last_record) > value.fail_timeout {
                value.clear_status();
            }
            value.last_record = Instant::now();
            value.rise_times += 1;
            value.fall_times = 0;

            if value.rise_times >= min_rises {
                value.failed = false;
            }
        }
    }
}
```

接下来我们将```TcpStream::connect```函数统一替换成```HealthCheck::connect```外部修改几乎为0，可实现开启健康检查，后续还会有主动式的健康检查。
```rust
pub async fn connect<A>(addr: &A) -> io::Result<TcpStream>
    where
        A: ToSocketAddrs,
    {
        let addrs = addr.to_socket_addrs()?;
        let mut last_err = None;

        for addr in addrs {
            // 健康检查失败，直接返回错误
            if Self::is_fall_down(&addr) {
                last_err = Some(io::Error::new(io::ErrorKind::Other, "health check falldown"));
            } else {
                match TcpStream::connect(&addr).await {
                    Ok(stream) => 
                    {
                        Self::add_rise_up(addr);
                        return Ok(stream)
                    },
                    Err(e) => {
                        Self::add_fall_down(addr);
                        last_err = Some(e)
                    },
                }
            }
        }

        Err(last_err.unwrap_or_else(|| {
            io::Error::new(
                io::ErrorKind::InvalidInput,
                "could not resolve to any address",
            )
        }))
    }
```

#### 效果
在前三次请求的时候，将花费5秒左右才抛出拒绝链接的错误
```
connect server Err(Os { code: 10061, kind: ConnectionRefused, message: "由于目标计算机积极拒绝，无
法连接。" })
```

可以发现三次之后，将会快速的抛出错误，达成健康检查的目标
```
connect server Err(Custom { kind: Other, error: "health check falldown" })
```

> 此时被动式的健康检查已完成，后续按需要的话将按需看是否实现主动式的健康检查。

11-从零用Rust编写正反向代理, 实现TCP连接的健康检查

# wmproxy
`wmproxy`是由`Rust`编写，已实现`http/https`代理，`socks5`代理， 反向代理，静态文件服务器，内网穿透，配置热更新等， 后续将实现`websocket`代理等，同时会将实现过程分享出来， 感兴趣的可以一起造个轮子法

## 项目 ++wmproxy++
[gite: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)


## 修改header参数
> 但凡代理之类，基本上都有修改头参数的需求，就比如要获取客户端的真实IP，需要写入```x-forward-for```表示客户端的真实IP，要不然经过转发后的HTTP无法获取真实的客户端地址。

所以需要在转发的同时能进行处理头部信息的相关参数。故内网端不能仅做流量转发。而且客户端可能直接以纯```HTTP2```的协议请求内网的数据，所以同时需要支持```HTTP/1.1及HTTP2```，由于以上需求，我们把之前的简单的转发逻辑改成以服务端接收客户端请求的模式对数据进行重加工。


### 新流程如下
> 以下是数据从外网进入到内网服务器的加工流程

```mermaid
graph TD
A[外网客户端]
B[代理服务端-外网]
C[请求端]
D[新的请求端]
E[代理客户端--内网]
F[内网服务器]
A-->|请求http端口| B
B -->|解析成Request| C
C -->|修改Request中的Header|D
D -->|发送HTTP请求数据给CenterClient|E
E -->|请求内网服务器转发数据|F
```

> 以下是内网服务器返回数据给外网客户端的流程
```mermaid
graph TD
A[外网客户端]
B[代理服务端-外网]
C[新的返回端]
D[返回端]
E[代理客户端--内网]
F[内网服务器]
F -->|返回Response|E
E -->|发送HTTP数据给CenterServer|D
D -->|修改头信息加工|C
C -->|将数据转发给|B
B -->|返回数据|A
```

### 转发中的注意事项
#### 我们可以获取完整的Request再进行请求吗？
如果我们这么操作，当数据包非常的大的时候例如1G，我们此时在内存中将有完整的1G内存，那么此时只需有数个同一类的请求，将会耗尽我们的内存，所以我们必须不能这么处理。

#### 超大文件下载的转发
超大文件必须将得到的数据及时的转发给客户端，此时在内存中的值才不至于太大，又能及时的传输给客户端，要不然可能大文件下载到中转服务器的时间内客户端得不到任何数据就会空耗掉这时间。

#### http/1.1中的chunked的处理
因为http/1.1的chunked协议，由```RFC 2616```定义，

分块编码(Transfer-Encoding: chunked)是超文本传输协议(HTTP)中的一种数据传输机制,允许HTTP由网页服务器发送给客户端的数据可以分成多个部分。分块传输编码只在HTTP协议1.1版本(HTTP/1.1)中提供，如果头部中有该选项，则代表数据包是```chunked```格式。
数据分解成一系列数据块,并以一个或多个块发送,这样服务器可以发送数据而不需要预先知道发送内容的总大小。

比如我们常看到的
```rust
for data in res.chunk() {
}
```
就是表示的是数据分段接收，对于大数据这个尤为重要。

此种报文的示例
这时,报文中的实体需要改为用一系列分块来传输。
每个分块包含十六进制的长度值和数据,长度值独占一行,长度不包括它结尾的 CRLF(\r\n),也不包括分块数据结尾的 CRLF。
最后一个分块长度值必须为 0,对应的分块数据没有内容,表示实体结束。
例:
```http
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

a\r\n
01234567890\r\n
1e\r\n
wmproxy is very good nat tool\r\n
0\r\n
\r\n
```

> 此种报文中我们必须进行解析，因为客户端可能是```keep-alive```选项，可以连续进行多发。所以收到的Request和Response都是连续的。必须知道何处结束才能继续解析下一个Request/Response。http2不需要，因为http2自带的data分包机制就有这些数据的处理

### header数据的定义
- header的修改分为两部分，一部分是对请求```Request```的重写，另一部分是对返回```Response```的重写。所以我们必须同时支持这两种，且将其区分出来。每条header信息我们将定定义一个可变长的数组，如第一个字符为```proxy```则表示对```Request```修改。
- 关于修改的动作有
    1. 添加，如```x-forward-for```需要末尾添加，我们用操作符```+```，比如```[proxy, +, x-forward-for, $client_ip]```
    2. 删除，我们用操作符```+```，如```[-, hidden]```
    3. 设置，设置我们默认不做任何参数，直接以header_name开头，如```[custom-key, custom-value]```
    4. 默认值，有些值有了参数我们就不将其重写，如果没有我们则设为默认值，我们用操作符```?```，如```[?, server, wmproxy]```

> 所以我们client.yaml的配置新增至如下：
```yaml
# 连接服务端地址
server: 127.0.0.1:8091
# 连接服务端是否加密
ts: true

# 内网映射配置的数组
mappings:
  #将localhost的域名转发到本地的127.0.0.1:8080
  - name: web
    mode: http
    local_addr: 127.0.0.1:8080
    domain: localhost
    headers:
      - [proxy, +, x-forward-for, $client_ip]
      - [-, hidden]
      - [custom-key, custom-value]
      - [?, server, wmproxy]
```

mappings的结构修改
```rust
pub struct MappingConfig {
    pub name: String,
    pub mode: String,
    pub local_addr: Option<SocketAddr>,
    #[serde(default = "default_domain")]
    pub domain: String,
    #[serde(default = "default_header")]
    pub headers: Vec<Vec<String>>,
}
```
我们把headers定义成一个动态的数组。根据不同的类型做不同的数据，因为长度有变化所以做不定长参数。
以下是代码解析
```rust
pub fn parse<T: Buf>(header: ProtFrameHeader, mut buf: T) -> ProxyResult<ProtMapping> {
    must_have!(buf, 2)?;
    let len = buf.get_u16() as usize;
    let mut mappings = vec![];
    
    for _ in 0..len {
        let name = read_short_string(&mut buf)?;
        let mode = read_short_string(&mut buf)?;
        let domain = read_short_string(&mut buf)?;
        let mut headers = vec![];
        must_have!(buf, 2)?;
        let len = buf.get_u16();
        for _ in 0 .. len {
            let mut header = vec![];
            must_have!(buf, 1)?;
            let sub_len = buf.get_u8();
            for _ in 0..sub_len {
                header.push(read_short_string(&mut buf)?);
            }
            headers.push(header);
        }
        mappings.push(MappingConfig::new(name, mode, domain, headers));
    }
    Ok(ProtMapping {
        sock_map: header.sock_map(),
        mappings,
    })
}
```
如此解析成一个完整的对应域名的结构，因为服务端用不到local_addr所以不做传输。


### 核心代码的实现
> 核心处理代码在```trans/http.rs```下，外部传入一个可读可写的stream，可能是```TcpStream```也可能是```TlsStream<TcpStream>```或者其它，同时把接收的```SocketAddr```传入，以方便后续获取```$client_ip```的头文件信息。

预处理
```rust
pub async fn process<T>(self, inbound: T, addr: SocketAddr) -> Result<(), ProxyError<T>>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug,
{
    println!("new process {:?}", inbound);
    let build = Client::builder();
    let (virtual_sender, virtual_receiver) = channel::<ProtFrame>(10);
    let stream = VirtualStream::new(self.sock_map, self.sender.clone(), virtual_receiver);
    let mut client = Client::new(build.value().ok().unwrap(), stream);
    let (receiver, sender) = client.split().unwrap();
    let oper = HttpOper {
        receiver,
        sender,
        sender_work: self.sender_work.clone(),
        virtual_sender: Some(virtual_sender),
        sock_map: self.sock_map,
        mappings: self.mappings.clone(),
        http_map: None,
    };
    let mut server = Server::new(inbound, Some(addr), oper);
    tokio::spawn( async move {
        let _ = client.wait_operate().await;
    });
    let _ret = server.incoming(Self::operate).await;
    if _ret.is_err() {
        println!("ret = {:?}", _ret);
    }
    Ok(())
}
```
此时我们创建一个虚拟的Stream来做双边互传，但是此时我们还没有收到任何的Request请求，我们并不知道当前的```Host```，此时我们还未发送```ProtCreate```，等真正处理请求的时候做处理，```HttpOper```是处理每个操作时均会带的参数，我们可以根据自己需要带上该参数。

> 后续处理，其中我们读和写都用RecvStream，做到读多少数据转发多少数据，以保证数据处理的及时性
```rust
async fn inner_operate(
    mut req: Request<RecvStream>,
    data: Arc<Mutex<HttpOper>>,
) -> ProtResult<Option<Response<RecvStream>>> {
    println!("receiver req = {:?}", req.url());
    let mut value = data.lock().await;
    let sender = value.virtual_sender.take();
    // 传在该参数则为第一次, 第一次的时候发送Create创建绑定连接
    if sender.is_some() {
        let host_name = req.get_host().unwrap_or(String::new());
        // 取得相关的host数据，对内网的映射端做匹配，如果未匹配到返回错误，表示不支持
        {
            let mut config = None;
            let mut is_find = false;
            {
                let read = value.mappings.read().await;
                for v in &*read {
                    if v.domain == host_name {
                        is_find = true;
                        config = Some(v.clone());
                    }
                }
            }
            if !is_find {
                return Ok(Some(Response::builder().status(404).body("not found").ok().unwrap().into_type()));
            }
            value.http_map = config;
        }

        println!("do create prot {}, host = {:?}", value.sock_map, req.get_host());

        let create = ProtCreate::new(value.sock_map, Some(req.get_host().unwrap_or(String::new())));
        let _ = value.sender_work.send((create, sender.unwrap())).await;
    }

    if let Some(config) = &value.http_map {
        // 复写Request的头文件信息
        HeaderHelper::rewrite_request(&mut req, &config.headers);
    }

    // 将请求发送出去
    value.sender.send(req).await?;
    // 等待返回数据的到来
    let mut res = value.receiver.recv().await;
    if res.is_some() {
        if let Some(config) = &value.http_map {
            // 复写Response的头文件信息
            HeaderHelper::rewrite_response(res.as_mut().unwrap(), &config.headers);
        }
        return Ok(res);
    } else {
        return Ok(Some(Response::builder().status(503).body("cant trans").ok().unwrap().into_type()));
    }
}
```

以下是直接HTTP/1.1的请求示例

![图片.png](http://47.97.231.149/static/img/1519f52c66fdb9081f2a765349111b24.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)

以下是直接HTTP/1.1升级成HTTP2的请求示例

![图片.png](http://47.97.231.149/static/img/997480fa37fc9d65ef06712bbd66c257.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
以下是直接HTTP2的请求示例

![图片.png](http://47.97.231.149/static/img/094917cf44a172c02c45cb3130f34b10.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)

请求的返回结果均带上了添加的头部信息，测试正常，至此HTTP的内网穿透数据打通。

10-从零用Rust编写正反向代理, HTTP内网穿透支持修改头信息

9-从零用Rust编写正反向代理, HTTP2改造篇之HPACK示例, 了解http2头信息如何处理

# wmproxy
`wmproxy`是由`Rust`编写，已实现`http/https`代理，`socks5`代理， 反向代理，静态文件服务器，内网穿透，配置热更新等， 后续将实现`websocket`代理等，同时会将实现过程分享出来， 感兴趣的可以一起造个轮子法

## 项目 ++wmproxy++
[gite: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)


## HTTP/2的简介
> HTTP/1.1发表于1999年，该协议持续被使用到了至今
> HTTP/2标准于2015年5月以RFC7540正式发表。由于HTTP2对1.1协议保持有高度的兼容，并且主要以字节传输，相比于1.1有更好的传输效率和更强大的传输能力，所以他快速流行起来
- 在2017年5月，全球排名前1000万的网站中，有13.7%支持了HTTP/2。
- 在2019年6月，全球有36.5%的网站支持了HTTP/2

而http/3的标准基于UDP协议的制定，而UDP在很多场合受限相对严重，由此可以得出http/1.1和http/2将会并存非常长的一段时间。所以我们需要对两种协议进行完全支持

## 库的选择
在这里我们选择自研的解析库 [webparse](https://github.com/tickbh/webparse)和HTTP服务框架[wenmeng](https://github.com/tickbh/wenmeng)，可以将服务转化成可以支持多协议的结构。此过程可能涉及到重写头信息，也可能添加头信息，会涉及到HTTP2的头部编码问题，所以必须将HTTP2的代码做完整的解析。

### HTTP2的定义
> HTTP2的RFC主要由[7540](https://httpwg.org/specs/rfc7540.html)和补充的[7541](https://httpwg.org/specs/rfc7541.html)，因为少量数据的请求如GET请求头占比100%，头部流量的优化变成了极为重要的性能提升点，所以很大的一部分把重点放在头部（7541）的优化。

### HPACK: HTTP2的头部压缩
头部信息主要以下部分组成:
Header Field: 一个名称-值对。无论是名称还是值都由8位的字节组成，但名称限定为常见的编码（可解析成String），值可以为纯二进制。
Dynamic Table: 动态表是一个将存储的头部字段与索引值相关联的表。这个表是动态的，特定于一个编码或解码上下文。
Static Table: 静态表是一个静态地将频繁出现的头部字段与索引值相关联的表。这个表是有序的、只读的、始终可访问的，并且可以在所有编码或解码上下文之间共享。定义了一个常用的键值对以更好的压缩如(:method, GET)可由一个字节0x82表示
Header List: 一个头部列表是有序的头字段集合，这些头字段被联合编码并可以包含重复的头字段。一个完整的HTTP/2头部块中的头字段列表就是一个头部列表。如返回:status必须在其它的头前面，请求:method必须在其它前面，另一个因为需要动态添加到动态表里，如果前后顺序不一致的话，可能会导致动态表的映射值不一致，所以必须用列表的形式保证顺序。
Header Field Representation: 一个头字段可以在编码形式中表示为字面量或索引
Header Block: 一个有序的头字段表示列表，当解码时，会产生一个完整的头部列表。

#### 动态表索引值
静态表和动态表如何结合成一个单独的索引地址空间。
在HPACK中，静态表和动态表都被结合到一个单独的索引地址空间中。
索引值在1和静态表长度之间（包括两端）指的是静态表中的元素。
索引值严格大于静态表长度指的是动态表中的元素。需要从索引中减去静态表的长度以找到动态表中的索引。
严格大于两个表长度之和的索引值必须被视为解码错误。
对于一个大小为s的静态表和大小为k的动态表，下面的图表展示了整个有效的索引地址空间。
```
<----------  索引地址空间 ---------->
<--      静态表   -->  <--    动态表     -->
+---+-----------+---+  +---+-----------+---+
| 1 |    ...    | s |  |s+1|    ...    |s+k|
+---+-----------+---+  +---+-----------+---+
                       ^                   |
                       |                   V
                新值插入位置      超出大小删除位置
```

#### 如何索引
编码的头部字段可以表示为索引或文字。
索引表示将头部字段定义为静态表或动态表中的条目的引用。
文字表示通过指定其名称和值来定义头部字段。头部字段名称可以文字地表示或作为静态表或动态表中的条目的引用。头部字段值以文字形式表示。
定义了三种不同的文字表示：
将头部字段作为新条目添加到动态表开头的文字表示，如(custom-key, custom-value)。
不将头部字段添加到动态表的文字表示，如(:path, /wmproxy)。
不将头部字段添加到动态表，同时附加规定，此头部字段始终使用文字表示，尤其是当由中间人重新编码时。此表示旨在保护不因压缩而处于危险之中的头部字段值这些文字表示的选择可以通过安全考虑来指导，以保护敏感的头部字段值(如Authorization: xxxx)，不能做任何的数据索引缓存。

头部字段名称或头部字段值的文字表示可以直接或使用静态Huffman编码对八位字节序列进行编码。

#### 长度编码
整数被用于表示名称索引、头部字段索引或字符串长度。整数的表示可以在一个八位字节内的任何位置开始。为了允许优化的处理，整数的表示始终在八位字节的末尾完成。
整数由两部分表示：一个前缀，该前缀填充当前八位字节，以及一个可选的八位字节列表，当整数值不适合前缀时使用。前缀的位数（称为N）是整数表示的参数。

如果整数值足够小，即严格小于2^N-1，则在前缀的N位中对其进行编码。
可表示0-31的值，前面三位被用来做别的用途，如string的长度前缀为1，如索引头前缀为2
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | ? |       Value       |
+---+---+---+-------------------+
```
> 图：前缀中编码的整数值（以N=5为例），动态表长度更新即N=5

否则，前缀的所有位均设置为1，并且使用一个或多个八位字节列表对值进行编码，该值减去2^N-1。每个八位字节的最高有效位用作续表标记：其值设置为1，列表中的最后一个八位字节除外。八位字节的其余位用于编码减小后的值。
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | ? | 1   1   1   1   1 |
+---+---+---+-------------------+
| 1 |    Value-(2^N-1) LSB      |
+---+---------------------------+
               ...
+---+---------------------------+
| 0 |    Value-(2^N-1) MSB      |
+---+---------------------------+

```
> 图：前缀后编码的整数值（以N=5为例）

从八位字节列表解码整数值首先从列表中反转八位字节的顺序。然后，对于每个八位字节，删除其最高有效位。将八位字节的剩余位连接起来，并增加2N-1以获得整数值。

前缀大小N始终介于1和8位之间。以八位字节边界开始的整数具有8位前缀。

表示整数I的伪代码如下：
```
if I < 2^N - 1, encode I on N bits
else
    encode (2^N - 1) on N bits #即N位的1
    I = I - (2^N - 1)
    while I >= 128
         encode (I % 128 + 128) on 8 bits
         I = I / 128
    encode I on 8 bits
```
解码整数I的伪代码如下：
```
decode I from the next N bits
if I < 2^N - 1, return I
else
    M = 0
    repeat
        B = next octet
        I = I + (B & 127) * 2^M
        M = M + 7
    while B & 128 == 128
    return I

```

> 在HPACK中跟长度相关的编解码都用如上方式

#### 字符串的表示
标题字段名称和标题字段值可以表示为字符串文字。字符串文字编码为一系列八进制数字，通过直接编码字符串文字的八进制数字或使用霍夫曼编码（参见［HUFFMAN］）。
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| H |    String Length (7+)     |
+---+---------------------------+
|  String Data (Length octets)  |
+-------------------------------+
```
> 图：字符串文字表示

字符串文字表示包含以下字段：

- H：一个1位的标记H，指示字符串的八进制数字是否使用霍夫曼编码。如果1则表示用HUFFMAN编码，如果为0则普通编码
- 字符串长度： 用于编码字符串文字的八进制数字的数量，编码为具有7位前缀的整数。
- 字符串数据：字符串文字的编码数据。如果H为“0”，则编码数据是字符串文字的原始八进制数字。如果H为“1”，则编码数据是字符串文字的霍夫曼编码。

霍夫曼编码的优势：
在头信息中，可读信息出现的频率远大于不可读字节出现的概率，也就是把0-255字节按照频率出现在概率进行数据的重编码，如‘0’则编码成‘00000’，按照ASCII的方式如果表示0需要8位的编码，这里就可以节省(8-5)/8=37.5%的数据大小。


#### 头信息索引
因为HTTP2是多次复用同一个连接，头基本上会相同，如Cookie，HTTP2会将常用的（静态编码）和常用的（动态编码）将其缓存下来，在下次发送的时候，只要发送一个字节接收方就可以知道对方发送的头文件信息。
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 1 |        Index (7+)         |
+---+---------------------------+
```
> 图: 头信息索引，Index为长度编码，遵循前缀1的长度编码

##### 增量索引的文字头部字段
增量索引文字头部字段表示法将一个头部字段附加到解码后的头部列表，并将其作为新条目插入到动态表中。
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |      Index (6+)       |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
```
表示名字是索引，即Name命中，如:path命中，值为新的值，添加到动态表里

```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |           0           |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
|  Name String (Length octets)  |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
```
表示名字和值均没有在原有的表里，现将name和value添加到动态表里。

索引的两个前缀必须为```01```，如```01000010```十六进制写法则是```0x82```，<61，查静态表可得(:method, GET)，即我们通过一字节表示请求方法为GET。

以下两种情况前缀为0001开头的则表示不添加到动态表中。
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 |  Index (4+)   |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+
```
> 不进行索引，但是从表中查Name，如authorization。

```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 |       0       |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
|  Name String (Length octets)  |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets)  |
+-------------------------------+

```
> 从不进行索引

#### 更新动态表的长度
动态表大小更新表示动态表大小发生了变化。
```
  0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 1 |   Max size (5+)   |
+---+---------------------------+
```
可以设置新的最大的动态表长度。

> 至此HTTP2的头部压缩协议已基本了解完成，下一章将进行具体示例的分析。

8-从零用Rust编写正反向代理, HTTP改造篇之HPACK原理

# wmproxy
`wmproxy`是由`Rust`编写，已实现`http/https`代理，`socks5`代理， 反向代理，静态文件服务器，内网穿透，配置热更新等， 后续将实现`websocket`代理等，同时会将实现过程分享出来， 感兴趣的可以一起造个轮子法

## 项目 ++wmproxy++
[gite: https://gitee.com/tickbh/wmproxy](https://gitee.com/tickbh/wmproxy)

[github: https://github.com/tickbh/wmproxy](https://github.com/tickbh/wmproxy)


## 内网、公网

> 内网：也叫做局域网，通常指单一的网络环境。例如你家里的路由器网络、网吧、公司网络、学校网络。网络大小不定，内网中的主机可以互联互通，但是越出这个局域网访问，就无法访问该网络中的主机。

> 公网：就是互联网，其实也可以看做一个扩大版的内网，比如叫城际网，省域网，国网。有单独的公网IP，任何其它地址可以访问网络的可以直接访问该IP，从而实现服务。

## 为什么要内网穿透

### 内网限制
1. IP不固定，通过家庭网，手机4G/5G访问的出口地址都是动态的，每次连接都会变化
2. 运营商通常会做NAT转化，从而实际上你访问的出口地址其实也是一个内网地址，如通常```https://www.baidu.com/s?wd=ip```查询地址
3. 常用端口无法使用，如80/443这类标准端口被直接限制不能使用。

### 公网优缺点
1. 服务器贵，带宽贵
2. IP固定，所有端口均可开放
3. 带宽稳定，基本上所有高防机房或者云厂商都能提供稳定的带宽

## 内网穿透的场景
### 场景1:开发人员本地调试接口
描述：线上项目有问题或者有某些新功能，必须进行Debug进行调试和测试。
特点：本地调试、网速要求低、需要HTTP或者HTTPS协议。
需求：必须本地，必须HTTP[S]网址。

### 场景2：公司或者家里的本地存储或者公司内部系统
描述：如外出进行工作，或者本地有大量的私有数据（敏感不适合上云），但是自己必须得进行访问，如git服务或者照片服务等
特点：需要远程能随时随地的访问，访问内容不确定，但是需要能提供
需求：要相对比较稳定的线路，但是带宽相对要求较低

### 场景3：私有服务器和小伙伴开黑
描述：把自己的电脑做服务器，有时候云上的主机配置相对较高点的一个月费用极高，所以需要本地做私有服务器，或者把自己当做一台训练机
特点：对稳定性要求不用太高的，可以提供相应的服务

## TCP内网穿透的原理
> 内网IP无法直接被访问，所以此时需求
> 1. 内网服务器
> 2. 公网服务器，有公网IP


此时网络如下，如此外部用户就能访问到内网服务器的数据，此时内网穿透客户端及服务端是保持长连接以方便进行推送，本质上是长链接在转发数据而实现穿透功能
```mermaid
flowchart TD
    C[内网服务器]<-->|由穿透客户端连接到内网服务器|A
    A[内网穿透客户端wmproxy]<-->|建立连接/保持连接|B[内网穿透服务端wmproxy]
    B<-->|访问建立连接|D[外网用户]
```

## Rust实现内网穿透
> wmproxy一款简单易用的内网穿透工具，简单示例如下：
### 客户端相关
客户端配置```client.yaml```
```yaml
# 连接服务端地址
server: 127.0.0.1:8091
# 连接服务端是否加密
ts: true

# 内网映射配置的数组
mappings:
  #将localhost的域名转发到本地的127.0.0.1:8080
  - name: web
    mode: http
    local_addr: 127.0.0.1:8080
    domain: localhost
  #将tcp的流量无条件转到127.0.0.1:8080
  - name: tcp
    mode: tcp
    local_addr: 127.0.0.1:8080
    domain: 
```
启动客户端
```bash
wmproxy -c config/client.yaml
```

### 服务端相关
服务端配置```server.yaml```
```yaml
#绑定的ip地址
bind_addr: 127.0.0.1:8091
#代理支持的功能，1为http，2为https，4为socks5
flag: 7
#内网映射http绑定地址
map_http_bind: 127.0.0.1:8001
#内网映射tcp绑定地址
map_tcp_bind: 127.0.0.1:8002
#内网映射https绑定地址
map_https_bind: 127.0.0.1:8003
#内网映射的公钥证书，为空则是默认证书
map_cert: 
#内网映射的私钥证书，为空则是默认证书
map_key:
#接收客户端是为是加密客户端
tc: true
#当前服务模式，server为服务端，client为客户端
mode: server
```
启动服务端
```bash
wmproxy -c config/server.yaml
```

### 测试实现
> 在本地的8080端口上启动了一个简单的http文件服务器
```bash
http-server .
```
#### http测试
> 此时，8001的端口是http内网穿透通过服务端映射到客户端，并指向到8080端口，此时若访问```http://127.0.0.1:8001```则会显示

![图片.png](http://47.97.231.149/static/img/9b3e7a1d533e639cdec6d9f820d345ed.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)

> http映射是根据域名做映射此时我们的域名是127.0.0.1，所以直接返回404无法访问
> 此时若访问```http://localhost:8001```，结果如下

![图片.png](http://47.97.231.149/static/img/a1ed52984fbb47667355967ac8ad709d.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
我们就可以判定我们的内网转发成功了。

#### tcp测试
> tcp就是在该端口上的流量无条件转发到另一个端口上，此时我们可以预测tcp映射与域名无关，我们在8002上转发到了8080上，此时我们访问```http://127.0.0.1:8002```和```http://localhost:8002```都可以得到一样的结果

![图片.png](http://47.97.231.149/static/img/4913d6c494cf8e8fab4d3a357942cca8.%C3%A5%C2%9B%C2%BE%C3%A7%C2%89%C2%87.webp)
此时tcp转发成功

## 源码实现
> 因为TLS连接与协议无关，只要把普通的TCP转成TLS，剩下的均和普通连接一样处理即可，那么，此时我们只需要处理TCP和HTTP的请求转发即可。

#### 监听
在程序启动的时候看我们是否配置了相应的http/https/tcp的内网穿透转发，如果有我们对相应的端口做监听，此时如果我们是https转发，要配置相应的证书，将会对```TcpStream```升级为```TlsStream<TcpStream>```
```rust
let http_listener = if let Some(ls) = &self.option.map_http_bind {
    Some(TcpListener::bind(ls).await?)
} else {
    None
};
let mut https_listener = if let Some(ls) = &self.option.map_https_bind {
    Some(TcpListener::bind(ls).await?)
} else {
    None
};

let map_accept = if https_listener.is_some() {
    let map_accept = self.option.get_map_tls_accept().await.ok();
    if map_accept.is_none() {
        let _ = https_listener.take();
    }
    map_accept
} else {
    None
};
let tcp_listener = if let Some(ls) = &self.option.map_tcp_bind {
    Some(TcpListener::bind(ls).await?)
} else {
    None
};
```

转发相关代码，主要在两个类里，分别为```trans/http.rs```和```trans/tcp.rs```
> 在```http```里面需要预处理相关的头文件消息，
- ```X-Forwarded-For```添加IP信息，从而使内网可以知道访问的IP来源
- ```Host```，重写Host信息，让内网端如果配置负载均衡可以正确的定位到位置
- ```Server```，重写Server信息，让内网可以明确知道这个服务端的类型
#### http转发源码
> 以下为部分代码，后续将进行比较正规的HTTP服务，以适应HTTP2
```rust
pub async fn process<T>(self, mut inbound: T) -> Result<(), ProxyError<T>>
where
    T: AsyncRead + AsyncWrite + Unpin,
{
    let mut request;
    let host_name;
    let mut buffer = BinaryMut::new();
    loop {
        // 省略读信息
        request = webparse::Request::new();
        // 通过该方法解析标头是否合法, 若是partial(部分)则继续读数据
        // 若解析失败, 则表示非http协议能处理, 则抛出错误
        // 此处clone为浅拷贝，不确定是否一定能解析成功，不能影响偏移
        match request.parse_buffer(&mut buffer.clone()) {
            Ok(_) => match request.get_host() {
                Some(host) => {
                    host_name = host;
                    break;
                }
                None => {
                    if !request.is_partial() {
                        Self::err_server_status(inbound, 503).await?;
                        return Err(ProxyError::UnknownHost);
                    }
                }
            },
            // 数据不完整，还未解析完，等待传输
            Err(WebError::Http(HttpError::Partial)) => {
                continue;
            }
            Err(e) => {
                Self::err_server_status(inbound, 503).await?;
                return Err(ProxyError::from(e));
            }
        }
    }

    // 取得相关的host数据，对内网的映射端做匹配，如果未匹配到返回错误，表示不支持
    {
        let mut is_find = false;
        let read = self.mappings.read().await;
        for v in &*read {
            if v.domain == host_name {
                is_find = true;
            }
        }
        if !is_find {
            Self::not_match_err_status(inbound, "no found".to_string()).await?;
            return Ok(());
        }
    }

    // 有新的内网映射消息到达，通知客户端建立对内网指向的连接进行双向绑定，后续做正规的http服务以支持拓展
    let create = ProtCreate::new(self.sock_map, Some(host_name));
    let (stream_sender, stream_receiver) = channel::<ProtFrame>(10);
    let _ = self.sender_work.send((create, stream_sender)).await;
    
    // 创建传输端进行绑定
    let mut trans = TransStream::new(inbound, self.sock_map, self.sender, stream_receiver);
    trans.reader_mut().put_slice(buffer.chunk());
    trans.copy_wait().await?;
    // let _ = copy_bidirectional(&mut inbound, &mut outbound).await?;
    Ok(())
}
```

#### tcp转发源码
> tcp处理相对比较简单，因为我们无法确定协议里是哪个类型的源码，所以对我们来说，就是单纯的把接收的数据完全转发到新的端口里。以下是部分源码
```rust
pub async fn process<T>(self, inbound: T) -> Result<(), ProxyError<T>>
where
    T: AsyncRead + AsyncWrite + Unpin,
{
    // 寻找是否有匹配的tcp转发协议，如果有，则进行转发，如果没有则丢弃数据
    {
        let mut is_find = false;
        let read = self.mappings.read().await;

        for v in &*read {
            if v.mode == "tcp" {
                is_find = true;
            }
        }
        if !is_find {
            log::warn!("not found tcp client trans");
            return Ok(());
        }
    }

    // 通知客户端数据进行连接的建立，客户端的tcp配置只能存在有且只有一个，要不然无法确定转发源
    let create = ProtCreate::new(self.sock_map, None);
    let (stream_sender, stream_receiver) = channel::<ProtFrame>(10);
    let _ = self.sender_work.send((create, stream_sender)).await;
    
    let trans = TransStream::new(inbound, self.sock_map, self.sender, stream_receiver);
    trans.copy_wait().await?;
    Ok(())
}
```
到此部分细节已基本调通，后续将优化http的处理相关，以方便支持http的头信息重写和tcp的错误信息将写入正确的日志，以方便进行定位。

7-从零用Rust编写正反向代理, HTTP及TCP内网穿透原理及运行篇

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