wmproxy 0.2.7

http https proxy by rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Copyright 2022 - 2023 Wenmeng See the COPYRIGHT
// file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// Author: tickbh
// -----
// Created Date: 2023/09/22 10:28:28

use webparse::{Buf, BufMut};

use crate::{
    prot::{ProtFlag, ProtKind},
    ProxyResult,
};

use super::ProtFrameHeader;

/// 新的Socket连接请求,
/// 接收方创建一个虚拟链接来对应该Socket的读取写入
#[derive(Debug)]
#[allow(dead_code)]
pub struct ProtCreate {
    sock_map: u64,
    mode: u8,
    domain: Option<String>,
}

impl ProtCreate {
    pub fn new(sock_map: u64, domain: Option<String>) -> Self {
        Self {
            sock_map,
            mode: 0,
            domain,
        }
    }

    pub fn parse<T: Buf>(header: ProtFrameHeader, mut buf: T) -> ProxyResult<ProtCreate> {
        let length = buf.get_u8() as usize;
        let mut domain = None;
        if length > buf.remaining() {
            return Err(crate::ProxyError::TooShort);
        }
        if length > 0 {
            let data = &buf.chunk()[..length];
            domain = Some(String::from_utf8_lossy(data).to_string());
        }
        Ok(ProtCreate {
            sock_map: header.sock_map(),
            mode: 0,
            domain,
        })
    }

    pub fn encode<B: Buf + BufMut>(self, buf: &mut B) -> ProxyResult<usize> {
        let mut head = ProtFrameHeader::new(
            ProtKind::Create,
            ProtFlag::zero(),
            self.sock_map,
        );
        let domain_len = self
            .domain
            .as_ref()
            .map(|s| s.as_bytes().len() as u32)
            .unwrap_or(0);
        head.length = 1 + domain_len;
        let mut size = 0;
        size += head.encode(buf)?;
        size += buf.put_u8(domain_len as u8);
        if let Some(d) = &self.domain {
            size += buf.put_slice(d.as_bytes());
        }
        Ok(size)
    }

    pub fn sock_map(&self) -> u64 {
        self.sock_map
    }

    pub fn domain(&self) -> &Option<String> {
        &self.domain
    }
}