br-web 0.6.0

This is an WEB SERVER
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::io::{Read};
use std::net::TcpStream;
use log::{error, info};
use openssl::ssl::SslStream;
use crate::web_socket_message::WebSocketMessage;

const BUFFER_SIZE: usize = 1024 * 512;
const HEADER_SIZE: usize = 128;

pub struct LineReader {}

impl LineReader {
    pub fn new() -> Self {
        LineReader {}
    }
    /// 读取-消息头
    pub fn read_header(&mut self, stream: &mut TcpStream) -> Result<Vec<u8>, String> {
        let mut response = vec![];
        loop {
            let mut buffer = [0u8; HEADER_SIZE];
            match stream.read(&mut buffer) {
                Ok(e) => {
                    response.extend(buffer[..e].to_vec());
                    match e {
                        HEADER_SIZE => {
                            match response.windows(4).position(|window| window == [13, 10, 13, 10]) {
                                None => {
                                    continue;
                                }
                                Some(_e) => {
                                    break;
                                }
                            };
                        }
                        _ => {
                            break;
                        }
                    }
                }
                Err(e) => return Err(format!("读取错误 1001: {}", e))
            }
        }
        Ok(response)
    }
    /// 读取ssl消息头
    pub fn read_header_ssl(&mut self, stream: &mut SslStream<TcpStream>) -> Result<Vec<u8>, String> {
        let mut response = vec![];
        loop {
            let mut buffer = [0u8; HEADER_SIZE];
            match stream.read(&mut buffer) {
                Ok(e) => {
                    response.extend(buffer[..e].to_vec());
                    match e {
                        HEADER_SIZE => {
                            match response.windows(4).position(|window| window == [13, 10, 13, 10]) {
                                None => {
                                    continue;
                                }
                                Some(_) => {
                                    break;
                                }
                            };
                        }
                        _ => {
                            break;
                        }
                    }
                }
                Err(e) => return Err(format!("读取错误 1004: {}", e))
            }
        }
        Ok(response)
    }

    /// 读取消息体
    pub fn read_body(&mut self, stream: &mut TcpStream, content_length: usize, body: Vec<u8>) -> Result<Vec<u8>, String> {
        let mut response = body.clone();
        loop {
            let mut buffer = [0u8; BUFFER_SIZE];
            match stream.read(&mut buffer) {
                Ok(e) => {
                    response.extend(buffer[..e].to_vec());
                    if response.len() >= content_length {
                        break;
                    }
                    continue;
                }
                Err(e) => return Err(format!("读取错误1003: {}", e))
            }
        }
        Ok(response)
    }

    /// 读取ssl消息体
    pub fn read_body_ssl(&mut self, stream: &mut SslStream<TcpStream>, content_length: usize, body: Vec<u8>) -> Result<Vec<u8>, String> {
        let mut response = body.clone();
        loop {
            let mut buffer = [0u8; BUFFER_SIZE];
            match stream.read(&mut buffer) {
                Ok(e) => {
                    response.extend(buffer[..e].to_vec());
                    if response.len() >= content_length {
                        let last_four: Vec<u8> = response.iter().rev().take(2).rev().cloned().collect();
                        if last_four == vec![13, 10] {
                            break;
                        }
                        continue;
                    }
                    continue;
                }
                Err(e) => return Err(format!("读取错误1003: {}", e))
            }
        }
        Ok(response)
    }

    /// 读取-websocket消息
    pub fn read_websocket(&mut self, stream: &mut TcpStream) -> Result<Vec<u8>, String> {
        let mut response = vec![];
        loop {
            let mut buffer = [0u8; HEADER_SIZE];
            match stream.read(&mut buffer) {
                Ok(0) => return Err("连接关闭".to_string()),
                Ok(n) => {
                    response.extend(buffer[..n].to_vec());
                    match WebSocketMessage::parse_message(response.clone()) {
                        Ok(e) => {
                            response = vec![];
                            info!("收到消息: {:?}", e.text);
                            break;
                        }
                        Err(e) => {
                            error!("错误: {}", e);
                            continue;
                        }
                    };
                }
                Err(e) => return Err(format!("连接失败: {}", e))
            }
        }
        Ok(response)
    }
}