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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::io;
use std::path::{PathBuf};
use std::sync::{Arc};
use std::str::from_utf8;

use tk_http::Status;
use http_file_headers::{Input as HeadersInput, Output};

use config::static_files::{Static, Mode};
use default_error_page::{serve_error_page};
use incoming::{Input, Request, Transport};
use handlers::files::decode::decode_component;
use handlers::files::pools::get_pool;
use handlers::files::common::{reply_file, NotFile};
use handlers::files::index::generate_index;


pub fn serve_dir<S: Transport>(settings: &Arc<Static>, mut inp: Input)
    -> Request<S>
{
    // TODO(tailhook) check for symlink attacks
    let path = match path(settings, &inp) {
        Ok(p) => p,
        Err(()) => {
            return serve_error_page(Status::Forbidden, inp);
        }
    };
    let virtual_path = strip_query(inp.headers.path().unwrap_or("/"))
        .to_string();
    inp.debug.set_fs_path(&path);
    let pool = get_pool(&inp.runtime, &settings.pool);
    let settings = settings.clone();
    let settings2 = settings.clone();

    let hinp = HeadersInput::from_headers(&settings.headers_config,
        inp.headers.method(), inp.headers.headers());
    let fut = pool.spawn_fn(move || {
        match hinp.probe_file(&path) {
            Ok(Output::Directory) if settings2.generate_index => {
                generate_index(&path, &virtual_path, &settings2)
                .map(|x| Err((NotFile::Directory(x), ())))
                .unwrap_or_else(|s| Err((NotFile::Status(s), ())))
            }
            Ok(Output::Directory) => {
                Err((NotFile::Status(Status::Forbidden), ()))
            }
            Ok(x) => Ok((x, ())),
            Err(e) => {
                if e.kind() == io::ErrorKind::PermissionDenied {
                    Err((NotFile::Status(Status::Forbidden), ()))
                } else {
                    error!("Error reading file {:?}: {}", path, e);
                    Err((NotFile::Status(Status::InternalServerError), ()))
                }
            }
        }
    });

    reply_file(inp, pool, fut, move |e, ()| {
        e.add_extra_headers(&settings.extra_headers);
    })
}

fn strip_query(path: &str) -> &str {
    match path.find(|c| c == '?' || c == '#') {
        Some(idx) => &path[..idx],
        None => path
    }
}

pub fn path(settings: &Static, inp: &Input) -> Result<PathBuf, ()> {
    let path = match settings.mode {
        Mode::relative_to_domain_root | Mode::with_hostname => {
            inp.headers.path().unwrap_or("/")
        }
        Mode::relative_to_route => inp.suffix,
    };
    let path = strip_query(path);
    let mut buf = Vec::with_capacity(path.len());
    if settings.mode == Mode::with_hostname {
        match inp.headers.host()  {
            Some(host) => {
                if host.find("/").is_some() {
                    // no slashes allowed
                    return Err(());
                }
                let name: &str = if let Some(colon) = host.find(":") {
                    &host[..colon]
                } else {
                    &host[..]
                };
                let name = if let Some(ref suf) = settings.strip_host_suffix {
                    if suf.len() >= name.len() {
                        // empty prefix is not allowed yet
                        return Err(());
                    }
                    if !name.ends_with(suf) {
                        // only this suffix should work
                        return Err(());
                    }
                    let final_dot = name.len() - suf.len() - 1;
                    if !name[final_dot..].starts_with('.') {
                        return Err(())
                    }
                    &name[..final_dot]
                } else {
                    name
                };
                buf.extend(name.as_bytes());
            }
            None => return Err(()),
        }
    }
    for cmp in path.split("/") {
        match cmp {
            "" | "." | "%2e" | "%2E" => {},
            ".." | "%2e." | "%2E." | ".%2e" | ".%2E"
            | "%2e%2e" | "%2E%2e" | "%2e%2E" | "%2E%2E" => return Err(()),
            _ => {
                if buf.len() > 0 {
                    buf.push(b'/');
                }
                decode_component(&mut buf, cmp)?;
            }
        }
    }

    // assert that we're not serving from root, this is a security check
    assert!(buf.len() == 0 || buf[0] != b'/');

    // only valid utf-8 supported so far
    let utf8 = from_utf8(&buf).map_err(|_| ())?;
    Ok(settings.path.join(utf8))
}