swindon 0.7.8

An HTTP edge (frontend) server with smart websockets support 
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

use std::str::from_utf8;


#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ContentType {
    Absent,
    Valid,
    Invalid,
}

pub fn check_json<'x, I>(headers: I) -> ContentType
    where I: Iterator<Item=(&'x str, &'x [u8])>,
{
    use self::ContentType::*;
    let mut cur = Absent;
    for (name, value) in headers {
        if name.eq_ignore_ascii_case("Content-Type") {
            match cur {
                Absent => {
                    let mut chunks = value.split(|&x| x == b';');
                    let first = from_utf8(chunks.next().unwrap());
                    if first.is_err() {
                        info!("Invalid content type {:?}, must be json",
                            String::from_utf8_lossy(value));
                        return Invalid;
                    }
                    let mime = first.unwrap().trim();
                    if !mime.eq_ignore_ascii_case("application/json") {
                        info!("Invalid content type {:?}, must be json",
                            String::from_utf8_lossy(value));
                        return Invalid;
                    }
                    for chunk in chunks {
                        let mut pair = chunk.split(|&x| x == b'=');
                        match from_utf8(pair.next().unwrap()) {
                            Ok(s) if s.trim() == "charset" => {
                                let charset = pair.next()
                                    .and_then(|c| from_utf8(c).ok())
                                    .map(|c| c.trim());
                                match charset {
                                    Some("utf-8") | Some("utf8") => {}
                                    _ => {
                                        info!("Invalid content type {:?}, \
                                            charset must be utf-8",
                                            String::from_utf8_lossy(value));
                                        return Invalid;
                                    }
                                }
                            }
                            Ok(..) => {}
                            Err(..) => {}
                        }
                    }
                    cur = Valid;
                }
                Valid | Invalid => {
                    info!("Invalid content type, duplicate header");
                    return Invalid;
                }
            }
        }
    }
    return cur;
}

#[cfg(test)]
mod test {
    use super::check_json;
    use super::ContentType::*;

    #[test]
    fn simple() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json"[..])
        ].into_iter()), Valid);
    }
    #[test]
    fn charset() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json; charset=utf-8"[..]),
        ].into_iter()), Valid);
    }

    #[test]
    fn bad_charset() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json; charset=windows-1251"[..]),
        ].into_iter()), Invalid);
    }

    #[test]
    fn duplicate() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json; charset=utf-8"[..]),
            ("Content-Type", &b"application/json; charset=utf-8"[..]),
        ].into_iter()), Invalid);
    }

    #[test]
    fn extra_kwargs() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json; xx=yy; charset=utf-8"[..]),
        ].into_iter()), Valid);
    }

    #[test]
    fn extra_non_utf8() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json; xx=\x99; charset=utf-8"[..]),
        ].into_iter()), Valid);
    }

    #[test]
    fn non_utf8_charset() {
        assert_eq!(check_json(vec![
            ("Content-Type", &b"application/json; charset=\x99"[..]),
        ].into_iter()), Invalid);
    }
}