nomhttp 0.1.0

Parser HTTP for the rustyproxy project based on nom
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

use std::str::FromStr;

use crate::http_header::HttpHeader;
use crate::http_response_status::HttpResponseStatus;
use crate::http_transfer_encoding::HttpTransferEncoding;

#[derive(Debug, Default, Clone)]
pub struct HttpResponse {
    status: HttpResponseStatus,
    headers: Vec<HttpHeader>,
    body: Vec<u8>,
    contentlength: Option<usize>,
    transferencoding: HttpTransferEncoding,
    head: Vec<u8>,
}

impl HttpResponse {
    pub fn new(
        status: HttpResponseStatus,
        headers: Vec<HttpHeader>,
        body: Vec<u8>,
        head: Vec<u8>,
    ) -> Self {
        let contentlength = headers.iter().find(|x| x.name().to_uppercase() == "CONTENT-LENGTH");

        let contentlength = match contentlength {
            Some(x) => {
                if let Ok(x) = x.value().parse::<usize>() {
                    Some(x)
                } else {
                    None
                }
            }
            None => None,
        };

        let transferencoding = headers
            .iter()
            .find(|x| x.name() == "Transfer-Encoding" || x.name() == "transfer-encoding");

        let transferencoding = match transferencoding {
            Some(x) => HttpTransferEncoding::from_str(x.value()).unwrap(),
            None => HttpTransferEncoding::NoEncoding,
        };

        HttpResponse {
            status,
            headers,
            body,
            contentlength,
            transferencoding,
            head,
        }
    }

    pub fn is_terminated(&self) -> bool {
        if let Some(size) = self.contentlength {
            size == self.body.len()
        } else {
            true
        }
    }
    
    pub fn headers(&self) -> &Vec<HttpHeader> {
        &self.headers
    }

    pub fn is_header_terminated(&self) -> bool {
        let tail: Vec<u8> = self.head.iter().rev().take(4).copied().collect();

        matches!(tail[..], [0x0a, 0x0d, 0x0a, 0x0d])
    }

    pub fn content_length(&self) -> Option<usize> {
        self.contentlength
    }

    pub fn as_bytes(&self) -> Vec<u8> {
        let mut full_content = vec![];

        for b in &self.head {
            full_content.push(*b);
        }

        for b in &self.body {
            full_content.push(*b);
        }

        full_content
    }

    pub fn transfer_encoding(&self) -> &HttpTransferEncoding {
        &self.transferencoding
    }

    pub fn body_mut(&mut self) -> &mut Vec<u8> {
        &mut self.body
    }

    pub fn is_transfer_complete(&self) -> bool {
        let tail: Vec<u8> = self.body.iter().rev().take(5).copied().collect();
        matches!(tail[..], [0x0a, 0x0d, 0x0a, 0x0d, 0x30])
    }

    pub fn status(&self) -> &HttpResponseStatus {
        &self.status
    }

    pub fn keep_alive(&self) -> bool {
        let kah = match self.headers.iter().find(|h| h.name() == "Connection") {
            Some(h) => h.value().to_owned(),
            None => "Close".to_string(),
        };

        !matches!(kah.as_ref(), "Close")
    }
}