carrier 0.12.2

carrier is a generic secure message system for IoT
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

use endpoint;
use headers;
use headers::Headers;
use identity;
use config;
use proto;
use std::io::{Read};

pub fn main(
    _poll: osaka::Poll,
    headers: headers::Headers,
    callidentity: &identity::Identity,
    mut stream: endpoint::Stream,
) -> Option<osaka::Task<()>> {

    match headers.get(b":method") {
        Some(b"GET") => {
            let filename =
                config::persistence_dir()
                .join("carrier.toml");

            let mut buffer = String::default();
            let mut file = match std::fs::File::open(&filename) {
                Err(e) => {
                    stream.send(Headers::with_error(500, format!("{}", e)).encode());
                    return None;
                },
                Ok(v) => v,
            };

            match file.read_to_string(&mut buffer) {
                Err(e) => {
                    stream.send(Headers::with_error(500, format!("{}", e)).encode());
                    return None;
                },
                Ok(v) => v,
            };

            let config: config::ConfigToml = match toml::from_str(&buffer) {
                Err(e) => {
                    stream.send(Headers::with_error(500, format!("{}", e)).encode());
                    return None;
                },
                Ok(v) => v,
            };

            let mut v = Vec::new();
            for a in config.authorize.unwrap_or_default() {
                v.push(proto::Authorization {
                    identity:   a.identity.clone(),
                    resource:   a.resource.clone(),
                });
            }
            stream.send(Headers::ok().encode());
            stream.message(proto::AuthorizationList{
                a: v,
            });

            None
        },
        Some(b"DELETE") => {
            let identity = match headers.get(b"identity") {
                None => {
                    stream.send(Headers::with_error(400, "missing identity header").encode());
                    return None;
                }
                Some(identity) => {
                    match String::from_utf8_lossy(&identity).parse::<identity::Identity>() {
                        Err(e) => {
                            stream.send(Headers::with_error(500, format!("{}", e)).encode());
                            return None;
                        },
                        Ok(v) => v,
                    }
                }
            };

            if &identity == callidentity {
                stream.send(Headers::with_error(400, "cannot delete self").encode());
                return None;
            }

            match config::deauthorize(identity) {
                Err(e) => {
                    stream.send(Headers::with_error(500, format!("{}", e)).encode());
                    return None;
                },
                Ok(v) => v,
            }

            stream.send(Headers::ok().encode());
            None
        },
        Some(b"POST") => {
            let resource = match headers.get(b"resource") {
                None => {
                    stream.send(Headers::with_error(400, "missing resource header").encode());
                    return None;
                }
                Some(v) => {
                    String::from_utf8_lossy(&v).to_string()
                }
            };
            let identity = match headers.get(b"identity") {
                None => {
                    stream.send(Headers::with_error(400, "missing identity header").encode());
                    return None;
                }
                Some(identity) => {
                    match String::from_utf8_lossy(&identity).parse::<identity::Identity>() {
                        Err(e) => {
                            stream.send(Headers::with_error(500, format!("{}", e)).encode());
                            return None;
                        },
                        Ok(v) => v,
                    }
                }
            };

            match config::authorize(identity, resource) {
                Err(e) => {
                    stream.send(Headers::with_error(500, format!("{}", e)).encode());
                    return None;
                },
                Ok(v) => v,
            }

            stream.send(Headers::ok().encode());
            None
        },
        _ => {
            let headers = Headers::with_error(405, "method not supported");
            stream.send(headers.encode());
            None
        }
    }
}