File size: 4,339 Bytes
2d8be8f | 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 | // Copyright 2019-2023 Tauri Programme within The Commons Conservancy
// SPDX-License-Identifier: Apache-2.0
// SPDX-License-Identifier: MIT
//! Expose your apps assets through a localhost server instead of the default custom protocol.
//!
//! **Note: This plugins brings considerable security risks and you should only use it if you know what your are doing. If in doubt, use the default custom protocol implementation.**
#![doc(
html_logo_url = "https://github.com/tauri-apps/tauri/raw/dev/app-icon.png",
html_favicon_url = "https://github.com/tauri-apps/tauri/raw/dev/app-icon.png"
)]
use std::collections::HashMap;
use http::Uri;
use tauri::{
plugin::{Builder as PluginBuilder, TauriPlugin},
Runtime,
};
use tiny_http::{Header, Response as HttpResponse, Server};
pub struct Request {
url: String,
}
impl Request {
pub fn url(&self) -> &str {
&self.url
}
}
pub struct Response {
headers: HashMap<String, String>,
}
impl Response {
pub fn add_header<H: Into<String>, V: Into<String>>(&mut self, header: H, value: V) {
self.headers.insert(header.into(), value.into());
}
}
type OnRequest = Option<Box<dyn Fn(&Request, &mut Response) + Send + Sync>>;
pub struct Builder {
port: u16,
host: Option<String>,
on_request: OnRequest,
}
impl Builder {
pub fn new(port: u16) -> Self {
Self {
port,
host: None,
on_request: None,
}
}
// Change the host the plugin binds to. Defaults to `localhost`.
pub fn host<H: Into<String>>(mut self, host: H) -> Self {
self.host = Some(host.into());
self
}
pub fn on_request<F: Fn(&Request, &mut Response) + Send + Sync + 'static>(
mut self,
f: F,
) -> Self {
self.on_request.replace(Box::new(f));
self
}
pub fn build<R: Runtime>(mut self) -> TauriPlugin<R> {
let port = self.port;
let host = self.host.unwrap_or("localhost".to_string());
let on_request = self.on_request.take();
PluginBuilder::new("localhost")
.setup(move |app, _api| {
let asset_resolver = app.asset_resolver();
std::thread::spawn(move || {
let server =
Server::http(format!("{host}:{port}")).expect("Unable to spawn server");
for req in server.incoming_requests() {
let path = req
.url()
.parse::<Uri>()
.map(|uri| uri.path().into())
.unwrap_or_else(|_| req.url().into());
#[allow(unused_mut)]
if let Some(mut asset) = asset_resolver.get(path) {
let request = Request {
url: req.url().into(),
};
let mut response = Response {
headers: Default::default(),
};
response.add_header("Content-Type", asset.mime_type);
if let Some(csp) = asset.csp_header {
response
.headers
.insert("Content-Security-Policy".into(), csp);
}
response
.headers
.insert("Cache-Control".into(), "no-cache".into());
if let Some(on_request) = &on_request {
on_request(&request, &mut response);
}
let mut resp = HttpResponse::from_data(asset.bytes);
for (header, value) in response.headers {
if let Ok(h) = Header::from_bytes(header.as_bytes(), value) {
resp.add_header(h);
}
}
req.respond(resp).expect("unable to setup response");
}
}
});
Ok(())
})
.build()
}
}
|