//! Blocking HTTP listen: page shell, `/_part`, `/_form`, `/admin`, optional static dir. use std::collections::HashMap; use std::net::SocketAddr; use std::path::PathBuf; use std::sync::Arc; use axum::extract::{Form, Multipart, Path, Query, State}; use axum::http::{header, HeaderValue, StatusCode}; use axum::response::{Html, IntoResponse, Redirect, Response}; use axum::routing::{get, post}; use axum::Router; use serde::Deserialize; use serde_json::{json, Map, Value}; use tokio::runtime::Runtime; use tower_http::services::ServeDir; use crate::db; use crate::form; use crate::middleware::Middleware; use crate::rate_limit; use crate::render; use crate::rss; use crate::session; use crate::sitemap; use crate::storage; use crate::upload; fn with_site_head(base: &Value, site_head: &[crate::assets::HeadLink]) -> Value { let mut page = base.clone(); crate::assets::merge_site_head(&mut page, site_head); page } /// Stamp session login state so nav `when=auth|guest` can filter at render time. fn with_nav_auth(base: &Value, cookie: Option<&str>) -> Value { let mut page = base.clone(); let Some(obj) = page.as_object_mut() else { return page; }; let user = session::session_id_from_cookie(cookie) .and_then(|sid| session::session_get(&sid, "username")); let logged_in = user.is_some(); obj.insert("_logged_in".into(), json!(logged_in)); if let Some(u) = user { obj.insert("_nav_user".into(), u); } else { obj.remove("_nav_user"); } page } fn serve_icon_file(path: PathBuf, content_type: String) -> Response { match std::fs::read(&path) { Ok(bytes) => { let ct = HeaderValue::from_str(&content_type) .unwrap_or_else(|_| HeaderValue::from_static("application/octet-stream")); ( StatusCode::OK, [ (header::CONTENT_TYPE, ct), ( header::CACHE_CONTROL, HeaderValue::from_static("public, max-age=86400"), ), ], bytes, ) .into_response() } Err(_) => StatusCode::NOT_FOUND.into_response(), } } #[derive(Clone)] pub struct UploadRoute { pub field: String, pub storage_url: String, pub prefix: String, pub max_bytes: u64, pub types: Option, } #[derive(Clone)] pub struct DownloadRoute { pub storage_url: String, pub disposition: String, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum GateMatch { Exact, /// Segment-boundary prefix: `/desk` matches `/desk` and `/desk/…`, not `/desk-x`. Prefix, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum OnDeny { Redirect, Forbid, } #[derive(Clone, Debug)] pub struct Gate { pub path: String, pub roles: Vec, pub match_mode: GateMatch, pub on_deny: OnDeny, pub exclude: Vec, } impl Gate { pub fn from_json(g: &Value) -> Option { let raw = g.get("path").and_then(|v| v.as_str())?.trim(); if raw.is_empty() { return None; } let starred = raw.ends_with('*'); let mut path = raw.trim_end_matches('*').trim_end_matches('/').to_string(); if path.is_empty() { path = "/".into(); } else if !path.starts_with('/') { path = format!("/{path}"); } let roles = match g.get("roles") { Some(Value::Array(a)) => a .iter() .filter_map(|v| v.as_str().map(|s| s.to_ascii_lowercase())) .collect(), Some(Value::String(s)) => session::parse_roles_csv(s), _ => vec!["admin".into()], }; let match_s = g .get("match") .or_else(|| g.get("匹配")) .and_then(|v| v.as_str()) .unwrap_or("") .to_ascii_lowercase(); let match_mode = match match_s.as_str() { "exact" | "精确" => GateMatch::Exact, "prefix" | "前缀" => GateMatch::Prefix, _ if starred => GateMatch::Prefix, _ => GateMatch::Prefix, }; let deny_s = g .get("on_deny") .or_else(|| g.get("拒绝")) .and_then(|v| v.as_str()) .unwrap_or("") .to_ascii_lowercase(); let on_deny = match deny_s.as_str() { "redirect" | "重定向" | "login" => OnDeny::Redirect, "forbid" | "禁止" | "403" => OnDeny::Forbid, _ => OnDeny::Forbid, }; let mut exclude = Vec::new(); if let Some(Value::Array(a)) = g.get("exclude").or_else(|| g.get("排除")) { for v in a { if let Some(s) = v.as_str() { let s = s.trim(); if !s.is_empty() { exclude.push(s.to_string()); } } } } else if let Some(s) = g .get("exclude") .or_else(|| g.get("排除")) .and_then(|v| v.as_str()) { for part in s.split(',') { let part = part.trim(); if !part.is_empty() { exclude.push(part.to_string()); } } } Some(Gate { path, roles, match_mode, on_deny, exclude, }) } } #[derive(Clone)] pub struct AppState { page: Value, pub db_url: Option, admin: bool, /// Built-in admin mount root (e.g. `/admin` or `/desk`); unused when `admin` is false. admin_prefix: String, /// Login form URL (GET/POST); may differ from `{admin_prefix}/login`. login_path: String, login_redirect: String, logout_redirect: String, forms: HashMap, /// Page that owns an embedded form (for re-render on validation errors). form_owners: HashMap, /// Admin users table (`|用户名|密码|`) when login-gated admin is configured. auth_users: Option, session_ttl: u64, cookie_secure: bool, upload_routes: HashMap, download_routes: HashMap, /// Optional assembled pages for 404 / 500. page_404: Option, page_500: Option, /// Default `` links from `app.icons` / static favicon convention. site_head: Vec, } impl AppState { fn ap(&self) -> &str { self.admin_prefix.trim_end_matches('/') } fn admin_href(&self, rest: &str) -> String { let p = self.ap(); let rest = rest.trim().trim_start_matches('/'); if rest.is_empty() { p.to_string() } else { format!("{p}/{rest}") } } } fn collect_page_forms( page: &Value, forms: &mut HashMap, owners: &mut HashMap, ) { if let Some(obj) = page.get("forms").and_then(|v| v.as_object()) { for (k, v) in obj { forms.insert(k.clone(), v.clone()); owners.insert(k.clone(), page.clone()); } } if let (Some(id), Some(f)) = ( page.get("form_id").and_then(|v| v.as_str()), page.get("form"), ) { if !id.is_empty() { forms.insert(id.to_string(), f.clone()); owners.insert(id.to_string(), page.clone()); } } } pub fn listen( page: &Value, db_url: Option<&str>, host: &str, port: u16, admin: bool, admin_prefix: &str, login_path: &str, login_redirect: &str, logout_redirect: &str, mut forms: HashMap, routes: HashMap, static_dir: Option, static_mount: &str, auth_users: Option, session_ttl: u64, cookie_secure: bool, ws_routes: HashMap, rss_routes: HashMap, upload_routes: HashMap, download_routes: HashMap, redirects: HashMap, sitemap_routes: HashMap, robots_body: Option, page_404: Option, page_500: Option, gates: Vec, gallery_routes: HashMap, middleware: &Middleware, mut site_head: Vec, mut icon_routes: Vec, proxy_routes: Vec<(String, crate::proxy::ProxyRoute)>, invoke_routes: Vec<(String, crate::invoke::InvokeRoute)>, ) -> Result { let mut form_owners = HashMap::new(); collect_page_forms(page, &mut forms, &mut form_owners); for p in routes.values() { collect_page_forms(p, &mut forms, &mut form_owners); } session::configure(session::Config { db_url: db_url.map(|s| s.to_string()), ttl_sec: session_ttl, cookie_secure, }); session::reset(session_ttl); rate_limit::reset(); // Convention: static_dir/favicon.* → /favicon.ico when no explicit icons. if icon_routes.is_empty() { if let Some(dir) = static_dir.as_ref() { if let Some((head, routes)) = crate::assets::convention_favicon(dir) { site_head = head; icon_routes = routes; } } } // Resolve relative icon paths: try as-is absolute, else leave for entry_dir resolve in lib. // (Absolute paths preferred; relative already joined in web_listen.) let admin_prefix = { let mut p = admin_prefix.trim().to_string(); if !p.starts_with('/') { p = format!("/{p}"); } while p.len() > 1 && p.ends_with('/') { p.pop(); } p }; let state = Arc::new(AppState { page: page.clone(), db_url: db_url.map(|s| s.to_string()), admin, admin_prefix: admin_prefix.clone(), login_path: { let lp = login_path.trim(); if lp.is_empty() { format!("{}/login", admin_prefix.trim_end_matches('/')) } else { lp.to_string() } }, login_redirect: login_redirect.to_string(), logout_redirect: logout_redirect.to_string(), forms, form_owners, auth_users, session_ttl, cookie_secure, upload_routes: upload_routes.clone(), download_routes: download_routes.clone(), page_404: page_404.clone(), page_500: page_500.clone(), site_head: site_head.clone(), }); let mut app = Router::new() .route("/", get(home)) .route("/_part/{id}", get(home_part)) .route("/_form/{id}", get(form_get).post(form_post)); // Built-in admin only when enabled — otherwise `/admin…` is free for author routes. if admin { let admin_routes = Router::new() .route("/", get(admin_home)) .route("/login", get(admin_login_get).post(admin_login_post)) .route("/logout", get(admin_logout)) .route("/{table}", get(admin_table)) .route("/{table}/new", get(admin_new_get).post(admin_new_post)) .route( "/{table}/{id}/edit", get(admin_edit_get).post(admin_edit_post), ) .route("/{table}/{id}/delete", get(admin_delete)); app = app.nest(&admin_prefix, admin_routes); } // Register each author route as an exact GET path + `{path}/_part/{id}`. // Paths containing `{param}` become dynamic routes (e.g. `/post/{slug}`); // the captured params are injected into the page before rendering. let mut paths: Vec = routes.keys().cloned().collect(); paths.sort(); for path in paths { let page = routes.get(&path).cloned().unwrap_or_default(); let dynamic = path.contains('{'); if dynamic { let page_for_render = page.clone(); app = app.route( &path, get(async move |State(st): State>, headers: axum::http::HeaderMap, Path(params): Path>| { let mut p = page_for_render.clone(); inject_params(&mut p, ¶ms); let p = with_site_head(&p, &st.site_head); let (_, csrf, set_cookie) = resolve_session(&headers); let cookie = cookie_from_headers(&headers); let p = with_nav_auth(&p, cookie); let mut resp = Html(render::render_page(&p, st.db_url.as_deref(), Some(&csrf))).into_response(); append_set_cookie(&mut resp, set_cookie); resp }), ); // Dynamic `{path}/_part/{id}` with the same path params. let part_path = format!("{path}/_part/{{id}}"); let page_for_part = page.clone(); app = app.route( &part_path, get(async move |State(st): State>, Path((params, id)): Path<(HashMap, String)>| { let mut p = page_for_part.clone(); inject_params(&mut p, ¶ms); render_part_from_page(&p, &id, st.db_url.as_deref()) }), ); } else { let page_for_render = page.clone(); app = app.route( &path, get(async move |State(st): State>, headers: axum::http::HeaderMap| { let (_, csrf, set_cookie) = resolve_session(&headers); let p = with_site_head(&page_for_render, &st.site_head); let p = with_nav_auth(&p, cookie_from_headers(&headers)); let mut resp = Html(render::render_page(&p, st.db_url.as_deref(), Some(&csrf))) .into_response(); append_set_cookie(&mut resp, set_cookie); resp }), ); let part_path = format!("{path}/_part/{{id}}"); let page_for_part = page.clone(); app = app.route( &part_path, get(async move |State(st): State>, Path(id): Path| { render_part_from_page(&page_for_part, &id, st.db_url.as_deref()) }), ); } } // WebSocket endpoints (`ws://…/{path}`). let mut ws_paths: Vec = ws_routes.keys().cloned().collect(); ws_paths.sort(); for path in ws_paths { let mode = ws_routes .get(&path) .copied() .unwrap_or(crate::ws_hub::WsMode::Echo); let route_path = path.clone(); app = app.route( &path, axum::routing::get(move |ws: axum::extract::WebSocketUpgrade| { ws_upgrade(ws, mode, route_path.clone()) }), ); } let mut rss_paths: Vec = rss_routes.keys().cloned().collect(); rss_paths.sort(); for path in rss_paths { let cfg = rss_routes.get(&path).cloned().unwrap_or_default(); let route_path = path.clone(); app = app.route( &path, get(move |State(st): State>| { let cfg = cfg.clone(); let route_path = route_path.clone(); async move { rss_feed(&st, &route_path, &cfg) } }), ); } let mut upload_paths: Vec = upload_routes.keys().cloned().collect(); upload_paths.sort(); for path in upload_paths { let route_path = path.clone(); app = app.route( &path, post(move |State(st): State>, headers: axum::http::HeaderMap, multipart: Multipart| { let route_path = route_path.clone(); async move { upload_post(st, headers, route_path, multipart).await } }), ); } let mut download_paths: Vec = download_routes.keys().cloned().collect(); download_paths.sort(); for path in download_paths { let route_path = path.clone(); app = app.route( &path, get(move |State(st): State>, headers: axum::http::HeaderMap, Path(params): Path>| { let route_path = route_path.clone(); async move { download_get(st, &route_path, params, &headers) } }), ); } let mut gallery_paths: Vec = gallery_routes.keys().cloned().collect(); gallery_paths.sort(); for path in gallery_paths { let cfg = gallery_routes.get(&path).cloned().unwrap_or_default(); app = app.route( &path, get(move |State(st): State>| { let cfg = cfg.clone(); async move { gallery_page(&st, &cfg) } }), ); } let mount = normalize_static_mount(static_mount); if let Some(dir) = static_dir { if !dir.is_dir() { return Err(format!( "static dir `{}` is not a directory", dir.display() )); } eprintln!( "marqdo web static: {} → {}", mount, dir.display() ); let svc = ServeDir::new(dir); app = app.nest_service(&mount, svc); } // Root / custom icon file routes (favicon.ico, /icons/…). for ir in icon_routes { let url = ir.url.clone(); if !url.starts_with('/') { return Err(format!("icon url `{url}` must start with /")); } if !ir.path.is_file() { return Err(format!( "icon file `{}` not found for `{url}`", ir.path.display() )); } eprintln!( "marqdo web icon: {} → {} ({})", url, ir.path.display(), ir.content_type ); let path = ir.path.clone(); let ct = ir.content_type.clone(); app = app.route( &url, get(move || { let path = path.clone(); let ct = ct.clone(); async move { serve_icon_file(path, ct) } }), ); } let mut redir_paths: Vec = redirects.keys().cloned().collect(); redir_paths.sort(); for path in redir_paths { let (to, permanent) = redirects.get(&path).cloned().unwrap_or_default(); app = app.route( &path, get(move || { let to = to.clone(); let permanent = permanent; async move { // 301 for permanent (SEO), 307 for temporary — not axum's 308/307 defaults. let status = if permanent { StatusCode::MOVED_PERMANENTLY } else { StatusCode::TEMPORARY_REDIRECT }; match HeaderValue::from_str(&to) { Ok(loc) => (status, [(header::LOCATION, loc)]).into_response(), Err(_) => Redirect::to(&to).into_response(), } } }), ); } let mut sm_paths: Vec = sitemap_routes.keys().cloned().collect(); sm_paths.sort(); for path in sm_paths { let cfg = sitemap_routes.get(&path).cloned().unwrap_or_default(); app = app.route( &path, get(move |State(st): State>| { let cfg = cfg.clone(); async move { sitemap_response(&st, &cfg) } }), ); } if let Some(body) = robots_body { app = app.route( "/robots.txt", get(move || { let body = body.clone(); async move { ( [( header::CONTENT_TYPE, HeaderValue::from_static("text/plain; charset=utf-8"), )], body, ) .into_response() } }), ); } // Streaming proxy + HTTP→## invoke (before fallback so paths are explicit). app = crate::proxy::mount_all(app, &proxy_routes); app = crate::invoke::mount_all(app, &invoke_routes); app = app.fallback(get(fallback_404)); let app = crate::middleware::apply(app, middleware); let app = if !gates.is_empty() { let gates_for_mw = gates.clone(); let login_path_for_mw = state.login_path.clone(); app.layer(axum::middleware::from_fn( move |req: axum::http::Request, next: axum::middleware::Next| { let gates = gates_for_mw.clone(); let login_path = login_path_for_mw.clone(); async move { rbac_middleware(gates, login_path, req, next).await } }, )) } else { app }; let app = app.with_state(state); let addr: SocketAddr = format!("{host}:{port}") .parse() .map_err(|e| format!("bad listen addr {host}:{port}: {e}"))?; let rt = Runtime::new().map_err(|e| e.to_string())?; rt.block_on(async move { let listener = tokio::net::TcpListener::bind(addr) .await .map_err(|e| format!("bind {addr}: {e}"))?; eprintln!("marqdo web listening on http://{addr}"); axum::serve(listener, app) .await .map_err(|e| format!("serve: {e}")) })?; Ok(json!({ "ok": true })) } pub fn normalize_static_mount(raw: &str) -> String { let s = raw.trim(); if s.is_empty() { return "/static".into(); } let mut m = if s.starts_with('/') { s.to_string() } else { format!("/{s}") }; while m.len() > 1 && m.ends_with('/') { m.pop(); } m } fn rss_feed(st: &AppState, _path: &str, cfg: &Value) -> Response { let Some(url) = st.db_url.as_deref() else { return Html(String::from("

no database

")).into_response(); }; let table = cfg .get("table") .and_then(|v| v.as_str()) .unwrap_or("posts"); let limit = cfg .get("limit") .and_then(|v| v.as_i64()) .unwrap_or(20); let order = cfg.get("order").and_then(|v| v.as_str()); let title = cfg .get("title") .and_then(|v| v.as_str()) .unwrap_or("Feed"); let link = cfg.get("link").and_then(|v| v.as_str()).unwrap_or("/"); let description = cfg .get("description") .and_then(|v| v.as_str()) .unwrap_or(""); let rows = db::select_order(url, table, limit, None, order, None, None) .ok() .and_then(|v| v.get("rows").and_then(|r| r.as_array()).cloned()) .unwrap_or_default(); let xml = rss::build_rss(title, link, description, &rows); ( [(axum::http::header::CONTENT_TYPE, "application/rss+xml; charset=utf-8")], xml, ) .into_response() } async fn home(State(st): State>, headers: axum::http::HeaderMap) -> Response { let (_, csrf, set_cookie) = resolve_session(&headers); let page = with_site_head(&st.page, &st.site_head); let page = with_nav_auth(&page, cookie_from_headers(&headers)); let html = render::render_page(&page, st.db_url.as_deref(), Some(&csrf)); let mut resp = Html(html).into_response(); append_set_cookie(&mut resp, set_cookie); resp } /// Inject captured dynamic-route params into a page copy as `params` (a map), /// so render can resolve `{param}` placeholders in `query`/`intro`. fn inject_params(page: &mut Value, params: &HashMap) { if let Some(obj) = page.as_object_mut() { let mut map = Map::new(); for (k, v) in params { map.insert(k.clone(), json!(v)); } obj.insert("params".into(), Value::Object(map)); // Propagate into every part (fragments render independently). if let Some(parts) = obj.get_mut("parts").and_then(|p| p.as_object_mut()) { for cfg in parts.values_mut() { if let Some(m) = cfg.as_object_mut() { let mut pmap = Map::new(); for (k, v) in params { pmap.insert(k.clone(), json!(v)); } m.insert("params".into(), Value::Object(pmap)); } } } } } fn render_part_from_page(page: &Value, id: &str, db_url: Option<&str>) -> Response { let Some(parts) = page.get("parts").and_then(|v| v.as_object()) else { return Html(String::from("

no parts

")).into_response(); }; let Some(cfg) = parts.get(id) else { return Html(format!("

unknown part {id}

")).into_response(); }; Html(render::render_fragment(cfg, db_url)).into_response() } async fn home_part(State(st): State>, Path(id): Path) -> Response { render_part_from_page(&st.page, &id, st.db_url.as_deref()) } async fn form_get( State(st): State>, headers: axum::http::HeaderMap, Path(id): Path, ) -> Response { let Some(frm) = st.forms.get(&id) else { return Html(format!("

unknown form {id}

")).into_response(); }; let (_, csrf, set_cookie) = resolve_session(&headers); let mut resp = Html(form::render(frm, &id, None, None, Some(&csrf))).into_response(); append_set_cookie(&mut resp, set_cookie); resp } async fn form_post( State(st): State>, headers: axum::http::HeaderMap, Path(id): Path, Form(posted): Form>, ) -> Response { let Some(frm) = st.forms.get(&id) else { return Html(format!("

unknown form {id}

")).into_response(); }; let Some(url) = st.db_url.as_deref() else { return Html(String::from("

no database

")).into_response(); }; let (_, csrf, set_cookie, posted) = match validate_csrf_post(&headers, posted) { Ok(v) => v, Err(r) => return r, }; let mut resp = submit_and_respond(&st, frm, &id, url, posted, None, Some(&csrf)); append_set_cookie(&mut resp, set_cookie); resp } fn posted_to_value(posted: HashMap) -> Value { let mut data = Map::new(); for (k, v) in posted { data.insert(k, json!(v)); } Value::Object(data) } fn with_flash(redirect: &str, flash: &str) -> String { if redirect.contains('?') { format!("{redirect}&flash={flash}") } else { format!("{redirect}?flash={flash}") } } fn submit_and_respond( st: &AppState, frm: &Value, form_id: &str, url: &str, posted: HashMap, admin_table: Option<&str>, csrf: Option<&str>, ) -> Response { let data_v = posted_to_value(posted); match form::submit(frm, &data_v, url) { Ok(res) if res.get("ok").and_then(|v| v.as_bool()).unwrap_or(false) => { let mut redirect = res .get("redirect") .and_then(|v| v.as_str()) .unwrap_or("/") .to_string(); if form_id.contains("-new") { redirect = with_flash(&redirect, "created"); } else if form_id.contains("-edit") { redirect = with_flash(&redirect, "updated"); } Redirect::to(&redirect).into_response() } Ok(res) => { let errors = res.get("errors"); if let Some(table) = admin_table { Html(admin_form_page( st, table, if form_id.contains("-edit") { "Edit" } else { "New" }, frm, form_id, Some(&data_v), errors, csrf, )) .into_response() } else if let Some(page) = st.form_owners.get(form_id) { Html(render::render_page_ex( page, st.db_url.as_deref(), Some(&data_v), errors, csrf, )) .into_response() } else { Html(form::render(frm, form_id, Some(&data_v), errors, csrf)).into_response() } } Err(e) => Html(format!("

submit error: {}

", esc(&e))).into_response(), } } fn cookie_from_headers(headers: &axum::http::HeaderMap) -> Option<&str> { headers .get(axum::http::header::COOKIE) .and_then(|v| v.to_str().ok()) } fn client_ip(headers: &axum::http::HeaderMap) -> String { headers .get("x-forwarded-for") .and_then(|v| v.to_str().ok()) .and_then(|s| s.split(',').next()) .map(|s| s.trim().to_string()) .filter(|s| !s.is_empty()) .unwrap_or_else(|| "127.0.0.1".into()) } fn resolve_session(headers: &axum::http::HeaderMap) -> (String, String, Option) { let cookie = cookie_from_headers(headers); let (id, set_cookie) = session::ensure_from_cookie(cookie); let csrf = session::csrf_for(&id).unwrap_or_default(); (id, csrf, set_cookie) } fn append_set_cookie(resp: &mut Response, set_cookie: Option) { if let Some(c) = set_cookie { let _ = resp.headers_mut().try_append( axum::http::header::SET_COOKIE, c.parse().unwrap(), ); } } fn validate_csrf_post( headers: &axum::http::HeaderMap, posted: HashMap, ) -> Result<(String, String, Option, HashMap), Response> { let (sid, csrf, set_cookie) = resolve_session(headers); let token = posted.get("_csrf").map(|s| s.as_str()).unwrap_or(""); if !session::validate_csrf(&sid, token) { return Err(Html( "

Invalid or missing CSRF token. Refresh and try again.

" .to_string(), ) .into_response()); } let mut posted = posted; posted.remove("_csrf"); Ok((sid, csrf, set_cookie, posted)) } fn json_err(status: StatusCode, msg: &str) -> Response { let body = json!({ "ok": false, "error": msg }); (status, axum::Json(body)).into_response() } async fn upload_post( st: Arc, headers: axum::http::HeaderMap, route_path: String, mut multipart: Multipart, ) -> Response { let cfg = match st.upload_routes.get(&route_path) { Some(c) => c.clone(), None => return json_err(StatusCode::NOT_FOUND, "upload route not found"), }; let had_cookie = cookie_from_headers(&headers).is_some(); let (sid, _csrf, set_cookie) = resolve_session(&headers); let mut csrf_token = String::new(); let mut file_name = String::new(); let mut file_ct = String::from("application/octet-stream"); let mut file_bytes: Option> = None; loop { let field = match multipart.next_field().await { Ok(Some(f)) => f, Ok(None) => break, Err(e) => return json_err(StatusCode::BAD_REQUEST, &format!("multipart: {e}")), }; let name = field.name().unwrap_or("").to_string(); if name == "_csrf" { csrf_token = field.text().await.unwrap_or_default(); continue; } if name != cfg.field { // Drain unrelated fields. let _ = field.bytes().await; continue; } file_name = field .file_name() .map(|s| s.to_string()) .unwrap_or_default(); if let Some(ct) = field.content_type() { file_ct = ct.to_string(); } match field.bytes().await { Ok(b) => file_bytes = Some(b.to_vec()), Err(e) => return json_err(StatusCode::BAD_REQUEST, &format!("read file: {e}")), } } // Existing session cookie → require CSRF; brand-new anonymous upload → open. if had_cookie && !session::validate_csrf(&sid, &csrf_token) { return json_err(StatusCode::FORBIDDEN, "Invalid or missing CSRF token"); } let bytes = match file_bytes { Some(b) if !b.is_empty() => b, _ => return json_err(StatusCode::BAD_REQUEST, "missing file field"), }; let size = bytes.len() as u64; let check = match upload::validate( &file_name, &file_ct, size, cfg.max_bytes, cfg.types.as_ref(), ) { Ok(v) => v, Err(e) => return json_err(StatusCode::BAD_REQUEST, &e), }; if check.get("ok").and_then(|v| v.as_bool()) != Some(true) { let err = check .get("error") .and_then(|v| v.as_str()) .unwrap_or("validation failed"); return json_err(StatusCode::BAD_REQUEST, err); } let ct = check .get("content_type") .and_then(|v| v.as_str()) .unwrap_or(&file_ct); let key = match upload::make_key(&cfg.prefix, &file_name) { Ok(k) => k, Err(e) => return json_err(StatusCode::BAD_REQUEST, &e), }; let saved = match storage::put_bytes(&cfg.storage_url, &key, &bytes, ct) { Ok(v) => v, Err(e) => return json_err(StatusCode::INTERNAL_SERVER_ERROR, &e), }; let mut body = json!({ "ok": true, "key": key, "size": size, "content_type": ct, }); if let Some(obj) = body.as_object_mut() { if let Some(sz) = saved.get("size") { obj.insert("size".into(), sz.clone()); } } let mut resp = (StatusCode::OK, axum::Json(body)).into_response(); append_set_cookie(&mut resp, set_cookie); resp } fn download_get( st: Arc, route_path: &str, params: HashMap, headers: &axum::http::HeaderMap, ) -> Response { let cfg = match st.download_routes.get(route_path) { Some(c) => c.clone(), None => return json_err(StatusCode::NOT_FOUND, "download route not found"), }; let key = params .get("key") .or_else(|| params.values().next()) .map(|s| s.trim_start_matches('/').to_string()) .unwrap_or_default(); if key.is_empty() { return json_err(StatusCode::BAD_REQUEST, "missing key"); } let got = match storage::read_bytes(&cfg.storage_url, &key) { Ok(Some(v)) => v, Ok(None) => return json_err(StatusCode::NOT_FOUND, "not found"), Err(e) => return json_err(StatusCode::INTERNAL_SERVER_ERROR, &e), }; let (bytes, content_type, filename) = got; let etag = weak_etag(&bytes); if let Some(inm) = headers .get(header::IF_NONE_MATCH) .and_then(|v| v.to_str().ok()) { if inm .split(',') .any(|t| t.trim().eq_ignore_ascii_case(&etag)) { return StatusCode::NOT_MODIFIED.into_response(); } } let disp = if cfg.disposition.eq_ignore_ascii_case("inline") { "inline" } else { "attachment" }; let safe_name = filename.replace('"', "_"); ( StatusCode::OK, [ ( header::CONTENT_TYPE, HeaderValue::from_str(&content_type) .unwrap_or_else(|_| HeaderValue::from_static("application/octet-stream")), ), ( header::CONTENT_DISPOSITION, HeaderValue::from_str(&format!("{disp}; filename=\"{safe_name}\"")) .unwrap_or_else(|_| HeaderValue::from_static("attachment")), ), ( header::ETAG, HeaderValue::from_str(&etag).unwrap_or_else(|_| HeaderValue::from_static("W/\"0\"")), ), ], bytes, ) .into_response() } fn weak_etag(bytes: &[u8]) -> String { let mut h: u64 = 0xcbf2_9ce4_8422_2325; for b in bytes { h ^= u64::from(*b); h = h.wrapping_mul(0x0100_0000_01b3); } format!("W/\"{h:x}-{}\"", bytes.len()) } fn gate_matches(path: &str, gate: &Gate) -> bool { let pat = gate.path.trim_end_matches('*').trim_end_matches('/'); let pat = if pat.is_empty() { "/" } else { pat }; match gate.match_mode { GateMatch::Exact => path == pat || path == gate.path, GateMatch::Prefix => path == pat || path.starts_with(&format!("{pat}/")), } } fn path_excluded(path: &str, exclude: &[String], login_path: &str) -> bool { if path == login_path || path.starts_with(&format!("{login_path}?")) { return true; } for ex in exclude { let ex = ex.trim_end_matches('*').trim_end_matches('/'); if ex.is_empty() { continue; } if path == ex || path.starts_with(&format!("{ex}/")) { return true; } } false } async fn rbac_middleware( gates: Vec, login_path: String, req: axum::http::Request, next: axum::middleware::Next, ) -> Response { let path = req.uri().path().to_string(); let cookie = req .headers() .get(header::COOKIE) .and_then(|v| v.to_str().ok()) .map(|s| s.to_string()); for gate in &gates { if !gate_matches(&path, gate) { continue; } if path_excluded(&path, &gate.exclude, &login_path) { break; } let role = session::session_role(cookie.as_deref()); if !session::role_allowed(&role, &gate.roles) { if role == "visitor" && gate.on_deny == OnDeny::Redirect { let next_q = urlencoding_path(&path); let dest = if next_q.is_empty() || path == login_path { login_path.clone() } else { format!("{login_path}?next={next_q}") }; return Redirect::to(&dest).into_response(); } return ( StatusCode::FORBIDDEN, Html(format!( "

403 Forbidden

Role `{role}` cannot access `{path}`.

" )), ) .into_response(); } break; } next.run(req).await } fn urlencoding_path(path: &str) -> String { let mut out = String::new(); for b in path.bytes() { match b { b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' | b'/' => { out.push(b as char) } _ => out.push_str(&format!("%{b:02X}")), } } out } fn gallery_page(_st: &AppState, cfg: &Value) -> Response { let storage_url = cfg .get("storage") .and_then(|v| v.as_str()) .unwrap_or(""); let prefix = cfg .get("prefix") .and_then(|v| v.as_str()) .unwrap_or(""); let title = cfg .get("title") .and_then(|v| v.as_str()) .unwrap_or("Gallery"); let download_base = cfg .get("download_base") .and_then(|v| v.as_str()) .unwrap_or("/_media"); let listed = storage::list(storage_url, Some(prefix)).unwrap_or_else(|_| json!({ "keys": [] })); let keys = listed .get("keys") .and_then(|v| v.as_array()) .cloned() .unwrap_or_default(); let mut items = String::new(); for k in &keys { let key = k.as_str().unwrap_or(""); if key.is_empty() { continue; } let href = format!( "{}/{}", download_base.trim_end_matches('/'), key.trim_start_matches('/') ); let name = key.rsplit('/').next().unwrap_or(key); let lower = name.to_ascii_lowercase(); let is_img = lower.ends_with(".png") || lower.ends_with(".jpg") || lower.ends_with(".jpeg") || lower.ends_with(".gif") || lower.ends_with(".webp") || lower.ends_with(".svg"); if is_img { items.push_str(&format!( "
\"{n}\"/
{n}
", h = esc(&href), n = esc(name) )); } else { items.push_str(&format!( "
{n}
", h = esc(&href), n = esc(name) )); } } if items.is_empty() { items = "

No media yet.

".into(); } let html = format!( r#" {title}

{title}

{items}
"#, title = esc(title), items = items ); let etag = weak_etag(html.as_bytes()); ( StatusCode::OK, [ ( header::CONTENT_TYPE, HeaderValue::from_static("text/html; charset=utf-8"), ), ( header::ETAG, HeaderValue::from_str(&etag).unwrap_or_else(|_| HeaderValue::from_static("W/\"0\"")), ), ], html, ) .into_response() } fn admin_gate(st: &AppState, cookie_header: Option<&str>) -> Option { // When admin=false the built-in routes are not mounted; defense-in-depth only. if !st.admin { return Some((StatusCode::NOT_FOUND, "Not Found").into_response()); } if st.db_url.is_none() { return Some(Html(admin_shell(st, "Admin", None, "

No database bound to this app.

")).into_response()); } if st.auth_users.is_some() && !admin_authed(st, cookie_header) { return Some(Redirect::to(&st.login_path).into_response()); } None } /// True when a session with role `admin` is present (legacy users without role → admin). fn admin_authed(_st: &AppState, cookie_header: Option<&str>) -> bool { let Some(sid) = session::session_id_from_cookie(cookie_header) else { return false; }; if session::session_get(&sid, "username").is_none() { return false; } let role = session::session_role(cookie_header); session::role_allowed(&role, &["admin".into()]) } async fn admin_login_get(State(st): State>, headers: axum::http::HeaderMap) -> Response { if st.auth_users.is_none() { return Redirect::to(&st.login_redirect).into_response(); } if admin_authed(&st, cookie_from_headers(&headers)) { return Redirect::to(&st.login_redirect).into_response(); } let (_, csrf, set_cookie) = resolve_session(&headers); let mut resp = Html(login_page(&st, None, Some(&csrf))).into_response(); append_set_cookie(&mut resp, set_cookie); resp } async fn admin_login_post( State(st): State>, headers: axum::http::HeaderMap, Form(posted): Form>, ) -> Response { let Some(users) = &st.auth_users else { return Redirect::to(&st.login_redirect).into_response(); }; let (_, csrf, set_cookie, posted) = match validate_csrf_post(&headers, posted) { Ok(v) => v, Err(r) => return r, }; let username = posted.get("username").cloned().unwrap_or_default(); let password = posted.get("password").cloned().unwrap_or_default(); let ip = client_ip(&headers); if let Err(msg) = rate_limit::check(&ip, &username) { let mut resp = Html(login_page(&st, Some(&msg), Some(&csrf))).into_response(); append_set_cookie(&mut resp, set_cookie); return resp; } let Some((user, role)) = session::check_credentials(users, &username, &password) else { rate_limit::record_failure(&ip, &username); let mut resp = Html(login_page(&st, Some("Invalid username or password."), Some(&csrf))) .into_response(); append_set_cookie(&mut resp, set_cookie); return resp; }; rate_limit::clear_success(&ip, &username); let sid = session::session_new(Some(st.session_ttl)); session::session_set(&sid, "username", json!(user)); session::session_set(&sid, "role", json!(role)); let mut resp = Redirect::to(&st.login_redirect).into_response(); let _ = resp.headers_mut().try_append( axum::http::header::SET_COOKIE, session::session_cookie(&sid, st.session_ttl, st.cookie_secure) .parse() .unwrap(), ); append_set_cookie(&mut resp, set_cookie); resp } fn login_page(st: &AppState, error: Option<&str>, csrf: Option<&str>) -> String { let err = match error { Some(e) => format!("

{}

", esc(e)), None => String::new(), }; let csrf_field = csrf .filter(|s| !s.is_empty()) .map(|t| format!("", esc(t))) .unwrap_or_default(); format!( r#" Admin Login "#, err = err, csrf_field = csrf_field, login_action = esc(&st.login_path), ) } async fn admin_logout( State(st): State>, headers: axum::http::HeaderMap, ) -> Response { if let Some(sid) = session::session_id_from_cookie( headers .get(axum::http::header::COOKIE) .and_then(|v| v.to_str().ok()), ) { session::session_destroy(&sid); } let mut resp = Redirect::to(&st.logout_redirect).into_response(); if let Ok(h) = resp.headers_mut().try_append( axum::http::header::SET_COOKIE, "marqdo_sid=; HttpOnly; Path=/; Max-Age=0; SameSite=Lax" .parse() .unwrap(), ) { let _ = h; } resp } fn flash_html(flash: Option<&str>) -> String { match flash { Some("created") => "
Row created.
".into(), Some("updated") => "
Row updated.
".into(), Some("deleted") => "
Row deleted.
".into(), Some(other) if !other.is_empty() => { format!("
{}
", esc(other)) } _ => String::new(), } } fn admin_shell(st: &AppState, title: &str, active: Option<&str>, inner: &str) -> String { let tables = st .db_url .as_deref() .and_then(|u| db::list_tables(u).ok()) .unwrap_or_default(); let mut side = format!(""); format!( r#" {title} · Admin {side}
{inner}
"#, title = esc(title), side = side, inner = inner ) } fn admin_form_page( st: &AppState, table: &str, kind: &str, frm: &Value, form_id: &str, data: Option<&Value>, errors: Option<&Value>, csrf: Option<&str>, ) -> String { let mut body = format!( "

Admin / {t} / {kind}

{kind} {t}

", home = esc(st.ap()), table_href = esc(&st.admin_href(table)), t = esc(table), kind = esc(kind), ); body.push_str(&form::render_body(frm, form_id, data, errors, csrf)); admin_shell(st, &format!("{kind} {table}"), Some(table), &body) } #[derive(Deserialize)] struct FlashQuery { flash: Option, } async fn admin_home( State(st): State>, headers: axum::http::HeaderMap, Query(q): Query, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); let tables = db::list_tables(url).unwrap_or_default(); let mut inner = String::from("

Admin

SQLite tables for this site.

"); inner.push_str(&flash_html(q.flash.as_deref())); if tables.is_empty() { inner.push_str( "
No tablesInitialize a table via db.init / 数据库.初始化.
", ); } else { inner.push_str("
"); for t in &tables { inner.push_str(&format!( "", href = esc(&st.admin_href(t)), new_href = esc(&st.admin_href(&format!("{t}/new"))), t = esc(t) )); } inner.push_str("
Table
{t}New
"); } Html(admin_shell(&st, "Admin", None, &inner)).into_response() } async fn admin_table( State(st): State>, headers: axum::http::HeaderMap, Path(table): Path, Query(q): Query, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); let Ok(data) = db::select(url, &table, 200, None) else { return Html(admin_shell( &st, &table, Some(&table), &format!("

Cannot read table {}.

", esc(&table)), )) .into_response(); }; let rows = data .get("rows") .and_then(|v| v.as_array()) .cloned() .unwrap_or_default(); let mut cols: Vec = rows .first() .and_then(|r| r.as_object()) .map(|m| m.keys().cloned().collect()) .unwrap_or_default(); if cols.is_empty() { if let Ok(info) = db::table_info(url, &table) { cols = info.into_iter().map(|c| c.name).collect(); } } if let Some(i) = cols.iter().position(|c| c == "id") { let idc = cols.remove(i); cols.insert(0, idc); } let mut inner = format!( "

Admin / {t}

{t}

", home = esc(st.ap()), t = esc(&table) ); inner.push_str(&flash_html(q.flash.as_deref())); inner.push_str(&format!( "
New row{} row{}
", rows.len(), if rows.len() == 1 { "" } else { "s" }, new_href = esc(&st.admin_href(&format!("{table}/new"))), )); if rows.is_empty() { inner.push_str(&format!( "", esc(&table), new_href = esc(&st.admin_href(&format!("{table}/new"))), )); } else { inner.push_str("
"); for c in &cols { inner.push_str(&format!("", esc(c))); } inner.push_str(""); for row in &rows { let m = row.as_object().cloned().unwrap_or_else(Map::new); inner.push_str(""); for c in &cols { let cell = m .get(c) .map(|v| match v { Value::String(s) => s.clone(), Value::Null => String::new(), other => other.to_string(), }) .unwrap_or_default(); // Show full cell text; CSS wraps / table-wrap scrolls when needed. inner.push_str(&format!("", esc(&cell))); } let id = m .get("id") .map(|v| match v { Value::String(s) => s.clone(), other => other.to_string(), }) .unwrap_or_default(); if !id.is_empty() { inner.push_str(&format!( "", edit = esc(&st.admin_href(&format!("{table}/{id}/edit"))), del = esc(&st.admin_href(&format!("{table}/{id}/delete"))), id = esc(&id), )); } else { inner.push_str(""); } inner.push_str(""); } inner.push_str("
{}
{}Edit · Delete
"); } Html(admin_shell(&st, &table, Some(&table), &inner)).into_response() } async fn admin_new_get( State(st): State>, headers: axum::http::HeaderMap, Path(table): Path, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); let (_, csrf, set_cookie) = resolve_session(&headers); match form::from_schema(url, &table, "insert", None, st.ap()) { Ok(frm) => { let mut resp = Html(admin_form_page( &st, &table, "New", &frm, &format!("admin-{table}-new"), None, None, Some(&csrf), )) .into_response(); append_set_cookie(&mut resp, set_cookie); resp } Err(e) => Html(admin_shell( &st, &table, Some(&table), &format!("

{}

", esc(&e)), )) .into_response(), } } async fn admin_new_post( State(st): State>, headers: axum::http::HeaderMap, Path(table): Path, Form(posted): Form>, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); let (_, csrf, set_cookie, posted) = match validate_csrf_post(&headers, posted) { Ok(v) => v, Err(r) => return r, }; match form::from_schema(url, &table, "insert", None, st.ap()) { Ok(frm) => { let mut resp = submit_and_respond( &st, &frm, &format!("admin-{table}-new"), url, posted, Some(&table), Some(&csrf), ); append_set_cookie(&mut resp, set_cookie); resp } Err(e) => Html(admin_shell( &st, &table, Some(&table), &format!("

{}

", esc(&e)), )) .into_response(), } } async fn admin_edit_get( State(st): State>, headers: axum::http::HeaderMap, Path((table, id)): Path<(String, String)>, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); let row = match db::get(url, &table, &id, None) { Ok(Value::Null) => { return Html(admin_shell( &st, &table, Some(&table), &format!("

Row {id} not found.

"), )) .into_response(); } Ok(v) => v, Err(e) => { return Html(admin_shell( &st, &table, Some(&table), &format!("

{}

", esc(&e)), )) .into_response(); } }; let (_, csrf, set_cookie) = resolve_session(&headers); match form::from_schema(url, &table, "update", Some(&id), st.ap()) { Ok(frm) => { let mut resp = Html(admin_form_page( &st, &table, "Edit", &frm, &format!("admin-{table}-edit"), Some(&row), None, Some(&csrf), )) .into_response(); append_set_cookie(&mut resp, set_cookie); resp } Err(e) => Html(admin_shell( &st, &table, Some(&table), &format!("

{}

", esc(&e)), )) .into_response(), } } async fn admin_edit_post( State(st): State>, headers: axum::http::HeaderMap, Path((table, id)): Path<(String, String)>, Form(posted): Form>, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); let (_, csrf, set_cookie, posted) = match validate_csrf_post(&headers, posted) { Ok(v) => v, Err(r) => return r, }; match form::from_schema(url, &table, "update", Some(&id), st.ap()) { Ok(frm) => { let mut resp = submit_and_respond( &st, &frm, &format!("admin-{table}-edit"), url, posted, Some(&table), Some(&csrf), ); append_set_cookie(&mut resp, set_cookie); resp } Err(e) => Html(admin_shell( &st, &table, Some(&table), &format!("

{}

", esc(&e)), )) .into_response(), } } async fn admin_delete( State(st): State>, headers: axum::http::HeaderMap, Path((table, id)): Path<(String, String)>, ) -> Response { if let Some(r) = admin_gate(&st, cookie_from_headers(&headers)) { return r; } let url = st.db_url.as_deref().unwrap(); if let Err(e) = db::delete(url, &table, &id, None) { return Html(admin_shell( &st, &table, Some(&table), &format!("

Delete failed: {}

", esc(&e)), )) .into_response(); } Redirect::to(&with_flash(&st.admin_href(&table), "deleted")).into_response() } fn esc(s: &str) -> String { s.replace('&', "&") .replace('<', "<") .replace('>', ">") } fn sitemap_response(st: &AppState, cfg: &Value) -> Response { let base = cfg .get("base") .and_then(|v| v.as_str()) .unwrap_or(""); let table = cfg.get("table").and_then(|v| v.as_str()); let loc_col = cfg .get("loc") .and_then(|v| v.as_str()) .unwrap_or("path"); let limit = cfg .get("limit") .and_then(|v| v.as_i64()) .unwrap_or(1000); let mut items = cfg.get("items").cloned().unwrap_or(json!([])); if let (Some(url), Some(table)) = (st.db_url.as_deref(), table) { if let Ok(rows) = db::select_order(url, table, limit, None, None, None, None) { if let Some(arr) = rows.get("rows").cloned() { // Normalize loc column → loc if let Some(list) = arr.as_array() { let mut out = Vec::new(); for row in list { let mut m = row.as_object().cloned().unwrap_or_default(); if !m.contains_key("loc") { if let Some(v) = m.get(loc_col).cloned() { m.insert("loc".into(), v); } } out.push(Value::Object(m)); } items = Value::Array(out); } } } } let xml = sitemap::build_sitemap(base, &items); ( [( header::CONTENT_TYPE, HeaderValue::from_static("application/xml; charset=utf-8"), )], xml, ) .into_response() } async fn fallback_404(State(st): State>, headers: axum::http::HeaderMap) -> Response { let (_, csrf, set_cookie) = resolve_session(&headers); let html = if let Some(ref page) = st.page_404 { let page = with_site_head(page, &st.site_head); render::render_page(&page, st.db_url.as_deref(), Some(&csrf)) } else { "404

404 Not Found

" .to_string() }; let mut resp = (StatusCode::NOT_FOUND, Html(html)).into_response(); append_set_cookie(&mut resp, set_cookie); resp } /// Render a custom 500 page when configured. #[allow(dead_code)] fn error_500(st: &AppState, csrf: Option<&str>, msg: &str) -> Response { let html = if let Some(ref page) = st.page_500 { let page = with_site_head(page, &st.site_head); render::render_page(&page, st.db_url.as_deref(), csrf) } else { format!( "500

500

{}

", esc(msg) ) }; (StatusCode::INTERNAL_SERVER_ERROR, Html(html)).into_response() } /// WebSocket server endpoint. /// - `echo`: reply each text frame to the same socket /// - `broadcast`: fan-out text frames to all sockets on this path /// - `drain`: read and discard frames async fn ws_upgrade( ws: axum::extract::WebSocketUpgrade, mode: crate::ws_hub::WsMode, path: String, ) -> Response { ws.on_upgrade(move |socket| ws_socket_loop(socket, mode, path)) } async fn ws_socket_loop( mut socket: axum::extract::ws::WebSocket, mode: crate::ws_hub::WsMode, path: String, ) { use axum::extract::ws::Message; use futures_util::{SinkExt, StreamExt}; match mode { crate::ws_hub::WsMode::Echo => { while let Some(Ok(msg)) = socket.recv().await { match msg { Message::Text(text) => { if socket.send(Message::Text(text)).await.is_err() { break; } } Message::Close(_) => break, _ => {} } } } crate::ws_hub::WsMode::Drain => { while let Some(Ok(msg)) = socket.recv().await { if matches!(msg, Message::Close(_)) { break; } } } crate::ws_hub::WsMode::Broadcast => { let mut rx = crate::ws_hub::subscribe(&path); let (mut sink, mut stream) = socket.split(); loop { tokio::select! { incoming = stream.next() => { match incoming { Some(Ok(Message::Text(text))) => { crate::ws_hub::publish(&path, text.to_string()); } Some(Ok(Message::Close(_))) | None => break, Some(Ok(_)) => {} Some(Err(_)) => break, } } out = rx.recv() => { match out { Ok(text) => { if sink.send(Message::Text(text.into())).await.is_err() { break; } } Err(tokio::sync::broadcast::error::RecvError::Lagged(_)) => continue, Err(_) => break, } } } } } } } #[cfg(test)] mod gate_tests { use super::*; fn g(path: &str, mode: GateMatch) -> Gate { Gate { path: path.into(), roles: vec!["admin".into()], match_mode: mode, on_deny: OnDeny::Forbid, exclude: vec![], } } #[test] fn prefix_segment_boundary() { let gate = g("/admin", GateMatch::Prefix); assert!(gate_matches("/admin", &gate)); assert!(gate_matches("/admin/news", &gate)); assert!(!gate_matches("/admin-publish", &gate)); assert!(!gate_matches("/administrator", &gate)); } #[test] fn starred_json_becomes_prefix() { let gate = Gate::from_json(&json!({"path": "/admin*", "roles": ["admin"]})).unwrap(); assert_eq!(gate.match_mode, GateMatch::Prefix); assert!(gate_matches("/admin/x", &gate)); assert!(!gate_matches("/admin-publish", &gate)); } #[test] fn exclude_login() { assert!(path_excluded( "/desk/login", &["/desk/login".into()], "/desk/login" )); assert!(!path_excluded("/desk", &["/desk/login".into()], "/desk/login")); } }