1use axum::extract::{Path, State};
16use axum::http::HeaderMap;
17use axum::response::{IntoResponse, Redirect, Response};
18use chrono::{DateTime, Utc};
19use rustango::core::Column as _;
20use rustango::core::Model as _;
21use rustango::extractors::Tenant;
22use rustango::sql::Auto;
23use rustango::sql::FetcherPool as _;
24use rustango::Model;
25use serde::{Deserialize, Serialize};
26
27use super::render::HONEYPOT_FIELD;
28use super::schema;
29
30#[derive(Model, Debug, Clone, Serialize, Deserialize)]
32#[rustango(table = "cms_form_entry", app = "cms")]
33pub struct FormEntry {
34 #[rustango(primary_key)]
35 pub id: Auto<i64>,
36 #[rustango(index)]
38 pub form_snippet_id: i64,
39 pub form_version: i64,
42 #[rustango(index)]
44 pub source_page_id: i64,
45 #[rustango(max_length = 512)]
46 pub source_url: String,
47 pub data_json: serde_json::Value,
49 #[rustango(max_length = 16)]
50 pub locale: String,
51 #[rustango(max_length = 64)]
52 pub ip: String,
53 #[rustango(auto_now_add)]
54 pub submitted_at: Auto<DateTime<Utc>>,
55}
56
57pub async fn ensure_table(pool: &rustango::sql::Pool) -> Result<(), rustango::sql::ExecError> {
62 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
63 pool.dialect(),
64 &FormEntry::SCHEMA,
65 );
66 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
67 rustango::sql::raw_execute_pool(pool, stmt, Vec::new()).await?;
68 }
69 Ok(())
70}
71
72pub const MAX_SUBMISSION_BYTES: usize = 10 * 1024 * 1024;
78
79pub(crate) async fn handle_form_submit(
80 State(state): State<crate::router::PublicState>,
81 tenant: Tenant,
82 headers: HeaderMap,
83 Path(form_id): Path<i64>,
84 req: axum::extract::Request,
85) -> Response {
86 use axum::extract::FromRequest as _;
87 let pool = tenant.pool();
88
89 let snippet = match crate::snippet::Snippet::objects()
91 .where_(crate::snippet::Snippet::id.eq(form_id))
92 .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
93 .first(pool)
94 .await
95 {
96 Ok(Some(s)) => s,
97 _ => return (axum::http::StatusCode::NOT_FOUND, "Unknown form.").into_response(),
98 };
99 let form = schema::parse(&snippet.data).unwrap_or_default();
100
101 let content_type = headers
107 .get(axum::http::header::CONTENT_TYPE)
108 .and_then(|v| v.to_str().ok())
109 .unwrap_or("")
110 .to_owned();
111 let mut pairs: Vec<(String, String)> = Vec::new();
112 let mut file_answers: std::collections::HashMap<String, String> =
113 std::collections::HashMap::new();
114 let mut pending_uploads: Vec<(String, axum::body::Bytes)> = Vec::new();
115 if content_type.starts_with("multipart/form-data") {
116 let Ok(mut mp) = axum::extract::Multipart::from_request(req, &()).await else {
117 return (axum::http::StatusCode::BAD_REQUEST, "Bad upload.").into_response();
118 };
119 loop {
123 let field = match mp.next_field().await {
124 Ok(Some(f)) => f,
125 Ok(None) => break,
126 Err(e) => return (e.status(), "Upload rejected.").into_response(),
127 };
128 let name = field.name().unwrap_or("").to_owned();
129 if name.is_empty() {
130 continue;
131 }
132 let fname = field
133 .file_name()
134 .map(str::to_owned)
135 .filter(|f| !f.is_empty());
136 if let Some(fname) = fname {
137 let bytes = match field.bytes().await {
138 Ok(b) => b,
139 Err(e) => return (e.status(), "Upload rejected.").into_response(),
140 };
141 if !bytes.is_empty() {
142 if let Some(key) = upload_key(&fname, &bytes) {
143 file_answers.insert(name, key.clone());
144 pending_uploads.push((key, bytes));
145 }
146 }
147 } else {
148 match field.text().await {
149 Ok(text) => pairs.push((name, text)),
150 Err(e) => return (e.status(), "Upload rejected.").into_response(),
151 }
152 }
153 }
154 } else {
155 let bytes = axum::body::to_bytes(req.into_body(), 2 * 1024 * 1024)
156 .await
157 .unwrap_or_default();
158 pairs = serde_urlencoded::from_bytes(&bytes).unwrap_or_default();
159 }
160
161 let hp_filled = pairs
163 .iter()
164 .any(|(k, v)| k == HONEYPOT_FIELD && !v.trim().is_empty());
165
166 let mut vals: std::collections::HashMap<String, Vec<String>> = std::collections::HashMap::new();
170 for (k, v) in &pairs {
171 if !k.starts_with('_') {
172 vals.entry(k.clone()).or_default().push(v.clone());
173 }
174 }
175
176 let mut answers = serde_json::Map::new();
180 let mut refused: Option<String> = None;
181 for field in form.fields() {
182 if !field.field_type.collects_value() || field.key.is_empty() {
183 continue;
184 }
185 let visible = schema::is_visible(field, &vals);
188 if matches!(field.field_type, schema::FieldType::File) {
191 match file_answers.get(&field.key) {
192 Some(key) => {
193 answers.insert(field.key.clone(), serde_json::Value::String(key.clone()));
194 }
195 None => {
196 if visible && field.required {
197 refused.get_or_insert_with(|| field.key.clone());
198 }
199 }
200 }
201 continue;
202 }
203 let values: Vec<&String> = pairs
204 .iter()
205 .filter(|(k, _)| k == &field.key)
206 .map(|(_, v)| v)
207 .filter(|v| !v.is_empty())
208 .collect();
209 if visible && field.required && values.is_empty() {
210 refused.get_or_insert_with(|| field.key.clone());
211 }
212 if visible && values.iter().any(|v| schema::validate_value(field, v).is_some()) {
215 refused.get_or_insert_with(|| field.key.clone());
216 }
217 if field.field_type.is_multi_value() {
218 answers.insert(
219 field.key.clone(),
220 serde_json::Value::Array(
221 values
222 .into_iter()
223 .map(|v| serde_json::Value::String(v.clone()))
224 .collect(),
225 ),
226 );
227 } else if let Some(v) = values.first() {
228 answers.insert(field.key.clone(), serde_json::Value::String((*v).clone()));
229 }
230 }
231
232 let referer = headers
234 .get(axum::http::header::REFERER)
235 .and_then(|v| v.to_str().ok())
236 .unwrap_or("")
237 .to_owned();
238 let source_path = referer_path(&referer);
239 let (path_only, query) = match source_path.split_once('?') {
242 Some((p, q)) => (p.to_owned(), Some(q.to_owned())),
243 None => (source_path.clone(), None),
244 };
245 let cookie_header = headers
246 .get(axum::http::header::COOKIE)
247 .and_then(|v| v.to_str().ok());
248 let request_locale = crate::locale_mode::resolve_request_locale(
249 pool,
250 state.locale_mode(),
251 &path_only,
252 query.as_deref(),
253 crate::locale_mode::locale_cookie_value(cookie_header).as_deref(),
254 None,
255 )
256 .await;
257 let site_prefix = crate::site::prefix_for_host(pool, crate::router::host_header(&headers))
258 .await
259 .unwrap_or_default();
260 let lookup_path = if path_only.is_empty() {
261 String::new()
262 } else {
263 crate::site::to_lookup_path(&site_prefix, &request_locale.stripped_path)
264 };
265 let source_page_id = if lookup_path.is_empty() {
266 0
267 } else {
268 crate::page::Page::objects()
269 .where_(crate::page::Page::url_path.eq(lookup_path.clone()))
270 .first(pool)
271 .await
272 .ok()
273 .flatten()
274 .and_then(|p| p.id.get().copied())
275 .unwrap_or(0)
276 };
277
278 let embed_id = pairs
281 .iter()
282 .find(|(k, _)| k == "_embed")
283 .map(|(_, v)| v.clone())
284 .unwrap_or_default();
285 let ovr_redirect = if source_page_id != 0 && !embed_id.is_empty() {
287 resolve_embed_redirect(pool, source_page_id, &embed_id).await
288 } else {
289 None
290 };
291
292 if hp_filled || refused.is_some() {
295 let back = if source_path.is_empty() {
296 "/".to_owned()
297 } else {
298 strip_form_flags(&source_path)
299 };
300 let sep = if back.contains('?') { '&' } else { '?' };
301 let flag = if hp_filled {
302 format!("form_submitted={form_id}")
303 } else {
304 format!("form_error={form_id}:{}", refused.unwrap_or_default())
305 };
306 return Redirect::to(&format!("{back}{sep}{flag}")).into_response();
307 }
308
309 let ip = headers
311 .get("x-forwarded-for")
312 .and_then(|v| v.to_str().ok())
313 .and_then(|s| s.split(',').next())
314 .unwrap_or("")
315 .trim()
316 .to_owned();
317 let form_version = crate::snippet::SnippetRevision::objects()
320 .where_(crate::snippet::SnippetRevision::snippet_id.eq(form_id))
321 .fetch(pool)
322 .await
323 .map(|v| v.len() as i64)
324 .unwrap_or(0);
325 let locale = request_locale.code.clone().unwrap_or_default();
328 let mut entry = FormEntry {
329 id: Auto::Unset,
330 form_snippet_id: form_id,
331 form_version,
332 source_page_id,
333 source_url: referer.chars().take(512).collect(),
334 data_json: serde_json::Value::Object(answers),
335 locale: locale.chars().take(16).collect(),
336 ip: ip.chars().take(64).collect(),
337 submitted_at: Auto::Unset,
338 };
339 let mut written: Vec<String> = Vec::new();
343 for (key, bytes) in &pending_uploads {
344 if write_upload(&tenant.org.slug, key, bytes).await {
345 written.push(key.clone());
346 }
347 }
348 if entry.insert_pool(pool).await.is_err() {
349 for key in &written {
350 remove_upload(&tenant.org.slug, key).await;
351 }
352 return (
353 axum::http::StatusCode::INTERNAL_SERVER_ERROR,
354 "Could not save your submission.",
355 )
356 .into_response();
357 }
358
359 {
369 let mut msg = crate::notify::Notification::new(
370 crate::notify::events::FORM_SUBMITTED,
371 format!("New form submission: {}", snippet.title),
372 )
373 .summary(format!("A visitor submitted \"{}\".", snippet.title));
374 if let serde_json::Value::Object(map) = &entry.data_json {
380 let mut seen = std::collections::HashSet::new();
381 let render = |v: &serde_json::Value| match v {
382 serde_json::Value::String(s) => s.clone(),
383 other => other.to_string(),
384 };
385 for f in form.fields() {
386 if let Some(v) = map.get(&f.key) {
387 seen.insert(f.key.clone());
388 let label = if f.label.trim().is_empty() {
389 f.key.clone()
390 } else {
391 f.label.clone()
392 };
393 msg = msg.field(label, render(v));
394 }
395 }
396 for (k, v) in map {
400 if !seen.contains(k) {
401 msg = msg.field(k.clone(), render(v));
402 }
403 }
404 }
405 if !entry.source_url.is_empty() {
406 msg = msg.url(entry.source_url.clone());
407 }
408 match crate::notify::worker::enqueue(pool, &msg, form_id).await {
412 Ok(0) => {}
413 Ok(_) => crate::notify::worker::spawn_drain(
414 pool.clone(),
415 tenant.org.slug.clone(),
416 state.mailer.clone(),
417 state.mailer_from.as_str().to_owned(),
418 ),
419 Err(e) => tracing::warn!(
420 target: "rustango_cms::forms",
421 error = %e, form_id, "could not queue submission notifications"
422 ),
423 }
424 }
425
426 if let Some(url) = ovr_redirect.filter(|u| is_safe_redirect(u)) {
428 return Redirect::to(&url).into_response();
429 }
430 if !form.settings.redirect_url.is_empty() && is_safe_redirect(&form.settings.redirect_url) {
431 return Redirect::to(&form.settings.redirect_url).into_response();
432 }
433 let back = if source_path_is_usable(&referer) {
434 strip_form_flags(&referer_path(&referer))
435 } else {
436 "/".to_owned()
437 };
438 let sep = if back.contains('?') { '&' } else { '?' };
439 Redirect::to(&format!("{back}{sep}form_submitted={form_id}")).into_response()
440}
441
442fn referer_path(referer: &str) -> String {
445 if referer.is_empty() {
446 return String::new();
447 }
448 if let Some(rest) = referer.splitn(2, "://").nth(1) {
449 match rest.find('/') {
451 Some(i) => rest[i..].to_owned(),
452 None => "/".to_owned(),
453 }
454 } else if referer.starts_with('/') {
455 referer.to_owned()
456 } else {
457 String::new()
458 }
459}
460
461fn strip_form_flags(path: &str) -> String {
464 let Some((base, query)) = path.split_once('?') else {
465 return path.to_owned();
466 };
467 let kept: Vec<&str> = query
468 .split('&')
469 .filter(|kv| {
470 let k = kv.split('=').next().unwrap_or("");
471 !kv.is_empty() && k != "form_submitted" && k != "form_error"
472 })
473 .collect();
474 if kept.is_empty() {
475 base.to_owned()
476 } else {
477 format!("{base}?{}", kept.join("&"))
478 }
479}
480
481fn source_path_is_usable(referer: &str) -> bool {
482 !referer_path(referer).is_empty()
483}
484
485fn is_safe_redirect(url: &str) -> bool {
487 rustango::auth_decorators::safe_next(url).is_some()
488}
489
490async fn resolve_embed_redirect(
495 pool: &rustango::sql::Pool,
496 page_id: i64,
497 embed_id: &str,
498) -> Option<String> {
499 let page = crate::page::Page::objects()
500 .where_(crate::page::Page::id.eq(page_id))
501 .first(pool)
502 .await
503 .ok()??;
504 let mut documents: Vec<serde_json::Value> = Vec::new();
505 let handler = crate::page_type_model::PageType::objects()
506 .where_(crate::page_type_model::PageType::id.eq(page.page_type_id))
507 .first(pool)
508 .await
509 .ok()
510 .flatten()
511 .and_then(|pt| crate::page_type::find_handler(&pt.type_name));
512 if let Some(handler) = handler {
513 if let Ok(extension) = handler.load_extension(pool, page_id).await {
514 documents.push(extension);
515 }
516 }
517 if let Ok(Some(builder)) = crate::page_builder::model::data_for_page(pool, page_id).await {
518 documents.push(builder.data);
519 }
520 documents
521 .iter()
522 .find_map(|doc| find_embed(doc, embed_id))
523 .and_then(|block| block.get("success_redirect_url").and_then(serde_json::Value::as_str))
524 .filter(|url| !url.is_empty())
525 .map(str::to_owned)
526}
527
528fn find_embed<'a>(value: &'a serde_json::Value, embed_id: &str) -> Option<&'a serde_json::Value> {
530 match value {
531 serde_json::Value::Object(obj) => {
532 if obj.get("id").and_then(serde_json::Value::as_str) == Some(embed_id)
533 && obj.get("type").and_then(serde_json::Value::as_str) == Some("form")
534 {
535 return obj.get("value");
536 }
537 obj.values().find_map(|v| find_embed(v, embed_id))
538 }
539 serde_json::Value::Array(items) => items.iter().find_map(|v| find_embed(v, embed_id)),
540 _ => None,
541 }
542}
543
544fn upload_key(filename: &str, bytes: &[u8]) -> Option<String> {
548 use sha2::{Digest, Sha256};
549 let safe = sanitize_upload_name(filename);
550 if safe.is_empty() {
551 return None;
552 }
553 let mut hasher = Sha256::new();
554 hasher.update(bytes);
555 let hex: String = hasher
556 .finalize()
557 .iter()
558 .take(8)
559 .fold(String::new(), |mut a, b| {
560 use std::fmt::Write as _;
561 let _ = write!(a, "{b:02x}");
562 a
563 });
564 Some(format!("{hex}-{safe}"))
565}
566
567fn upload_dir(slug: &str) -> std::path::PathBuf {
568 std::path::PathBuf::from("./var/form-uploads").join(sanitize_upload_name(slug))
569}
570
571async fn write_upload(slug: &str, key: &str, bytes: &[u8]) -> bool {
575 let dir = upload_dir(slug);
576 let written = async {
577 rustango::__private_runtime::tokio::fs::create_dir_all(&dir).await?;
578 rustango::__private_runtime::tokio::fs::write(dir.join(key), bytes).await
579 }
580 .await;
581 if let Err(e) = written {
582 tracing::warn!(target: "rustango_cms::forms", error = %e, "form upload not stored; the submission is saved without it");
583 return false;
584 }
585 true
586}
587
588async fn remove_upload(slug: &str, key: &str) {
590 let _ = rustango::__private_runtime::tokio::fs::remove_file(upload_dir(slug).join(key)).await;
591}
592
593fn sanitize_upload_name(name: &str) -> String {
597 let base = name.rsplit(['/', '\\']).next().unwrap_or(name);
598 let cleaned: String = base
599 .chars()
600 .map(|c| {
601 if c.is_ascii_alphanumeric() || c == '.' || c == '-' || c == '_' {
602 c
603 } else {
604 '_'
605 }
606 })
607 .take(100)
608 .collect();
609 cleaned.trim_matches('.').to_owned()
610}
611
612#[cfg(test)]
613mod tests {
614 use super::*;
615
616 #[test]
617 fn sanitize_upload_name_strips_paths() {
618 assert_eq!(sanitize_upload_name("../../etc/passwd"), "passwd");
619 assert_eq!(
620 sanitize_upload_name("my report (1).pdf"),
621 "my_report__1_.pdf"
622 );
623 assert_eq!(sanitize_upload_name("..\\..\\win.ini"), "win.ini");
624 }
625
626 #[test]
627 fn finds_the_embed_in_a_stream_or_builder_fields() {
628 let builder = serde_json::json!({
629 "price": 32.0,
630 "order": [{ "id": "b1", "type": "form", "value": { "form": "3", "success_redirect_url": "/thanks" } }]
631 });
632 assert_eq!(find_embed(&builder, "b1").and_then(|v| v["success_redirect_url"].as_str()), Some("/thanks"));
633 let nested = serde_json::json!({ "body": [{ "id": "x", "type": "section", "value": { "inner": [
634 { "id": "b2", "type": "form", "value": { "success_redirect_url": "/deep" } } ] } }] });
635 assert_eq!(find_embed(&nested, "b2").and_then(|v| v["success_redirect_url"].as_str()), Some("/deep"));
636 assert!(find_embed(&nested, "missing").is_none());
637 let other = serde_json::json!([{ "id": "b3", "type": "text", "value": {} }]);
639 assert!(find_embed(&other, "b3").is_none());
640 }
641
642 #[test]
643 fn earlier_result_flags_are_dropped() {
644 assert_eq!(strip_form_flags("/c?form_error=name"), "/c");
645 assert_eq!(strip_form_flags("/c?lang=fr&form_submitted=1"), "/c?lang=fr");
646 assert_eq!(strip_form_flags("/c?form_error=1&form_error=2&x=1"), "/c?x=1");
647 assert_eq!(strip_form_flags("/c"), "/c");
648 }
649
650 #[test]
651 fn referer_path_strips_host() {
652 assert_eq!(referer_path("https://x.test/a/b?c=1"), "/a/b?c=1");
653 assert_eq!(referer_path("http://x.test"), "/");
654 assert_eq!(referer_path("/already/path"), "/already/path");
655 assert_eq!(referer_path(""), "");
656 }
657
658 #[test]
659 fn safe_redirect_blocks_offsite() {
660 assert!(is_safe_redirect("/thanks"));
661 assert!(!is_safe_redirect("//evil.test"));
662 assert!(!is_safe_redirect("https://evil.test"));
663 assert!(!is_safe_redirect("/\\evil.test"));
665 assert!(!is_safe_redirect("/%5Cevil.test"));
666 assert!(!is_safe_redirect("/%2Fevil.test"));
667 }
668}
669