` verbatim.
140 | ///
141 | /// This call will overwrite/hide all previous messages.
142 | pub fn show_message(&self, msg: impl Into
) {
143 | let _ = self.0.send(Action::Message(msg.into()));
144 | }
145 | }
146 |
147 | #[derive(Debug, Clone)]
148 | enum Action {
149 | Reload,
150 | Message(String),
151 | }
152 |
--------------------------------------------------------------------------------
/lib/src/serve/fs.rs:
--------------------------------------------------------------------------------
1 | use std::{io::{self, ErrorKind}, path::Path};
2 |
3 | use http_range::{HttpRange, HttpRangeParseError};
4 | use hyper::{Body, Request, Response, header, StatusCode};
5 | use tokio::{fs, io::{AsyncSeekExt, AsyncReadExt}};
6 | use tokio_util::codec::{FramedRead, BytesCodec};
7 |
8 | use crate::{inject, Config};
9 | use super::{bad_request, not_found, SERVER_HEADER};
10 |
11 |
12 | /// Checks if the request matches any `config.mounts` and returns an
13 | /// appropriate response in that case. Otherwise `Ok(None)` is returned.
14 | pub(crate) async fn try_serve(
15 | req: &Request,
16 | config: &Config,
17 | ) -> Option> {
18 | let (subpath, mount) = config.mounts.iter()
19 | .filter_map(|mount| {
20 | req.uri()
21 | .path()
22 | .strip_prefix(&mount.uri_path)
23 | .map(|subpath| {
24 | // Make sure that subpath never starts with `/`.
25 | (subpath.trim_start_matches('/').to_owned(), mount)
26 | })
27 | })
28 |
29 | // We want the "most specific" mount, so the longest URI path wins.
30 | .max_by_key(|(_, mount)| mount.uri_path.len())?;
31 |
32 | Some(serve(req, &subpath, &mount.fs_path, config).await)
33 | }
34 |
35 | async fn serve(
36 | req: &Request,
37 | subpath: &str,
38 | fs_root: &Path,
39 | config: &Config,
40 | ) -> Response {
41 | log::trace!("Serving request from file server...");
42 |
43 | let subpath = Path::new(subpath);
44 | let path = fs_root.join(subpath);
45 |
46 | // Protect against directory traversal attacks.
47 | macro_rules! canonicalize {
48 | ($path:expr) => {
49 | match fs::canonicalize($path).await {
50 | Ok(v) => v,
51 | Err(e) if e.kind() == ErrorKind::NotFound => return not_found(config),
52 | Err(e) => panic!(
53 | "unhandled error: could not canonicalize path '{}': {}",
54 | $path.display(),
55 | e,
56 | ),
57 | }
58 | };
59 | }
60 |
61 | let canonical_req = canonicalize!(&path);
62 | let canonical_root = canonicalize!(fs_root);
63 | if !canonical_req.starts_with(canonical_root) {
64 | log::warn!(
65 | "Directory traversal attack detected ({:?} {}) -> responding BAD REQUEST",
66 | req.method(),
67 | req.uri().path(),
68 | );
69 |
70 | return bad_request("Bad request: requested file outside of served directory\n");
71 | }
72 |
73 | // Dispatch depending on whether it's a file or directory.
74 | if !path.exists() {
75 | not_found(config)
76 | } else if path.is_file() {
77 | log::trace!("Serving requested file");
78 | serve_file(&path, req, config).await
79 | } else if path.join("index.html").is_file() {
80 | log::trace!("Serving 'index.html' file in requested directory");
81 | serve_file(&path.join("index.html"), req, config).await
82 | } else {
83 | log::trace!("Listing contents of directory...");
84 | serve_dir(req.uri().path(), &path, config)
85 | .await
86 | .expect("failed to read directory contents due to IO error")
87 | }
88 | }
89 |
90 | /// Lists the contents of a directory.
91 | async fn serve_dir(
92 | uri_path: &str,
93 | path: &Path,
94 | config: &Config,
95 | ) -> Result, io::Error> {
96 | const DIR_LISTING_HTML: &str = include_str!("../assets/dir-listing.html");
97 |
98 | // Collect all children of this folder.
99 | let mut folders = Vec::new();
100 | let mut files = Vec::new();
101 | let mut it = fs::read_dir(path).await?;
102 | while let Some(entry) = it.next_entry().await? {
103 | let name = entry.file_name().to_string_lossy().into_owned();
104 | if entry.file_type().await?.is_file() {
105 | files.push((name, false));
106 | } else {
107 | folders.push((name + "/", false));
108 | }
109 | }
110 |
111 | // Also collect all mounts that are mounted below this path.
112 | for sd in config.mounts.iter().filter(|sd| sd.fs_path.exists()) {
113 | if let Some(rest) = sd.uri_path.strip_prefix(uri_path) {
114 | if rest.is_empty() {
115 | continue;
116 | }
117 |
118 | let name = rest.find('/')
119 | .map(|pos| &rest[..pos])
120 | .unwrap_or(rest)
121 | .to_owned();
122 | if sd.fs_path.is_dir() {
123 | folders.push((name + "/", true));
124 | } else {
125 | files.push((name, true));
126 | }
127 | }
128 | }
129 |
130 | folders.sort();
131 | files.sort();
132 |
133 | // Build list of children.
134 | let mut entries = String::from("\n");
135 | for (name, is_mount) in folders.into_iter().chain(files) {
136 | entries.push_str(&format!(
137 | "{0}\n",
138 | name,
139 | if is_mount { "mount" } else { "real" },
140 | ));
141 | }
142 |
143 | let html = DIR_LISTING_HTML
144 | .replace("{{ uri_path }}", uri_path)
145 | .replace("{{ entries }}", &entries)
146 | .replace("{{ control_path }}", config.control_path());
147 |
148 | Ok(
149 | Response::builder()
150 | .header("Content-Type", "text/html; charset=utf-8")
151 | .header("Server", SERVER_HEADER)
152 | .body(html.into())
153 | .expect("bug: invalid response")
154 | )
155 | }
156 |
157 | /// Serves a single file. If it's a HTML file, our JS code is injected.
158 | async fn serve_file(
159 | path: &Path,
160 | req: &Request,
161 | config: &Config,
162 | ) -> Response {
163 | // TODO: maybe we should return 403 if the file can't be read due to
164 | // permissions? Generally, the `unwrap`s in this function are... meh.
165 |
166 | let mime = mime_guess::from_path(&path).first();
167 | if mime.as_ref().map_or(false, |mime| mime.as_ref().starts_with("text/html")) {
168 | let raw = fs::read(path).await.expect("failed to read file");
169 | let html = inject::into(&raw, &config);
170 |
171 | Response::builder()
172 | .header("Content-Type", "text/html")
173 | .header("Content-Length", html.len().to_string())
174 | .header("Server", SERVER_HEADER)
175 | .body(html.into())
176 | .expect("bug: invalid response")
177 | } else {
178 | let mut file = fs::File::open(path).await.expect("failed to open file");
179 | let file_size = file.metadata().await.expect("failed to read file metadata").len();
180 |
181 | let mut response = Response::builder()
182 | .header("Server", SERVER_HEADER)
183 | .header(header::ACCEPT_RANGES, "bytes");
184 | if let Some(mime) = mime {
185 | response = response.header("Content-Type", mime.to_string());
186 | }
187 |
188 | if let Some(range_header) = req.headers().get(header::RANGE) {
189 | let range = match HttpRange::parse_bytes(range_header.as_bytes(), file_size) {
190 | Ok(ranges) if ranges.len() == 1 => ranges[0],
191 | Ok(_) => {
192 | return Response::builder()
193 | .status(StatusCode::BAD_REQUEST)
194 | .header("Server", SERVER_HEADER)
195 | .body("multiple ranges in 'Range' header not supported".into())
196 | .expect("bug: invalid response")
197 | }
198 | Err(HttpRangeParseError::InvalidRange) => todo!(),
199 | Err(HttpRangeParseError::NoOverlap) => {
200 | return Response::builder()
201 | .status(StatusCode::RANGE_NOT_SATISFIABLE)
202 | .header("Server", SERVER_HEADER)
203 | .body("".into())
204 | .expect("bug: invalid response");
205 | }
206 | };
207 |
208 | file.seek(io::SeekFrom::Start(range.start)).await.unwrap();
209 | let reader = FramedRead::new(file.take(range.length), BytesCodec::new());
210 | let body = Body::wrap_stream(reader);
211 | response
212 | .status(StatusCode::PARTIAL_CONTENT)
213 | .header(header::CONTENT_LENGTH, range.length)
214 | .header(header::CONTENT_RANGE, format!(
215 | "bytes {}-{}/{}",
216 | range.start,
217 | range.start + range.length,
218 | file_size,
219 | ))
220 | .body(body)
221 | .expect("bug: invalid response")
222 | } else {
223 | let body = Body::wrap_stream(FramedRead::new(file, BytesCodec::new()));
224 | response
225 | .header(header::CONTENT_LENGTH, file_size)
226 | .body(body)
227 | .expect("bug: invalid response")
228 | }
229 | }
230 | }
231 |
--------------------------------------------------------------------------------
/lib/src/serve/mod.rs:
--------------------------------------------------------------------------------
1 | use std::{convert::Infallible, future::Future, panic::AssertUnwindSafe, sync::Arc};
2 |
3 | use futures::FutureExt;
4 | use hyper::{
5 | Body, Method, Request, Response, Server, StatusCode,
6 | http::uri::PathAndQuery,
7 | service::{make_service_fn, service_fn},
8 | };
9 | use tokio::sync::broadcast::Sender;
10 |
11 | use crate::serve::proxy::ProxyContext;
12 | use super::{Action, Config};
13 |
14 | mod fs;
15 | mod proxy;
16 |
17 |
18 | pub(crate) async fn run(config: Config, actions: Sender) -> Result<(), hyper::Error> {
19 | let addr = config.bind_addr;
20 |
21 | let ctx = Arc::new(Context {
22 | config,
23 | proxy: ProxyContext::new(),
24 | });
25 | let make_service = make_service_fn(move |_| {
26 | let ctx = Arc::clone(&ctx);
27 | let actions = actions.clone();
28 |
29 | async {
30 | Ok::<_, Infallible>(service_fn(move |req| {
31 | handle_internal_errors(
32 | handle(req, Arc::clone(&ctx), actions.clone())
33 | )
34 | }))
35 | }
36 | });
37 |
38 | log::info!("Creating hyper server");
39 | let server = Server::try_bind(&addr)?.serve(make_service);
40 |
41 | log::info!("Start listening with hyper server");
42 | server.await?;
43 |
44 | Ok(())
45 | }
46 |
47 | async fn handle_internal_errors(
48 | future: impl Future
20 | 
](https://github.com/LukasKalbertodt/penguin/actions/workflows/ci.yml)
5 | [
](https://crates.io/crates/penguin-app)
6 | [
](https://crates.io/crates/penguin)
7 | [
](https://docs.rs/penguin)
8 |
9 | Penguin is a dev server featuring live-reloading, a file server, proxy support, and more.
10 | It is language and framework agnostic, so it works for basically any web project.
11 | Browser sessions can reload themselves (e.g. when a file changes) or show an overlay with a custom message (e.g. the compiler error).
12 |
13 | Penguin is available both as a command line application (`penguin-app` on crates.io) and as a library. For for more information on the library, see [its documentation](https://docs.rs/penguin). The rest of this document will mainly talk about the CLI app.
14 |
15 |
16 | ## Example
17 |
18 |