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
use std::collections::HashMap;
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());
}
}
pub struct Builder {
port: u16,
on_request: Option<Box<dyn Fn(&Request, &mut Response) + Send + Sync>>,
}
impl Builder {
pub fn new(port: u16) -> Self {
Self {
port,
on_request: None,
}
}
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 on_request = self.on_request.take();
PluginBuilder::new("localhost")
.setup(move |app| {
let asset_resolver = app.asset_resolver();
std::thread::spawn(move || {
let server =
Server::http(&format!("localhost:{}", port)).expect("Unable to spawn server");
for req in server.incoming_requests() {
#[allow(unused_mut)]
if let Some(mut asset) = asset_resolver.get(req.url().into()) {
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);
}
if let Some(on_request) = &on_request {
on_request(&request, &mut response);
}
#[cfg(target_os = "linux")]
if let Some(response_csp) = response.headers.get("Content-Security-Policy") {
let html = String::from_utf8_lossy(&asset.bytes);
let body = html.replacen(tauri::utils::html::CSP_TOKEN, response_csp, 1);
asset.bytes = body.as_bytes().to_vec();
}
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()
}
}
