use std::sync::Arc;
use std::time::Duration;
use axum::extract::State;
use axum::http::{StatusCode, Uri};
use axum::response::{IntoResponse, Redirect, Response};
use axum::routing::get;
use axum::Router;
use rustango::cache::BoxedCache;
use rustango::cache_page::CachePageLayer;
use rustango::extractors::Tenant;
use tera::Tera;
use crate::locale_mode::{resolve_request_locale, LocaleMode};
use crate::render::{render_negotiated, render_with_route};
use crate::resolver::{resolve_path, resolve_routable};
#[derive(Clone)]
pub(crate) struct PublicState {
pub(crate) tera: Arc<Tera>,
pub(crate) url_prefix: String,
locale_mode: LocaleMode,
pub(crate) mailer: Option<Arc<dyn rustango::email::Mailer>>,
pub(crate) mailer_from: Arc<String>,
pub(crate) fragment_cache: Option<(BoxedCache, Duration)>,
pub(crate) tenant_templates: Option<Arc<crate::tenant_templates::TenantTemplates>>,
}
impl PublicState {
fn new(tera: Arc<Tera>, url_prefix: String) -> Self {
Self {
tera,
url_prefix,
locale_mode: LocaleMode::default(),
mailer: None,
mailer_from: Arc::new(String::new()),
fragment_cache: None,
tenant_templates: None,
}
}
pub(crate) async fn tera_for(&self, slug: &str) -> Arc<Tera> {
let Some(tt) = self.tenant_templates.as_ref() else {
return Arc::clone(&self.tera);
};
if let Some(cached) = tt.cached(slug) {
return cached;
}
let (tt, owned) = (Arc::clone(tt), slug.to_owned());
rustango::__private_runtime::tokio::task::spawn_blocking(move || tt.for_tenant(&owned))
.await
.unwrap_or_else(|_| Arc::clone(&self.tera))
}
fn with_fragment_cache(mut self, cache: BoxedCache, ttl: Duration) -> Self {
self.fragment_cache = Some((cache, ttl));
self
}
fn with_locale_mode(mut self, mode: LocaleMode) -> Self {
self.locale_mode = mode;
self
}
pub(crate) fn locale_mode(&self) -> LocaleMode {
self.locale_mode
}
fn with_mailer(
mut self,
mailer: Arc<dyn rustango::email::Mailer>,
from: impl Into<String>,
) -> Self {
self.mailer = Some(mailer);
self.mailer_from = Arc::new(from.into());
self
}
}
fn apply_cache_layer(router: Router, cache: BoxedCache, ttl: Duration) -> Router {
router
.layer(
CachePageLayer::new(cache)
.timeout(ttl)
.key_prefix("rcms:page")
.vary_on(["accept-language", "x-rcms-locale", "x-rcms-accept"]),
)
.layer(axum::middleware::map_request(inject_locale_cookie_header))
.layer(axum::middleware::map_request(inject_accept_kind_header))
}
async fn inject_accept_kind_header(mut req: axum::extract::Request) -> axum::extract::Request {
let accept = crate::page_view::parse_accept(
req.headers()
.get(axum::http::header::ACCEPT)
.and_then(|v| v.to_str().ok()),
);
if accept == crate::page_view::Accept::Json {
req.headers_mut().insert(
axum::http::HeaderName::from_static("x-rcms-accept"),
axum::http::HeaderValue::from_static("json"),
);
}
req
}
async fn inject_locale_cookie_header(mut req: axum::extract::Request) -> axum::extract::Request {
let code = crate::locale_mode::locale_cookie_value(
req.headers()
.get(axum::http::header::COOKIE)
.and_then(|v| v.to_str().ok()),
);
if let Some(code) = code {
if let Ok(hv) = axum::http::HeaderValue::from_str(&code) {
req.headers_mut()
.insert(axum::http::HeaderName::from_static("x-rcms-locale"), hv);
}
}
req
}
pub struct PublicRouter {
tera: Arc<Tera>,
prefix: String,
cache: Option<(BoxedCache, Duration)>,
locale_mode: LocaleMode,
mailer: Option<(Arc<dyn rustango::email::Mailer>, String)>,
static_dirs: Vec<(String, std::path::PathBuf)>,
static_files: Vec<(String, &'static [u8], &'static str)>,
tenant_templates: Option<Arc<crate::tenant_templates::TenantTemplates>>,
}
impl PublicRouter {
#[must_use]
pub fn new(tera: Arc<Tera>) -> Self {
Self {
tera,
prefix: String::new(),
cache: None,
locale_mode: LocaleMode::default(),
mailer: None,
static_dirs: Vec::new(),
static_files: Vec::new(),
tenant_templates: None,
}
}
#[must_use]
pub fn static_dir(
mut self,
url_prefix: impl Into<String>,
fs_root: impl Into<std::path::PathBuf>,
) -> Self {
self.static_dirs.push((url_prefix.into(), fs_root.into()));
self
}
#[must_use]
pub fn static_file(
mut self,
url_path: impl Into<String>,
bytes: &'static [u8],
content_type: &'static str,
) -> Self {
self.static_files
.push((url_path.into(), bytes, content_type));
self
}
#[must_use]
pub fn with_form_mailer(
mut self,
mailer: Arc<dyn rustango::email::Mailer>,
from_addr: impl Into<String>,
) -> Self {
self.mailer = Some((mailer, from_addr.into()));
self
}
#[must_use]
pub fn at(mut self, prefix: impl Into<String>) -> Self {
self.prefix = prefix.into();
self
}
#[must_use]
pub fn cached(mut self, cache: BoxedCache, ttl: Duration) -> Self {
self.cache = Some((cache, ttl));
self
}
#[must_use]
pub fn locale_mode(mut self, mode: LocaleMode) -> Self {
self.locale_mode = mode;
self
}
#[must_use]
pub fn tenant_templates(mut self, tt: crate::tenant_templates::TenantTemplates) -> Self {
self.tenant_templates = Some(Arc::new(tt));
self
}
#[must_use]
pub fn tenant_templates_shared(
mut self,
tt: Arc<crate::tenant_templates::TenantTemplates>,
) -> Self {
self.tenant_templates = Some(tt);
self
}
#[must_use]
pub fn build(self) -> Router {
let mut state =
PublicState::new(self.tera, self.prefix.clone()).with_locale_mode(self.locale_mode);
state.tenant_templates = self.tenant_templates;
if let Some((mailer, from)) = self.mailer {
state = state.with_mailer(mailer, from);
}
if let Some((cache, ttl)) = &self.cache {
state = state.with_fragment_cache(cache.clone(), *ttl);
}
let cms_router = if self.prefix.is_empty() {
fallback_router(state)
} else {
explicit_router(&self.prefix, state)
};
let cms_router = if let Some((cache, ttl)) = self.cache {
apply_cache_layer(cms_router, cache, ttl)
} else {
cms_router
};
let mut router = Router::new();
for (url_prefix, fs_root) in self.static_dirs {
let trimmed = url_prefix.trim_end_matches('/').to_owned();
let pattern = format!("{trimmed}/{{*path}}");
let root = Arc::new(fs_root);
router = router.route(
&pattern,
axum::routing::get({
let root = root.clone();
move |path: axum::extract::Path<String>| {
let root = root.clone();
async move {
rustango::__private_runtime::tokio::task::spawn_blocking(move || {
serve_static_path(&root, &path.0)
})
.await
.unwrap_or_else(|_| not_found())
}
}
}),
);
}
for (url_path, bytes, ct) in self.static_files {
router = router.route(
&url_path,
axum::routing::get(move || async move { serve_static_bytes(bytes, ct) }),
);
}
router.merge(cms_router)
}
}
fn serve_static_path(fs_root: &std::path::Path, requested: &str) -> Response {
if requested.is_empty() || requested.contains('\0') {
return not_found();
}
for seg in requested.split('/') {
if seg == ".." || seg.starts_with('/') {
return not_found();
}
}
let candidate = fs_root.join(requested);
let canon_root = match fs_root.canonicalize() {
Ok(p) => p,
Err(_) => return not_found(),
};
let canon = match candidate.canonicalize() {
Ok(p) => p,
Err(_) => return not_found(),
};
if !canon.starts_with(&canon_root) {
return not_found();
}
let bytes = match std::fs::read(&canon) {
Ok(b) => b,
Err(_) => return not_found(),
};
let ct = mime_guess::from_path(&canon)
.first_or_octet_stream()
.essence_str()
.to_owned();
static_response(bytes, &ct)
}
fn serve_static_bytes(bytes: &'static [u8], content_type: &'static str) -> Response {
static_response(bytes.to_vec(), content_type)
}
fn static_response(bytes: Vec<u8>, content_type: &str) -> Response {
use axum::http::header;
(
axum::http::StatusCode::OK,
[
(
header::CONTENT_TYPE,
axum::http::HeaderValue::from_str(content_type).unwrap_or_else(|_| {
axum::http::HeaderValue::from_static("application/octet-stream")
}),
),
(
header::CACHE_CONTROL,
axum::http::HeaderValue::from_static("public, max-age=3600"),
),
],
bytes,
)
.into_response()
}
fn not_found() -> Response {
(axum::http::StatusCode::NOT_FOUND, "Not Found").into_response()
}
pub fn router(tera: Arc<Tera>) -> Router {
fallback_router(PublicState::new(tera, String::new()))
}
pub fn router_cached(tera: Arc<Tera>, cache: BoxedCache, ttl: Duration) -> Router {
apply_cache_layer(
fallback_router(PublicState::new(tera, String::new())),
cache,
ttl,
)
}
pub fn router_at(prefix: &str, tera: Arc<Tera>) -> Router {
explicit_router(prefix, PublicState::new(tera, prefix.to_owned()))
}
pub fn router_at_cached(prefix: &str, tera: Arc<Tera>, cache: BoxedCache, ttl: Duration) -> Router {
apply_cache_layer(
explicit_router(prefix, PublicState::new(tera, prefix.to_owned())),
cache,
ttl,
)
}
fn fallback_router(state: PublicState) -> Router {
crate::perf::instrument(fallback_router_inner(state))
}
fn fallback_router_inner(state: PublicState) -> Router {
Router::new()
.route("/sitemap.xml", get(crate::sitemap::handle_sitemap))
.route("/robots.txt", get(crate::robots::handle_robots))
.route("/sitemap/{n}", get(crate::sitemap::handle_sitemap_shard))
.route("/feed/{kind}/rss.xml", get(crate::feed::handle_feed_rss))
.route("/feed/{kind}/atom.xml", get(crate::feed::handle_feed_atom))
.route(
"/__cms-view-password",
get(handle_view_password_form).post(handle_view_password_submit),
)
.route(
"/forms/submit/{form_id}",
axum::routing::post(crate::forms::submit::handle_form_submit)
.layer(axum::extract::DefaultBodyLimit::max(crate::forms::submit::MAX_SUBMISSION_BYTES)),
)
.route("/forms/runtime.js", get(serve_form_runtime_js))
.route("/forms/forms.css", get(serve_form_css))
.route(
crate::analytics::COLLECT_PATH,
axum::routing::post(crate::analytics::collect::handle_collect),
)
.route(
crate::analytics::WS_PATH,
get(crate::analytics::ws::handle_ws),
)
.route(
crate::analytics::BEACON_JS_PATH,
get(crate::analytics::serve_beacon_js),
)
.fallback(get(handle_page_request))
.layer(axum::middleware::from_fn(crate::seed::lazy_seed_layer))
.with_state(state)
}
async fn serve_form_runtime_js() -> impl IntoResponse {
serve_static_bytes(include_str!("forms/runtime.js").as_bytes(), "text/javascript; charset=utf-8")
}
async fn serve_form_css() -> impl IntoResponse {
serve_static_bytes(include_str!("forms/forms.css").as_bytes(), "text/css; charset=utf-8")
}
fn explicit_router(prefix: &str, state: PublicState) -> Router {
let inner = Router::new()
.route("/sitemap.xml", get(crate::sitemap::handle_sitemap))
.route("/robots.txt", get(crate::robots::handle_robots))
.route("/sitemap/{n}", get(crate::sitemap::handle_sitemap_shard))
.route("/feed/{kind}/rss.xml", get(crate::feed::handle_feed_rss))
.route("/feed/{kind}/atom.xml", get(crate::feed::handle_feed_atom))
.route(
"/__cms-view-password",
get(handle_view_password_form).post(handle_view_password_submit),
)
.route(
"/forms/submit/{form_id}",
axum::routing::post(crate::forms::submit::handle_form_submit)
.layer(axum::extract::DefaultBodyLimit::max(crate::forms::submit::MAX_SUBMISSION_BYTES)),
)
.route("/forms/runtime.js", get(serve_form_runtime_js))
.route("/forms/forms.css", get(serve_form_css))
.route(
crate::analytics::COLLECT_PATH,
axum::routing::post(crate::analytics::collect::handle_collect),
)
.route(
crate::analytics::WS_PATH,
get(crate::analytics::ws::handle_ws),
)
.route(
crate::analytics::BEACON_JS_PATH,
get(crate::analytics::serve_beacon_js),
)
.route("/", get(handle_page_request))
.route("/{*path}", get(handle_page_request))
.layer(axum::middleware::from_fn(crate::seed::lazy_seed_layer))
.with_state(state);
if prefix.is_empty() {
return inner;
}
let trailing = format!("{prefix}/");
let bare = prefix.to_owned();
Router::new().nest(prefix, inner).route(
&trailing,
get(move || {
let bare = bare.clone();
async move { Redirect::permanent(&bare) }
}),
)
}
pub(crate) fn host_header(headers: &axum::http::HeaderMap) -> &str {
headers
.get(axum::http::header::HOST)
.and_then(|v| v.to_str().ok())
.map_or("", |h| h.split(':').next().unwrap_or(""))
}
fn hook_ctx<'a>(tenant: &'a Tenant, viewer: Option<&rustango::tenancy::auth::User>) -> crate::hooks::HookCtx<'a> {
crate::hooks::HookCtx::new(tenant.pool(), &tenant.org.slug, viewer.and_then(|u| u.id.get().copied()))
}
async fn handle_page_request(
tenant: Tenant,
State(state): State<PublicState>,
rustango::extractors::SessionUser(session_user): rustango::extractors::SessionUser,
rustango::tenancy::member_auth::CurrentMember(member): rustango::tenancy::member_auth::CurrentMember,
headers: axum::http::HeaderMap,
uri: Uri,
) -> Response {
let admin = if member.is_none() { session_user.as_ref() } else { None };
let inspect = admin.is_some_and(crate::template_inspector::wanted);
let bar = admin.map(|_| crate::admin_bar::Labels {
edit: crate::admin::tr(&headers, "Edit this page"),
admin: crate::admin::tr(&headers, "Admin"),
hide: crate::admin::tr(&headers, "Show or hide the admin bar"),
templates: crate::admin::tr(&headers, "Templates"),
});
crate::admin_bar::scope(
bar,
crate::template_inspector::scope(inspect, serve_page(tenant, state, session_user, member, headers, uri)),
)
.await
}
async fn serve_page(
tenant: Tenant,
state: PublicState,
session_user: Option<rustango::tenancy::auth::User>,
member: Option<rustango::tenancy::auth::User>,
headers: axum::http::HeaderMap,
uri: Uri,
) -> Response {
let viewer = member.as_ref().or(session_user.as_ref());
let raw_path = uri.path();
let _perf_t = crate::perf::start();
if let Some(resp) = crate::redirect::serve_override(
&tenant,
state.fragment_cache.as_ref().map(|(c, ttl)| (c, *ttl)),
raw_path,
uri.query(),
)
.await
{
crate::perf::mark("redirect_rules", _perf_t);
return resp;
}
crate::perf::mark("redirect_rules", _perf_t);
let accept_language = headers
.get(axum::http::header::ACCEPT_LANGUAGE)
.and_then(|v| v.to_str().ok());
let accept = crate::page_view::parse_accept(
headers
.get(axum::http::header::ACCEPT)
.and_then(|v| v.to_str().ok()),
);
let cookie_code = crate::locale_mode::locale_cookie_value(
headers
.get(axum::http::header::COOKIE)
.and_then(|v| v.to_str().ok()),
);
let _perf_t = crate::perf::start();
let request_locale = resolve_request_locale(
tenant.pool(),
state.locale_mode,
raw_path,
uri.query(),
cookie_code.as_deref(),
accept_language,
)
.await;
crate::perf::mark("locale", _perf_t);
let locale_code = request_locale.code.clone();
let locale_explicit = request_locale.explicit;
let lookup_path = request_locale.stripped_path;
let _perf_t = crate::perf::start();
let site_prefix = crate::site::prefix_for_host(tenant.pool(), host_header(&headers))
.await
.unwrap_or_default();
crate::perf::mark("site", _perf_t);
let lookup_path = crate::site::to_lookup_path(&site_prefix, &lookup_path);
let _perf_t = crate::perf::start();
let _resolved = resolve_path(&tenant, &lookup_path).await;
crate::perf::mark("resolve_path", _perf_t);
match _resolved {
Ok(Some(page)) => {
let _perf_t = crate::perf::start();
let _blocked =
crate::view_restriction_guard::enforce(&tenant, &page, viewer, &headers, raw_path)
.await;
crate::perf::mark("view_restriction", _perf_t);
if let Some(blocked) = _blocked {
return styled_denial(&tenant, &state, blocked, locale_code.as_deref()).await;
}
if let Some(resp) = crate::hooks::fire_before_serve_page(hook_ctx(&tenant, viewer), &page, &headers).await {
return resp;
}
let _perf_t = crate::perf::start();
let tera = state.tera_for(&tenant.org.slug).await;
let _switcher =
install_locale_switcher(&tenant, &state, &page, locale_code.as_deref()).await;
let _origin = crate::meta_tags::stash_site_origin(crate::sitemap::base_url(&headers));
let resp = render_negotiated(
&tenant,
&tera,
&page,
&state.url_prefix,
&site_prefix,
locale_code.as_deref(),
viewer,
accept,
state.fragment_cache.as_ref().map(|(c, ttl)| (c, *ttl)),
)
.await;
crate::perf::mark("render", _perf_t);
let resp = if resp.status().is_server_error() {
crate::error_pages::respond(&tenant, &state, resp.status(), locale_code.as_deref())
.await
} else {
resp
};
persist_locale(resp, locale_explicit, locale_code.as_deref())
}
Ok(None) => {
match resolve_routable(&tenant, &lookup_path).await {
Ok(Some((page, route_match))) => {
if let Some(blocked) = crate::view_restriction_guard::enforce(
&tenant, &page, viewer, &headers, raw_path,
)
.await
{
return styled_denial(&tenant, &state, blocked, locale_code.as_deref()).await;
}
if let Some(resp) = crate::hooks::fire_before_serve_page(hook_ctx(&tenant, viewer), &page, &headers).await {
return resp;
}
let tera = state.tera_for(&tenant.org.slug).await;
let _switcher =
install_locale_switcher(&tenant, &state, &page, locale_code.as_deref())
.await;
let _origin =
crate::meta_tags::stash_site_origin(crate::sitemap::base_url(&headers));
let resp = render_with_route(
&tenant,
&tera,
&page,
&state.url_prefix,
&site_prefix,
locale_code.as_deref(),
viewer,
&route_match,
accept,
state.fragment_cache.as_ref().map(|(c, ttl)| (c, *ttl)),
)
.await;
let resp = if resp.status().is_server_error() || resp.status() == StatusCode::NOT_FOUND {
crate::error_pages::respond(
&tenant,
&state,
resp.status(),
locale_code.as_deref(),
)
.await
} else {
resp
};
return persist_locale(resp, locale_explicit, locale_code.as_deref());
}
Ok(None) => {}
Err(e) => {
tracing::error!(path = %raw_path, error = %e, "resolve_routable failed");
}
}
fallthrough_to_redirect(
&tenant,
&state,
raw_path,
uri.query(),
locale_code.as_deref(),
)
.await
}
Err(e) => {
tracing::error!(path = %raw_path, error = %e, "resolve_path failed");
crate::error_pages::respond(
&tenant,
&state,
StatusCode::INTERNAL_SERVER_ERROR,
locale_code.as_deref(),
)
.await
}
}
}
fn persist_locale(mut resp: Response, explicit: bool, code: Option<&str>) -> Response {
use axum::http::header::{HeaderValue, SET_COOKIE, VARY};
resp.headers_mut()
.append(VARY, HeaderValue::from_static("Cookie"));
if explicit {
if let Some(code) = code {
let cookie = format!(
"{}={code}; Path=/; SameSite=Lax; HttpOnly; Max-Age=31536000",
crate::locale_mode::LOCALE_COOKIE
);
if let Ok(hv) = HeaderValue::from_str(&cookie) {
resp.headers_mut().append(SET_COOKIE, hv);
}
}
}
resp
}
async fn styled_denial(
tenant: &Tenant,
state: &PublicState,
blocked: Response,
locale_code: Option<&str>,
) -> Response {
if blocked.status() == StatusCode::FORBIDDEN {
crate::error_pages::respond(tenant, state, StatusCode::FORBIDDEN, locale_code).await
} else {
blocked
}
}
pub(crate) async fn install_locale_switcher(
tenant: &Tenant,
state: &PublicState,
page: &crate::page::Page,
current_code: Option<&str>,
) -> crate::language_switcher::PendingGuard {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let locales: Vec<crate::locale::Locale> = crate::locale::Locale::objects()
.where_(crate::locale::Locale::active.eq(true))
.order_by(&[("sort_order", false)])
.fetch(tenant.pool())
.await
.unwrap_or_default();
let entries = crate::language_switcher::build(
&locales,
&state.url_prefix,
&page.url_path,
state.locale_mode,
current_code,
);
crate::language_switcher::stash_pending(entries)
}
async fn fallthrough_to_redirect(
tenant: &Tenant,
state: &PublicState,
raw_path: &str,
query: Option<&str>,
locale_code: Option<&str>,
) -> Response {
match crate::redirect::find_for_path(tenant.pool(), raw_path).await {
Ok(Some(row)) => {
let to = crate::redirect::resolve_destination(tenant.pool(), &row).await;
let rule = rustango::redirects::RedirectRule {
to,
permanent: row.is_permanent,
};
let resp = rustango::redirects::build_redirect_response(&rule, query);
crate::redirect::record_hit(
tenant.pool(),
&tenant.org.slug,
row.id.get().copied().unwrap_or_default(),
);
resp
}
Ok(None) => {
let cache = state.fragment_cache.as_ref().map(|(c, ttl)| (c, *ttl));
if let Some(resp) =
crate::redirect::serve_wildcard(tenant, cache, raw_path, query).await
{
return resp;
}
if raw_path.trim_matches('/').is_empty() && crate::error_pages::site_is_empty(tenant.pool()).await {
return crate::error_pages::empty_site_response();
}
crate::error_pages::respond(tenant, state, StatusCode::NOT_FOUND, locale_code).await
}
Err(e) => {
tracing::warn!(path = %raw_path, error = %e, "redirect lookup failed");
crate::error_pages::respond(tenant, state, StatusCode::NOT_FOUND, locale_code).await
}
}
}
#[derive(Debug, serde::Deserialize)]
struct PasswordPromptQuery {
page: i64,
#[serde(default)]
next: Option<String>,
#[serde(default)]
error: Option<String>,
}
#[derive(Debug, serde::Deserialize)]
struct PasswordSubmitForm {
page: i64,
password: String,
#[serde(default)]
next: Option<String>,
}
async fn handle_view_password_form(
tenant: Tenant,
State(state): State<PublicState>,
headers: axum::http::HeaderMap,
axum::extract::Query(q): axum::extract::Query<PasswordPromptQuery>,
) -> Response {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let _ = &tenant;
let page_rows: Vec<crate::page::Page> = crate::page::Page::objects()
.where_(crate::page::Page::id.eq(q.page))
.fetch(tenant.pool())
.await
.unwrap_or_default();
let title = page_rows
.first()
.map(|p| p.title.clone())
.unwrap_or_else(|| "Protected page".to_owned());
let next = q.next.clone().unwrap_or_else(|| "/".to_owned());
let error_msg = q.error.as_deref().unwrap_or("");
let mut ctx = tera::Context::new();
ctx.insert("page_id", &q.page);
ctx.insert("page_title", &title);
ctx.insert("next_path", &next);
ctx.insert("error_message", &error_msg);
let (csrf_token, csrf_cookie) =
rustango::forms::csrf::ensure_token(&headers, rustango::forms::csrf::CSRF_COOKIE);
ctx.insert("csrf_token", &csrf_token);
match state.tera.render("rcms/view_password.html", &ctx) {
Ok(body) => {
let mut resp = axum::response::Html(body).into_response();
if let Some(v) = csrf_cookie.and_then(|c| axum::http::HeaderValue::from_str(&c).ok()) {
resp.headers_mut().append(axum::http::header::SET_COOKIE, v);
}
resp
}
Err(e) => {
tracing::error!(error = %e, "view-password template render failed");
(StatusCode::INTERNAL_SERVER_ERROR, "template error").into_response()
}
}
}
async fn handle_view_password_submit(
tenant: Tenant,
axum::extract::Form(form): axum::extract::Form<PasswordSubmitForm>,
) -> Response {
let Some(restriction) = crate::view_restriction::direct_for_page(tenant.pool(), form.page)
.await
.unwrap_or(None)
.filter(|r| r.kind == crate::view_restriction::RestrictionKind::Password.as_str())
else {
return (
StatusCode::BAD_REQUEST,
"no password restriction on this page",
)
.into_response();
};
let _ = &tenant;
let _ = &restriction.password_hash;
let ok =
crate::passwords::verify(&form.password, &restriction.password_hash).await.unwrap_or(false);
let next = form
.next
.as_deref()
.and_then(rustango::auth_decorators::safe_next)
.unwrap_or_else(|| "/".to_owned());
if !ok {
let next_enc = crate::view_restriction_guard::url_encode_path(&next);
return Redirect::to(&format!(
"/__cms-view-password?page={}&next={next_enc}&error=Wrong+password",
form.page
))
.into_response();
}
let cookie =
crate::view_restriction_guard::grant_cookie(&tenant.org.slug, &restriction, form.page);
let mut response = Redirect::to(&next).into_response();
if let Ok(hv) = axum::http::HeaderValue::from_str(&cookie) {
response
.headers_mut()
.append(axum::http::header::SET_COOKIE, hv);
}
response
}
#[cfg(test)]
mod static_serve_tests {
use super::*;
use std::fs;
use std::path::PathBuf;
fn tempdir(name: &str) -> PathBuf {
let mut p = std::env::temp_dir();
p.push(format!("rustango_cms_static_{name}_{}", std::process::id()));
let _ = fs::remove_dir_all(&p);
fs::create_dir_all(&p).expect("create tempdir");
p
}
#[test]
fn serves_existing_file_with_guessed_mime() {
let dir = tempdir("hit");
fs::write(dir.join("styles.css"), b"body{color:red}").unwrap();
let resp = serve_static_path(&dir, "styles.css");
assert_eq!(resp.status(), axum::http::StatusCode::OK);
let ct = resp
.headers()
.get(axum::http::header::CONTENT_TYPE)
.unwrap()
.to_str()
.unwrap();
assert!(ct.starts_with("text/css"), "got `{ct}`");
let cc = resp
.headers()
.get(axum::http::header::CACHE_CONTROL)
.unwrap()
.to_str()
.unwrap();
assert!(cc.contains("max-age=3600"));
}
#[test]
fn rejects_dotdot_traversal_in_segment() {
let dir = tempdir("trav");
fs::write(dir.join("ok.txt"), b"in-root").unwrap();
let resp = serve_static_path(&dir, "../etc/passwd");
assert_eq!(resp.status(), axum::http::StatusCode::NOT_FOUND);
}
#[test]
fn rejects_absolute_segment() {
let dir = tempdir("abs");
let resp = serve_static_path(&dir, "/etc/passwd");
assert_eq!(resp.status(), axum::http::StatusCode::NOT_FOUND);
}
#[test]
fn rejects_null_byte_in_path() {
let dir = tempdir("null");
let resp = serve_static_path(&dir, "ok\0.txt");
assert_eq!(resp.status(), axum::http::StatusCode::NOT_FOUND);
}
#[test]
fn missing_file_is_404_not_500() {
let dir = tempdir("miss");
let resp = serve_static_path(&dir, "does-not-exist.css");
assert_eq!(resp.status(), axum::http::StatusCode::NOT_FOUND);
}
#[test]
fn serves_static_bytes_with_supplied_content_type() {
let resp = serve_static_bytes(b"<svg/>", "image/svg+xml");
assert_eq!(resp.status(), axum::http::StatusCode::OK);
assert_eq!(
resp.headers()
.get(axum::http::header::CONTENT_TYPE)
.and_then(|v| v.to_str().ok()),
Some("image/svg+xml"),
);
}
#[test]
fn nested_subdir_is_served() {
let dir = tempdir("nested");
fs::create_dir_all(dir.join("css/sub")).unwrap();
fs::write(dir.join("css/sub/x.css"), b"x{}").unwrap();
let resp = serve_static_path(&dir, "css/sub/x.css");
assert_eq!(resp.status(), axum::http::StatusCode::OK);
}
#[test]
fn empty_path_is_404() {
let dir = tempdir("empty");
let resp = serve_static_path(&dir, "");
assert_eq!(resp.status(), axum::http::StatusCode::NOT_FOUND);
}
}
#[cfg(test)]
mod accept_cache_key_tests {
use super::*;
use axum::http::{HeaderValue, Request};
fn req_with_accept(accept: Option<&str>) -> axum::extract::Request {
let mut b = Request::builder().uri("/some-page");
if let Some(a) = accept {
b = b.header(
axum::http::header::ACCEPT,
HeaderValue::from_str(a).unwrap(),
);
}
b.body(axum::body::Body::empty()).unwrap()
}
async fn stamped(accept: Option<&str>) -> Option<String> {
let req = inject_accept_kind_header(req_with_accept(accept)).await;
req.headers()
.get("x-rcms-accept")
.and_then(|v| v.to_str().ok())
.map(str::to_owned)
}
#[tokio::test]
async fn only_an_explicit_json_preference_changes_the_cache_key() {
assert_eq!(
stamped(Some("application/json")).await.as_deref(),
Some("json")
);
assert_eq!(
stamped(Some("application/json, text/plain, */*"))
.await
.as_deref(),
Some("json")
);
let chrome = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,\
image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7";
assert_eq!(stamped(Some(chrome)).await, None);
assert_eq!(stamped(Some("*/*")).await, None);
assert_eq!(stamped(None).await, None);
assert_eq!(
stamped(Some("application/json;q=0.1, text/html")).await,
None
);
assert_eq!(stamped(Some("application/json;q=0")).await, None);
}
#[tokio::test]
async fn a_browser_and_a_json_client_do_not_share_a_key() {
let browser = stamped(Some("text/html,application/xhtml+xml,*/*;q=0.8")).await;
let json = stamped(Some("application/json")).await;
assert_ne!(
browser, json,
"browser and JSON callers must key differently or the page \
cache will serve one the other's representation"
);
}
}