1use std::io::{BufRead, BufReader, Write};
14use std::net::{TcpListener, TcpStream};
15use std::sync::atomic::{AtomicBool, AtomicU16, Ordering};
16use std::sync::{Mutex, OnceLock};
17use std::thread;
18use std::time::Duration;
19
20use serde::{Deserialize, Serialize};
21
22use crate::domains::{self, DeliveryResolution, ResolutionVia};
23use crate::mail_rules::{self, InboundMessage};
24use crate::mail_store::{self, StoredMail};
25
26pub const DEFAULT_SMTP_BIND: &str = "127.0.0.1:2525";
28
29static SMTP_RUNNING: AtomicBool = AtomicBool::new(false);
30static SMTP_PORT: AtomicU16 = AtomicU16::new(0);
31static SMTP_STOP: AtomicBool = AtomicBool::new(false);
32static SMTP_BIND_DISPLAY: OnceLock<Mutex<String>> = OnceLock::new();
33
34fn bind_display() -> &'static Mutex<String> {
35 SMTP_BIND_DISPLAY.get_or_init(|| Mutex::new(String::new()))
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40pub struct AcceptResult {
41 pub accepted: bool,
42 pub rejected: Option<String>,
43 pub stored: Option<StoredMail>,
44}
45
46pub fn accept_message(
48 from: &str,
49 to: &str,
50 subject: &str,
51 body: &str,
52 sender_verified: bool,
53 sender_did: Option<String>,
54) -> AcceptResult {
55 let addresses = domains::list_addresses(None);
56 match domains::resolve_delivery(&addresses, to) {
57 DeliveryResolution::Reject { reason } => AcceptResult {
58 accepted: false,
59 rejected: Some(reason),
60 stored: None,
61 },
62 DeliveryResolution::Deliver { address, via } => {
63 let msg = InboundMessage {
64 from_address: from.to_string(),
65 to_address: to.to_string(),
66 sender_did,
67 sender_verified,
68 subject: subject.to_string(),
69 size_bytes: body.len(),
70 };
71 let mut verdict = mail_rules::evaluate(&address.rules, &msg);
72 let via_str = match via {
73 ResolutionVia::Exact => "exact",
74 ResolutionVia::Catchall => "catchall",
75 ResolutionVia::Unsolicited => "unsolicited",
76 };
77 if matches!(via, ResolutionVia::Catchall) && !verdict.quarantined {
78 verdict.quarantined = true;
79 verdict.reasons.push("catchall intake — quarantined".into());
80 }
81 if !verdict.deliver {
82 return AcceptResult {
83 accepted: false,
84 rejected: verdict
85 .rejected
86 .or_else(|| Some("rejected by rules".into())),
87 stored: None,
88 };
89 }
90 match mail_store::store_delivery(
91 from,
92 to,
93 &address.address,
94 subject,
95 body,
96 via_str,
97 verdict.quarantined,
98 verdict.priority,
99 verdict.reasons,
100 ) {
101 Ok(stored) => AcceptResult {
102 accepted: true,
103 rejected: None,
104 stored: Some(stored),
105 },
106 Err(e) => AcceptResult {
107 accepted: false,
108 rejected: Some(e),
109 stored: None,
110 },
111 }
112 }
113 }
114}
115
116pub fn mail_dns_forms(domain: &str, mx_host: Option<&str>) -> serde_json::Value {
119 let domain = domain.trim().to_lowercase();
120 let mx = mx_host
121 .map(|h| h.trim().to_lowercase())
122 .filter(|h| !h.is_empty())
123 .unwrap_or_else(|| format!("mail.{domain}"));
124 let port = SMTP_PORT.load(Ordering::Relaxed);
125 let port_note = if port == 0 {
126 DEFAULT_SMTP_BIND.to_string()
127 } else {
128 format!("listening on port {port}")
129 };
130 serde_json::json!({
131 "domain": domain,
132 "mx_host": mx,
133 "records": [
134 {
135 "type": "MX",
136 "name": "@",
137 "priority": 10,
138 "value": format!("{mx}."),
139 "hint": "Points senders at your mail host (tunnel, VPS, or home public hostname)."
140 },
141 {
142 "type": "A_or_AAAA",
143 "name": mx.strip_suffix(&format!(".{domain}")).unwrap_or("mail"),
144 "value": "<your public IP or tunnel target>",
145 "hint": "Where the MX name resolves. Cloudflare Tunnel can map hostname → this app."
146 },
147 {
148 "type": "TXT",
149 "name": "@",
150 "value": "v=spf1 mx a -all",
151 "hint": "SPF: only MX/A may send as this domain (tighten later with DKIM)."
152 },
153 ],
154 "local_receiver": {
155 "default_bind": DEFAULT_SMTP_BIND,
156 "status": if SMTP_RUNNING.load(Ordering::Relaxed) { "running" } else { "stopped" },
157 "bind": bind_display().lock().map(|g| g.clone()).unwrap_or_default(),
158 "port_note": port_note,
159 "how": "Start the local SMTP receiver in Talk → Mail. For public mail, forward TCP 25 (or 2525) to that port via tunnel/router. Same machine can use localhost:2525 without DNS."
160 },
161 "plaintext_block": format!(
162 "MX @ 10 {mx}.\n\
163 A/AAAA {mx} → <public IP or tunnel>\n\
164 TXT @ v=spf1 mx a -all\n\
165 # Local receiver: {port_note}\n\
166 # QDP front-door TXT is separate (_qdp) — identity, not MX."
167 ),
168 })
169}
170
171pub fn receiver_status() -> serde_json::Value {
173 serde_json::json!({
174 "running": SMTP_RUNNING.load(Ordering::Relaxed),
175 "port": SMTP_PORT.load(Ordering::Relaxed),
176 "bind": bind_display().lock().map(|g| g.clone()).unwrap_or_default(),
177 "default_bind": DEFAULT_SMTP_BIND,
178 })
179}
180
181#[cfg(not(target_arch = "wasm32"))]
184pub fn start_receiver(bind: &str) -> Result<serde_json::Value, String> {
185 let bind = if bind.trim().is_empty() {
186 DEFAULT_SMTP_BIND.to_string()
187 } else {
188 bind.trim().to_string()
189 };
190 if SMTP_RUNNING.load(Ordering::Relaxed) {
191 return Ok(serde_json::json!({
192 "already_running": true,
193 "bind": bind_display().lock().map(|g| g.clone()).unwrap_or_default(),
194 "port": SMTP_PORT.load(Ordering::Relaxed),
195 }));
196 }
197 let listener = TcpListener::bind(&bind)
198 .map_err(|e| format!("bind {bind} failed: {e} (is another process using the port?)"))?;
199 listener
200 .set_nonblocking(true)
201 .map_err(|e| format!("set_nonblocking: {e}"))?;
202 let port = listener.local_addr().map(|a| a.port()).unwrap_or(0);
203 SMTP_STOP.store(false, Ordering::Relaxed);
204 SMTP_PORT.store(port, Ordering::Relaxed);
205 if let Ok(mut g) = bind_display().lock() {
206 *g = bind.clone();
207 }
208 SMTP_RUNNING.store(true, Ordering::Relaxed);
209
210 thread::Builder::new()
211 .name("webizen-smtp".into())
212 .spawn(move || {
213 while !SMTP_STOP.load(Ordering::Relaxed) {
214 match listener.accept() {
215 Ok((stream, _peer)) => {
216 let _ = stream.set_read_timeout(Some(Duration::from_secs(60)));
217 let _ = stream.set_write_timeout(Some(Duration::from_secs(60)));
218 thread::spawn(move || {
220 if let Err(e) = handle_smtp_session(stream) {
221 log::debug!("smtp session end: {e}");
222 }
223 });
224 }
225 Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
226 thread::sleep(Duration::from_millis(50));
227 }
228 Err(_) => {
229 thread::sleep(Duration::from_millis(100));
230 }
231 }
232 }
233 SMTP_RUNNING.store(false, Ordering::Relaxed);
234 SMTP_PORT.store(0, Ordering::Relaxed);
235 })
236 .map_err(|e| format!("spawn smtp thread: {e}"))?;
237
238 Ok(serde_json::json!({
239 "started": true,
240 "bind": bind,
241 "port": port,
242 "message": format!("Local SMTP receiver on {bind} — point MX/tunnel here, or send to localhost for tests."),
243 }))
244}
245
246#[cfg(not(target_arch = "wasm32"))]
247pub fn stop_receiver() -> Result<serde_json::Value, String> {
249 SMTP_STOP.store(true, Ordering::Relaxed);
250 thread::sleep(Duration::from_millis(80));
252 Ok(serde_json::json!({
253 "stopped": true,
254 "running": SMTP_RUNNING.load(Ordering::Relaxed),
255 }))
256}
257
258#[cfg(not(target_arch = "wasm32"))]
259fn smtp_write(stream: &mut TcpStream, line: &str) -> Result<(), String> {
260 stream
261 .write_all(line.as_bytes())
262 .map_err(|e| e.to_string())?;
263 stream.flush().map_err(|e| e.to_string())
264}
265
266fn parse_smtp_path(arg: &str) -> String {
268 let s = arg.trim();
269 if let Some(start) = s.find('<') {
270 if let Some(end) = s[start + 1..].find('>') {
271 return s[start + 1..start + 1 + end].trim().to_string();
272 }
273 }
274 s.trim_matches(|c| c == '<' || c == '>').to_string()
275}
276
277#[cfg(not(target_arch = "wasm32"))]
278fn handle_smtp_session(mut stream: TcpStream) -> Result<(), String> {
279 stream.set_nonblocking(false).map_err(|e| e.to_string())?;
281 smtp_write(
282 &mut stream,
283 "220 webizen.local ESMTP Qualia semantic mail ready\r\n",
284 )?;
285
286 let mut reader = BufReader::new(stream.try_clone().map_err(|e| e.to_string())?);
287 let mut mail_from = String::new();
288 let mut rcpt_to: Vec<String> = Vec::new();
289 let mut line = String::new();
290
291 loop {
292 line.clear();
293 let n = reader.read_line(&mut line).map_err(|e| e.to_string())?;
294 if n == 0 {
295 break;
296 }
297 let cmd = line.trim_end_matches(['\r', '\n']);
298 let upper = cmd.to_ascii_uppercase();
299
300 if upper.starts_with("EHLO") || upper.starts_with("HELO") {
301 smtp_write(
302 &mut stream,
303 "250-webizen.local\r\n250-PIPELINING\r\n250 8BITMIME\r\n",
304 )?;
305 } else if upper.starts_with("MAIL FROM:") {
306 mail_from = parse_smtp_path(&cmd[10..]);
307 smtp_write(&mut stream, "250 OK\r\n")?;
308 } else if upper.starts_with("RCPT TO:") {
309 let to = parse_smtp_path(&cmd[8..]);
310 let addresses = domains::list_addresses(None);
311 match domains::resolve_delivery(&addresses, &to) {
312 DeliveryResolution::Deliver { .. } => {
313 rcpt_to.push(to);
314 smtp_write(&mut stream, "250 OK\r\n")?;
315 }
316 DeliveryResolution::Reject { reason } => {
317 smtp_write(&mut stream, &format!("550 5.1.1 {reason}\r\n"))?;
318 }
319 }
320 } else if upper == "DATA" {
321 if rcpt_to.is_empty() {
322 smtp_write(&mut stream, "503 5.5.1 No valid recipients\r\n")?;
323 continue;
324 }
325 smtp_write(&mut stream, "354 End data with <CR><LF>.<CR><LF>\r\n")?;
326 let mut data = String::new();
327 loop {
328 line.clear();
329 let n = reader.read_line(&mut line).map_err(|e| e.to_string())?;
330 if n == 0 {
331 break;
332 }
333 let trimmed = line.trim_end_matches(['\r', '\n']);
335 if trimmed == "." {
336 break;
337 }
338 if let Some(rest) = line.strip_prefix("..") {
340 data.push_str(rest);
341 } else {
342 data.push_str(&line);
343 }
344 }
345 let (subject, body) = split_headers_body(&data);
346 let from = if mail_from.is_empty() {
347 "unknown@invalid".to_string()
348 } else {
349 mail_from.clone()
350 };
351 let mut any_ok = false;
352 let mut last_err = String::new();
353 for to in &rcpt_to {
354 let r = accept_message(&from, to, &subject, &body, false, None);
355 if r.accepted {
356 any_ok = true;
357 } else if let Some(e) = r.rejected {
358 last_err = e;
359 }
360 }
361 if any_ok {
362 smtp_write(&mut stream, "250 OK queued\r\n")?;
363 } else {
364 smtp_write(&mut stream, &format!("550 5.7.1 rejected: {last_err}\r\n"))?;
365 }
366 mail_from.clear();
368 rcpt_to.clear();
369 } else if upper == "RSET" {
370 mail_from.clear();
371 rcpt_to.clear();
372 smtp_write(&mut stream, "250 OK\r\n")?;
373 } else if upper == "NOOP" {
374 smtp_write(&mut stream, "250 OK\r\n")?;
375 } else if upper == "QUIT" {
376 smtp_write(&mut stream, "221 webizen.local closing\r\n")?;
377 break;
378 } else if upper.starts_with("VRFY") || upper.starts_with("EXPN") {
379 smtp_write(&mut stream, "252 Not verified\r\n")?;
380 } else {
381 smtp_write(&mut stream, "502 5.5.2 Command not implemented\r\n")?;
382 }
383 }
384 Ok(())
385}
386
387fn split_headers_body(data: &str) -> (String, String) {
389 let normalized = data.replace("\r\n", "\n");
390 let (head, body) = if let Some(i) = normalized.find("\n\n") {
391 (&normalized[..i], normalized[i + 2..].to_string())
392 } else {
393 return (String::new(), normalized);
394 };
395 let mut subject = String::new();
396 for line in head.lines() {
397 let lower = line.to_ascii_lowercase();
398 if let Some(rest) = lower.strip_prefix("subject:") {
399 subject = line[line.len() - rest.len()..].trim().to_string();
401 break;
402 }
403 }
404 let full_body = if body.is_empty() {
406 data.to_string()
407 } else {
408 body
409 };
410 (subject, full_body)
411}
412
413#[cfg(test)]
414mod tests {
415 use super::*;
416 use crate::domains::{
417 make_domain, make_purpose_address, upsert_address, upsert_domain, AgentType, DomainOwner,
418 MailRules,
419 };
420
421 #[test]
422 fn parse_smtp_path_angles() {
423 assert_eq!(parse_smtp_path("<bob@alice.example>"), "bob@alice.example");
424 assert_eq!(parse_smtp_path(" bob@alice.example "), "bob@alice.example");
425 }
426
427 #[test]
428 fn split_subject_from_data() {
429 let (s, b) = split_headers_body("From: a@b\r\nSubject: Hello\r\n\r\nBody line\r\n");
430 assert_eq!(s, "Hello");
431 assert!(b.contains("Body line"));
432 }
433
434 #[test]
435 fn accept_message_fail_closed_without_mailbox() {
436 let r = accept_message(
437 "x@y.example",
438 "nobody@not-registered.invalid.example",
439 "hi",
440 "body",
441 false,
442 None,
443 );
444 assert!(!r.accepted);
445 assert!(r.rejected.is_some());
446 }
447
448 #[test]
449 fn accept_message_delivers_when_domain_onboarded() {
450 let domain = format!("inbound-test-{}.example", std::process::id());
451 let d = make_domain(
452 &domain,
453 AgentType::NaturalPerson,
454 DomainOwner::Personal {
455 did: "did:test".into(),
456 },
457 "did:test",
458 "T",
459 None,
460 1,
461 )
462 .unwrap();
463 upsert_domain(d).unwrap();
464 let a = make_purpose_address(
465 &domain,
466 "frontdoor",
467 MailRules {
468 notify: true,
469 ..Default::default()
470 },
471 1,
472 )
473 .unwrap();
474 upsert_address(a).unwrap();
475 let to = format!("frontdoor@{domain}");
476 let r = accept_message(
477 "peer@other.example",
478 &to,
479 "Ping",
480 "hello world",
481 false,
482 None,
483 );
484 assert!(r.accepted, "{:?}", r.rejected);
485 let stored = r.stored.expect("stored");
486 assert_eq!(stored.mailbox, to);
487 assert!(!stored.quarantined);
488 let _ = mail_store::delete(&stored.id);
490 }
491
492 #[test]
493 fn mail_dns_forms_include_mx_and_spf() {
494 let v = mail_dns_forms("alice.example", Some("mail.alice.example"));
495 let block = v["plaintext_block"].as_str().unwrap_or("");
496 assert!(block.contains("MX"));
497 assert!(block.contains("spf1"));
498 }
499}