tensamin/iota
Watch
6
0
Fork
You've already forked iota
 0
Code Issues Pull requests 3 Projects Releases 1 Packages Wiki Activity Actions

[Add] basic split

Browse source
This commit is contained in:
Alex Emmet 2026-04-04 19:46:21 +02:00
commit 3cdf7c62d5
77 changed files with 506 additions and 648 deletions
Download patch file Download diff file Expand all files Collapse all files

190
web-ui/src/api.rs Executable file
View file

@ -0,0 +1,190 @@
use crate::server::server::is_local_network;
use crate::util::config_util::CONFIG;
use actix_web::{HttpRequest, HttpResponse, Responder, web};
use serde_json::{Value, json};
use std::net::SocketAddr;
use std::sync::Arc;
pub fn api_config(cfg: &mut web::ServiceConfig) {
cfg.service(
web::scope("/api")
.route("/shutdown/", web::post().to(shutdown))
.route("/reload/", web::post().to(reload))
.route("/users/add/", web::post().to(users_add))
.route("/users/remove/", web::post().to(users_remove))
.route("/users/get/", web::get().to(users_get))
.route("/communities/add/", web::post().to(communities_add))
.route("/communities/get/", web::get().to(communities_get))
.route("/settings/set/", web::post().to(settings_set))
.route("/settings/get/", web::get().to(settings_get)),
);
}
async fn settings_set(req: HttpRequest, ssl: web::Data<bool>) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let key = req.headers().get("key").and_then(|v| v.to_str().ok());
let value = req.headers().get("value").and_then(|v| v.to_str().ok());
match (key, value) {
(Some(k), Some(v)) => {
let _ = CONFIG
.write()
.await
.config
.insert(&k.to_string(), v.to_string());
success()
}
_ => error(),
}
}
async fn settings_get(req: HttpRequest, ssl: web::Data<bool>) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let config = CONFIG.read().await.config.clone();
let serde_config: Value = serde_json::to_value(config.to_string()).unwrap();
HttpResponse::Ok().json(serde_config)
}
async fn communities_get(req: HttpRequest, ssl: web::Data<bool>) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let communities = crate::communities::community_manager::get_communities().await;
let mut list = Vec::new();
for c in communities {
let val = c.frontend().await;
let s_val: Value = serde_json::to_value(val.to_string()).unwrap();
list.push(s_val);
}
HttpResponse::Ok().json(list)
}
async fn communities_add(
req: HttpRequest,
ssl: web::Data<bool>,
payload: web::Json<Value>,
) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let name = payload["name"].as_str().unwrap_or("").to_string();
let owner = payload["owner"].as_i64().unwrap_or(0);
let community = Arc::new(crate::communities::community::Community::create(name, owner).await);
crate::communities::community_manager::add_community(community).await;
success()
}
async fn users_get(req: HttpRequest, ssl: web::Data<bool>) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let users = crate::users::user_manager::get_users();
let list: Vec<_> = users
.into_iter()
.map(|u| {
let val = u.frontend();
serde_json::to_value(val.to_string()).unwrap()
})
.collect();
HttpResponse::Ok().json(list)
}
async fn users_remove(
req: HttpRequest,
ssl: web::Data<bool>,
payload: web::Json<Value>,
) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let uuid = payload.get("uuid").and_then(|v| v.as_i64()).unwrap_or(0);
crate::users::user_manager::remove_user(uuid);
crate::users::user_manager::save_users();
success()
}
async fn users_add(
req: HttpRequest,
ssl: web::Data<bool>,
payload: web::Json<Value>,
) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
let username = match payload.get("username").and_then(|v| v.as_str()) {
Some(u) => u,
_ => return error(),
};
if let (Some(user), Some(_)) = crate::users::user_manager::create_user(username).await {
let val = user.frontend();
let s_val: Value = serde_json::to_value(val.to_string()).unwrap();
HttpResponse::Ok().json(s_val)
} else {
error()
}
}
async fn shutdown(req: HttpRequest, ssl: web::Data<bool>) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
*crate::SHUTDOWN.write().await = true;
success()
}
async fn reload(req: HttpRequest, ssl: web::Data<bool>) -> impl Responder {
if !is_allowed_req(&req, *ssl.get_ref()) {
return forbidden();
}
*crate::SHUTDOWN.write().await = true;
*crate::RELOAD.write().await = true;
success()
}
fn forbidden() -> HttpResponse {
HttpResponse::Forbidden().body("403 Forbidden")
}
fn success() -> HttpResponse {
HttpResponse::Ok().json(json!({ "type": "success" }))
}
fn error() -> HttpResponse {
HttpResponse::Ok().json(json!({ "type": "error" }))
}
fn is_allowed(addr: SocketAddr, ssl: bool) -> bool {
is_local_network(addr.ip()) || ssl
}
fn is_allowed_req(req: &HttpRequest, ssl: bool) -> bool {
if let Some(addr) = req.peer_addr() {
is_allowed(addr, ssl)
} else {
false
}
}

3
web-ui/src/lib.rs Normal file
View file

@ -0,0 +1,3 @@
pub mod api;
pub mod server;
pub mod web_path_parser;

169
web-ui/src/server.rs Normal file
View file

@ -0,0 +1,169 @@
use crate::log;
use crate::server::api::api_config;
use crate::server::web_path_parser;
use crate::util::file_util::load_file_buf;
use crate::{ACTIVE_TASKS, SHUTDOWN};
use actix_web::{App, Error, HttpRequest, HttpServer, Responder, dev::ServerHandle, web};
use actix_web_actors::ws;
use rustls::ServerConfig;
use rustls::pki_types::{CertificateDer, PrivateKeyDer};
use std::{
error::Error as StdError,
io::{self, BufReader, ErrorKind},
net::IpAddr,
sync::Arc,
time::Duration,
};
async fn ws_handler(req: HttpRequest, stream: web::Payload) -> Result<impl Responder, Error> {
let path = req.path().to_string();
log!("WS connection from {:?}", req.peer_addr());
let session = WsSession::new(path);
ws::start(session, &req, stream)
}
use tokio::sync::oneshot;
pub async fn start(port: u16) -> bool {
let (tx, rx) = oneshot::channel::<ServerHandle>();
let _ = tokio::spawn(async move {
let server = match load_tls_config() {
Ok(Some(tls_config)) => {
log!("HTTPS (HTTP/2) Server running on 0.0.0.0:{}", port);
let _config = (*tls_config).clone();
HttpServer::new(move || {
App::new()
.app_data(web::Data::new(true))
.configure(api_config)
.service(web::resource("/ws/{path:.*}").route(web::get().to(ws_handler)))
.default_service(web::to(web_path_parser::handle))
})
.bind(("0.0.0.0", port))
.unwrap()
.run()
}
Ok(_) => {
log!("HTTP Server running on 0.0.0.0:{}", port);
HttpServer::new(move || {
App::new()
.app_data(web::Data::new(false))
.configure(api_config)
.service(web::resource("/ws/{path:.*}").route(web::get().to(ws_handler)))
.default_service(web::to(web_path_parser::handle))
})
.bind(("0.0.0.0", port))
.unwrap()
.run()
}
Err(e) => {
log!("TLS config error: {}", e);
return;
}
};
let server_handle = server.handle();
tx.send(server_handle).unwrap();
ACTIVE_TASKS.insert("WebServer".into());
server.await.unwrap();
ACTIVE_TASKS.remove("WebServer");
log!("Web Server shutdown complete.");
});
if let Ok(server_handle) = rx.await {
tokio::spawn(async move {
wait_for_shutdown(server_handle).await;
});
true
} else {
false
}
}
async fn wait_for_shutdown(server_handle: ServerHandle) {
loop {
if *SHUTDOWN.read().await {
log!("Shutdown signal received.");
server_handle.stop(true).await;
break;
}
tokio::time::sleep(Duration::from_millis(100)).await;
}
}
fn load_tls_config() -> Result<Option<Arc<ServerConfig>>, Box<dyn StdError>> {
let cert_file_res = load_file_buf("certs", "cert.pem");
let key_file_res = load_file_buf("certs", "cert.key");
let cert_file_buf = match cert_file_res {
Ok(b) => b,
Err(e) if e.kind() == ErrorKind::NotFound => {
log!("TLS certificate 'certs/cert.pem' not found.");
return Ok(None);
}
Err(e) => return Err(e.into()), // Other IO error
};
let key_file_buf = match key_file_res {
Ok(b) => b,
Err(e) if e.kind() == ErrorKind::NotFound => {
log!("TLS key 'certs/cert.key' not found.");
return Ok(None);
}
Err(e) => return Err(e.into()), // Other IO error
};
let cert_chain = rustls_pemfile::certs(&mut BufReader::new(cert_file_buf))
.collect::<Result<Vec<CertificateDer>, _>>()?;
// PKCS8
let mut key_reader = BufReader::new(key_file_buf);
let mut key_ders = rustls_pemfile::pkcs8_private_keys(&mut key_reader)
.map(|r| r.map(Into::into))
.collect::<Result<Vec<PrivateKeyDer>, _>>()?;
if key_ders.is_empty() {
// RSA
key_reader = BufReader::new(load_file_buf("certs", "cert.key")?); // Re-read key file
key_ders = rustls_pemfile::rsa_private_keys(&mut key_reader)
.map(|r| r.map(Into::into))
.collect::<Result<Vec<PrivateKeyDer>, _>>()?;
}
if key_ders.is_empty() {
// EC
key_reader = BufReader::new(load_file_buf("certs", "cert.key")?); // Re-read key file
key_ders = rustls_pemfile::ec_private_keys(&mut key_reader)
.map(|r| r.map(Into::into))
.collect::<Result<Vec<PrivateKeyDer>, _>>()?;
}
if key_ders.is_empty() {
return Err("No private keys found in key file. (Tried PKCS8, RSA, and EC)".into());
}
let config = ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(cert_chain, key_ders.remove(0))
.map_err(|e| io::Error::new(ErrorKind::Other, e.to_string()))?;
Ok(Some(Arc::new(config)))
}
pub fn is_local_network(addr: IpAddr) -> bool {
match addr {
IpAddr::V4(v4) => {
let o = v4.octets();
o[0] == 10
|| (o[0] == 172 && (16..=31).contains(&o[1]))
|| (o[0] == 192 && o[1] == 168)
|| o[0] == 127
|| (o[0] == 169 && o[1] == 254)
}
IpAddr::V6(v6) => {
let s = v6.segments();
(s[0] & 0xfe00) == 0xfc00 || (s[0] & 0xffc0) == 0xfe80 || v6.is_loopback()
}
}
}

77
web-ui/src/web_path_parser.rs Executable file
View file

@ -0,0 +1,77 @@
use actix_web::{HttpRequest, HttpResponse};
use std::path::{Path, PathBuf};
use crate::util::file_util::load_file_vec;
fn codec_for_ext(ext: &str) -> &'static str {
match ext {
"html" => "text/html; charset=utf-8",
"css" => "text/css",
"js" => "application/javascript",
"json" => "application/json",
"png" => "image/png",
"ico" => "image/x-icon",
"woff2" => "font/woff2",
_ => "application/octet-stream",
}
}
pub async fn handle(req: HttpRequest) -> HttpResponse {
let req_path = req.path().trim_start_matches('/');
let mut fs_path = PathBuf::from("web");
if req_path.is_empty() {
fs_path.push("index.html");
} else {
fs_path.extend(req_path.split('/'));
}
if fs_path.is_dir() {
fs_path.push("index.html");
}
let ext_opt = fs_path.extension().and_then(|e| e.to_str());
let mut final_name = fs_path
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("")
.to_string();
if ext_opt.is_none() {
if final_name.is_empty() {
final_name = "index.html".to_string();
} else {
final_name.push_str(".html");
}
}
let content_type = codec_for_ext(
fs_path
.extension()
.and_then(|e| e.to_str())
.unwrap_or("html"),
);
let dir = fs_path.parent().unwrap_or(Path::new("web"));
match load_file_vec(dir.to_str().unwrap_or("web"), &final_name) {
Ok(content) => HttpResponse::Ok().content_type(content_type).body(content),
Err(_) => {
let ext = fs_path.extension().and_then(|e| e.to_str()).unwrap_or("");
if matches!(ext, "js" | "css" | "woff2") {
return HttpResponse::NotFound()
.content_type("text/plain")
.body("Not found");
}
let fallback = load_file_vec("web", "404.html")
.unwrap_or_else(|_| include_bytes!("../../static/web/404.html").to_vec());
HttpResponse::NotFound()
.content_type("text/html; charset=utf-8")
.body(fallback)
}
}
}