flask 1.0.0

create http Request/Response objects from a raw TcpStream
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

use super::{
    all_headers,
    array_to_vec,
    http,
    http_version,
    read_body,
    http_method,
    to_space
};

use crate::combinators::{
    crlf,
    slash,
    spaces
};

use http::{Request, Version};
use std::io::Read;
use std::net::TcpStream;
use std::str;

#[derive(PartialEq, Debug)]
struct RequestLine<'a> {
    method: &'a str,
    target: &'a str, // [u8],
    version: &'a str,
    // version: HttpVersion,
}

named!( read_request_line <RequestLine>,
    do_parse!(
        method: http_method >> opt!(spaces) >> target: to_space >> opt!(spaces) >>
        http >> slash >> version: http_version >> crlf >>
        (RequestLine {method: method, target: target , version: version})
    )
);
fn _read_http_request(mut stream: TcpStream) -> Result<Request<Vec<u8>>, http::Error> {
    let mut buf = [0; 1024];
    stream.read(&mut buf).unwrap();

    let msg = str::from_utf8(&buf).unwrap();
    let (rest1, req_line) = read_request_line(msg.as_bytes()).unwrap();
    let (rest2, headers) = all_headers(rest1).unwrap();

    let mut request = Request::builder()
                        .method(req_line.method)
                        .uri(req_line.target);
    request = match req_line.version {
        "0.9" => request.version( Version::HTTP_09 ),
        "1.0" => request.version( Version::HTTP_10 ),
        "1.1" => request.version( Version::HTTP_11 ),
        "2.0" => request.version( Version::HTTP_2 ),
        "3.0" => request.version( Version::HTTP_3 ),
        _ => { request }  // I don't know the http version so skip it
    };

    let mut content_length = 0;
    for elem in headers.iter() {
        if elem.key.to_lowercase() == "content-length" {
            content_length = elem.value.parse::<usize>().unwrap();
        }
        request = request.header(elem.key, elem.value);
    }

    if rest2.len() < content_length {
        let mut buf2 = vec![0; content_length - rest2.len()];
        stream.read(&mut buf2).unwrap();
        let mut body_vec: Vec<u8> = array_to_vec(rest2);
        for i in buf2.iter() {
            body_vec.push(*i);
        }
        return request.body(body_vec);
    } else {
        let (_, body) = read_body(rest2).unwrap();
        let body_vec: Vec<u8> = array_to_vec(body);
        return request.body(body_vec);
    }

}

pub fn read_http_request(stream: TcpStream) -> Result<Request<Vec<u8>>, http::Error> {
    _read_http_request(stream)
}