ehttpd 0.14.0

A HTTP server nano-framework, which can be used to create custom small-scale HTTP server applications
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
144
145
146
147
148
149
150
151
152
153

use ehttpd::bytes::{Data, Source};
use ehttpd::http::Request;
use std::io::Read;

#[test]
fn request_header_is_parsed() {
    // A request with a header field
    let mut source = Source::from(concat! {
        "POST /resource HTTP/1.1\r\n",
        "Host: example.test\r\n",
        "\r\n",
    });

    // Parse the request and ensure that all header components are available
    let request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    assert_eq!(request.method, b"POST");
    assert_eq!(request.target, b"/resource");
    assert_eq!(request.version, b"HTTP/1.1");
    assert_eq!(request.field("host").expect("host field is missing").as_ref(), b"example.test");
}

#[test]
fn closed_connection_has_no_request() {
    // Ensure that no request is returned
    let mut source = Source::default();
    let request: Option<Request> = Request::from_stream(&mut source).expect("failed to parse request");
    assert!(request.is_none());
}

#[test]
fn oversized_header_is_rejected() {
    // A request larger than the configured header limit
    let mut source = Source::from(concat! {
        "GET / HTTP/1.1\r\n",
        "\r\n",
    });

    // Ensure that the header is rejected
    let request: Result<Option<Request<16>>, _> = Request::from_stream(&mut source);
    let error = request.expect_err("oversized header was accepted");
    assert_eq!(error.error, "HTTP header is too large");
}

#[test]
fn body_with_content_length_is_read() {
    // A request with a fixed-length body
    let mut source = Source::from(concat! {
        "POST / HTTP/1.1\r\n",
        "Content-Length: 6\r\n",
        "\r\n",
        "<BODY>",
    });

    // Parse the request and read its body
    let mut request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    let body = request.read_body_data(6).expect("failed to read request body");
    assert_eq!(body, Some(Data::new_static(b"<BODY>")));
}

#[test]
fn body_without_content_length_is_not_read() {
    // A request without a content-length field
    let mut source = Source::from(concat! {
        "POST / HTTP/1.1\r\n",
        "\r\n",
        "<BODY>",
    });

    // Parse the request and attempt to read its body
    let mut request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    let body = request.read_body_data(6).expect("failed to inspect request body");
    assert!(body.is_none());

    // Ensure that the indeterminate body is left unread
    let mut unread = [0; 6];
    request.stream.read_exact(&mut unread).expect("failed to read remaining body");
    assert_eq!(unread, *b"<BODY>");
}

#[test]
fn chunked_body_is_not_read() {
    // A request with chunked transfer encoding
    let mut source = Source::from(concat! {
        "POST / HTTP/1.1\r\n",
        "Transfer-Encoding: chunked\r\n",
        "\r\n",
        "6\r\n",
        "<BODY>\r\n",
        "0\r\n",
        "\r\n",
    });

    // Parse the request and ensure that unsupported chunked bodies are not returned
    let mut request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    let body = request.read_body_data(6).expect("failed to inspect request body");
    assert!(body.is_none());
}

#[test]
fn body_over_limit_is_rejected() {
    // A request whose body exceeds the configured limit
    let mut source = Source::from(concat! {
        "POST / HTTP/1.1\r\n",
        "Content-Length: 6\r\n",
        "\r\n",
        "<BODY>",
    });

    // Parse the request and ensure that the oversized body is rejected
    let mut request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    let body = request.read_body_data(5);
    let error = body.expect_err("oversized body was accepted");
    assert_eq!(error.error, "HTTP body is too large");
}

#[test]
fn truncated_body_is_rejected() {
    // A request with fewer body bytes than promised
    let mut source = Source::from(concat! {
        "POST / HTTP/1.1\r\n",
        "Content-Length: 7\r\n",
        "\r\n",
        "<BODY>",
    });

    // Parse the request and ensure that the truncated body is rejected
    let mut request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    let body = request.read_body_data(7);
    let error = body.expect_err("truncated body was accepted");
    assert_eq!(error.error, "Truncated HTTP body");
}

#[test]
fn connection_close_is_recognized_inside_a_token_list() {
    // Spam the server with a lot of connection verbs
    let mut source = Source::from(concat! {
        "GET / HTTP/1.1\r\n",
        "Host: example.test\r\n",
        "Connection: keep-alive, Close, upgrade\r\n",
        "\r\n",
    });

    // Ensure the close-header is detected
    let request: Request =
        Request::from_stream(&mut source).expect("failed to parse request").expect("request is missing");
    assert!(request.has_connection_close());
}