Coverage / crates/hub/src/mail.rs 88.7%

pub async fn load(db: &crate::db::Pool, from_config: &Email) -> Email {

    let mut mail = from_config.clone();

    if let Ok(Some(s)) = crate::db::accounts::setting(db, SETTING_SMTP).await {

    }

    mail

}

pub fn settings(app: &Shared) -> Email {

    app.mail.read().unwrap_or_else(|p| p.into_inner()).clone()

}

pub async fn save(app: &Shared, smtp: &str, from: &str) -> sqlx::Result<()> {

    crate::db::accounts::set_setting(&app.db, SETTING_SMTP, smtp).await?;

    crate::db::accounts::set_setting(&app.db, SETTING_FROM, from).await?;

    *app.mail.write().unwrap_or_else(|p| p.into_inner()) = Email { smtp: smtp.to_string(), from: from.to_string() };

    Ok(())

}

pub fn masked(smtp: &str) -> String {

    let Some((scheme, rest)) = smtp.split_once("://") else { return smtp.to_string() };

    let Some((userinfo, host)) = rest.rsplit_once('@') else { return smtp.to_string() };

    match userinfo.split_once(':') {

        Some((user, _)) => format!("{scheme}://{user}:***@{host}"),

}

pub fn enabled(app: &Shared) -> bool {

    let cfg = settings(app);

    !cfg.smtp.is_empty() && !cfg.from.is_empty()

}

pub async fn send_letter(

    app: &Shared,

    to_name: &str,

    to_addr: &str,

    subject: &str,

    body: &str,

    action: Option<Action<'_>>,

    unsubscribe: Option<&str>,

) -> Result<(), String> {

    if !enabled(app) {

    }

    let sent = deliver(app, to_name, to_addr, subject, body, action, unsubscribe).await;

    let counter = if sent.is_ok() { &crate::metrics::MAIL_SENT } else { &crate::metrics::MAIL_FAILED };

    counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);

    sent

}

async fn deliver(

    app: &Shared,

    to_name: &str,

    to_addr: &str,

    subject: &str,

    body: &str,

    action: Option<Action<'_>>,

    unsubscribe: Option<&str>,

) -> Result<(), String> {

    let cfg = settings(app);

    let site = sender_name(&cfg.from).unwrap_or_else(|| app.config.site.name.clone());

    let html = html(&site, app.config.base_url(), subject, body, action, unsubscribe);

    let subject = format!("[{site}] {subject}");

    let from = cfg.from.parse().map_err(|e| format!("[email] from: {e}"))?;

    let to = format!("{to_name} <{to_addr}>").parse().or_else(|_| to_addr.parse()).map_err(|e| format!("address {to_addr}: {e}"))?;

    let png = ContentType::parse("image/png").map_err(|e| e.to_string())?;

    let message = Message::builder()

        .from(from)

        .to(to)

        .subject(subject)

        .multipart(

            MultiPart::alternative().singlepart(SinglePart::plain(body.to_string())).multipart(

                MultiPart::related()

                    .singlepart(SinglePart::html(html))

                    .singlepart(Attachment::new_inline("logo".to_string()).body(LOGO.to_vec(), png)),

        .map_err(|e| e.to_string())?;

    if let Some(dir) = cfg.smtp.strip_prefix("file://") {

        let name = format!("{}-{}.eml", crate::db::now_ms(), crate::auth::random_hex(4));

        return tokio::fs::write(std::path::Path::new(dir).join(name), message.formatted())

            .await

            .map_err(|e| format!("write mail to {dir}: {e}"));

}

fn sender_name(from: &str) -> Option<String> {

    let (name, _) = from.split_once('<')?;

    let name = name.trim().trim_matches('"').trim();

    (!name.is_empty()).then(|| name.to_string())

}

fn esc(s: &str) -> String {

    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")

}

fn linked(text: &str) -> String {

    let re = regex::Regex::new(r"https?://[^\s<>]+[^\s<>.,;:!?)]").expect("a valid pattern");

    let mut out = String::new();

    let mut last = 0;

    for m in re.find_iter(text) {

    out.push_str(&esc(&text[last..]));

    out.replace('\n', "<br>")

}

pub fn html(site: &str, base: &str, subject: &str, body: &str, action: Option<Action<'_>>, unsubscribe: Option<&str>) -> String {

    let base = base.trim_end_matches('/');

    let host = base.split("://").nth(1).unwrap_or(base);

    let button = action

        .map(|a| {

            let (label, url) = (esc(a.label), esc(a.url));

            format!(

        })

        .unwrap_or_default();

    let mut placed = false;

    let mut paras = String::new();

    for p in body.split("\n\n").map(str::trim).filter(|p| !p.is_empty()) {

        if action.is_some_and(|a| p == a.url) {

            if !placed {

                paras.push_str(&button);

                placed = true;

            }

            continue;

        }

        if unsubscribe.is_some_and(|u| p.contains(u)) {

        }

        paras.push_str(&format!(

            r#"<p style="margin:0 0 16px;font-size:15px;line-height:1.6;color:#1f2328;" class="ox-text">{}</p>"#,

            linked(p)

        ));

    let button = if placed { String::new() } else { button };

    let stop =

        unsubscribe.map(|u| format!(r#" &middot; <a href="{}" style="color:#6e7781;">Stop these emails</a>"#, esc(u))).unwrap_or_default();

    let (site_e, subject_e, host_e) = (esc(site), esc(subject), esc(host));

    format!(

}

    fn a_message_is_a_card_with_its_button_and_the_site_s_links() {

        let body =

            "Confirm that [email protected] is yours:\n\nhttps://hub.example/verify/abc\n\nThe link works for 48 hours. <b>Not</b> HTML.";

        let h = html(

            "OxygenHub",

            "https://hub.example/",

            "Confirm your email address",

            body,

            Some(Action { label: "Confirm my email address", url: "https://hub.example/verify/abc" }),

            Some("https://hub.example/settings/notifications?unsubscribe=k"),

        assert!(h.contains(r#"<img src="cid:logo""#), "the mark, inline");

        assert!(h.contains(">Confirm my email address</a>") && h.contains(r#"href="https://hub.example/verify/abc""#));

        assert_eq!(

            h.matches("https://hub.example/verify/abc</a>").count(),

        assert!(h.contains("<b>Not</b> HTML."), "the body is escaped");

        assert!(h.contains(r#"href="https://hub.example/explore""#) && h.contains("Stop these emails"));

        assert!(h.contains("at hub.example,"));

    }

pub fn secured(url: &str) -> String {

    let Some(rest) = url.strip_prefix("smtp://") else { return url.to_string() };

    if url.contains("tls=") {

        return url.to_string();

    }

    let host = rest.rsplit('@').next().unwrap_or(rest);

    let host = host.split(['/', '?']).next().unwrap_or(host);

    let host = host.rsplit_once(':').map_or(host, |(h, _)| h).trim_matches(['[', ']']);

    if matches!(host, "localhost" | "127.0.0.1" | "::1") {

        return url.to_string();

    }

    format!("{url}{}tls=required", if url.contains('?') { "&" } else { "?" })

}

    fn smtp_urls_require_starttls_unless_they_say_otherwise() {

        assert_eq!(secured("smtp://resend:[email protected]:587"), "smtp://resend:[email protected]:587?tls=required");

        assert_eq!(secured("smtps://resend:[email protected]:465"), "smtps://resend:[email protected]:465");

        assert_eq!(secured("smtp://relay.example:25?tls=opportunistic"), "smtp://relay.example:25?tls=opportunistic");

        assert_eq!(secured("smtp://localhost:25"), "smtp://localhost:25", "a relay on this machine");

        assert_eq!(secured("smtp://u:[email protected]:1025"), "smtp://u:[email protected]:1025");

        assert_eq!(secured("file:///tmp/mail"), "file:///tmp/mail");

    }

fn enc(s: &str) -> String {

    s.bytes()

        .map(|b| match b {

            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => (b as char).to_string(),

            _ => format!("%{b:02X}"),

        })

        .collect()

}

fn dec(s: &str) -> String {

    let b = s.as_bytes();

    let mut out = Vec::new();

    let mut i = 0;

    while i < b.len() {

        if b[i] == b'%' && i + 2 < b.len() {

            if let Ok(v) = u8::from_str_radix(&s[i + 1..i + 3], 16) {

                out.push(v);

                i += 3;

                continue;

        }

        out.push(b[i]);

        i += 1;

    String::from_utf8_lossy(&out).into_owned()

}

fn parts(url: &str) -> Option<(&str, &str, &str, &str, &str, &str)> {

    let (scheme, rest) = url.split_once("://")?;

    let (rest, query) = rest.split_once('?').unwrap_or((rest, ""));

    let (userinfo, hostport) = rest.rsplit_once('@').unwrap_or(("", rest));

    let (user, pass) = userinfo.split_once(':').unwrap_or((userinfo, ""));

    let hostport = hostport.trim_end_matches('/');

    let (host, port) = hostport.rsplit_once(':').unwrap_or((hostport, ""));

    Some((scheme, user, pass, host, port, query))

}

pub fn describe(url: &str) -> Choice {

    if url.is_empty() {

        return Choice { service: "off".into(), ..Default::default() };

    }

    let Some((scheme, user, pass, host, port, query)) = parts(url).filter(|p| p.0 == "smtp" || p.0 == "smtps") else {

        return Choice { service: "url".into(), ..Default::default() };

    let mut c = Choice {

        user: dec(user),

        host: host.to_string(),

        port: port.to_string(),

        has_secret: !pass.is_empty(),

        security: if scheme == "smtps" {

            "tls".into()

        } else if query.contains("tls=none") {

            "starttls".into()

        ..Default::default()

    c.service = if host == "smtp.resend.com" {

        "resend".into()

    } else if let Some(region) = host.strip_prefix("email-smtp.").and_then(|h| h.strip_suffix(".amazonaws.com")) {

        c.region = region.to_string();

        "ses".into()

    } else if host == "smtp.mailgun.org" || host == "smtp.eu.mailgun.org" {

        c.region = if host.contains(".eu.") { "eu".into() } else { "us".into() };

        "mailgun".into()

    } else if query.contains("tls=opportunistic") {

        "smtp".into()

    c

}

pub fn compose(a: &Asked, current: &str) -> Result<String, String> {

    let region = a.region.trim();

    let (scheme, user, host, port, query): (&str, String, String, String, &str) = match a.service.as_str() {

        "resend" => ("smtps", "resend".into(), "smtp.resend.com".into(), "465".into(), ""),

        "ses" => {

            if region.is_empty() || !region.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') {

            }

            if a.user.trim().is_empty() {

            }

            ("smtps", a.user.trim().to_string(), format!("email-smtp.{region}.amazonaws.com"), "465".into(), "")

        "mailgun" => {

            let host = match region {

                "eu" => "smtp.eu.mailgun.org",

            if a.user.trim().is_empty() {