Skip to main content

qualia_client_core/
mail_inbound.rs

1//! Inbound mail acceptance — the path that makes domain mail **work**.
2//!
3//! Flow:
4//! 1. Envelope `RCPT TO` / inject target → [`crate::domains::resolve_delivery`]
5//! 2. Body + headers → [`crate::mail_rules::evaluate`]
6//! 3. If deliver → [`crate::mail_store::store_delivery`]
7//!
8//! Also runs a **local SMTP receiver** (default `127.0.0.1:2525`) so mail can land without a paid
9//! mailbox product. Public internet delivery still needs DNS MX + a tunnel/VPS to your host
10//! (port 25 is often blocked on residential links) — but the product inbox is yours, local, and
11//! rule-bearing.
12
13use 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
26/// Default bind for the personal SMTP edge (submission-style port; avoid privileged 25).
27pub 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/// Outcome of accepting one message (for API / UI).
39#[derive(Debug, Clone, Serialize, Deserialize)]
40pub struct AcceptResult {
41    pub accepted: bool,
42    pub rejected: Option<String>,
43    pub stored: Option<StoredMail>,
44}
45
46/// Accept a message for a registered domain mailbox — pure product path (no network).
47pub 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
116/// DNS records a human pastes so the **internet** can find this receiver.
117/// Host is optional public hostname (MX target); when empty, placeholders are used.
118pub 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
171/// Status of the local SMTP receiver.
172pub 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/// Start the local SMTP receiver on `bind` (e.g. `127.0.0.1:2525` or `0.0.0.0:2525`).
182/// Idempotent if already running on the same bind.
183#[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                        // One connection per thread — personal MTA volume is small.
219                        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"))]
247/// Stops the inbound receiver.
248pub fn stop_receiver() -> Result<serde_json::Value, String> {
249    SMTP_STOP.store(true, Ordering::Relaxed);
250    // Give the accept loop a moment to notice.
251    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
266/// Extract address from `MAIL FROM:<a@b>` / `RCPT TO:<a@b>` / bare forms.
267fn 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    // Blocking reads after accept — switch socket back to blocking for BufReader.
280    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                // End of data: line is ".\r\n" or "."
334                let trimmed = line.trim_end_matches(['\r', '\n']);
335                if trimmed == "." {
336                    break;
337                }
338                // RFC 5321 dot-stuffing: lines starting with ".." → strip one dot.
339                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            // Reset transaction
367            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
387/// Split RFC822-ish message into subject + body (body includes remaining headers stripped of Subject).
388fn 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            // Preserve original casing of value from `line`
400            subject = line[line.len() - rest.len()..].trim().to_string();
401            break;
402        }
403    }
404    // Prefer full original as body for reading; subject extracted for list UI.
405    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        // cleanup
489        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}