himalaya 2.2.1

CLI to manage emails
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! # SMTP client
//!
//! The wrapper around io-smtp's blocking client every SMTP-specific
//! subcommand receives.
//!
//! Sending is stateless once authenticated, so unlike a storage backend
//! these commands need no account context: the merged [`Account`] comes
//! back for dispatch uniformity and is not threaded into them.

use std::{
    net::Ipv4Addr,
    ops::{Deref, DerefMut},
};

use anyhow::{Result, anyhow};
use io_sasl::mechanism::Sasl;
use io_smtp::{
    client::{SmtpClientStd as Inner, SmtpClientStdConnectOptions},
    rfc5321::SmtpEhloDomain,
    session::SmtpSessionOpenOptions,
};
use pimalaya_config::secret::SecretResolver;
use url::Url;

use crate::{
    account::context::Account,
    config::{AccountConfig, Config, ProxyConfig, SmtpConfig, parse_server},
};

/// SMTP client wrapping the inner stream for sending messages.
pub struct SmtpClient {
    inner: Inner,
}

impl SmtpClient {
    /// Opens the SMTP connection (TCP/TLS/STARTTLS, greeting, EHLO,
    /// SASL).
    pub fn new(config: SmtpConfig) -> Result<Self> {
        let tls = config.tls.into_tls(config.alpn);
        let domain: SmtpEhloDomain<'static> = Ipv4Addr::new(127, 0, 0, 1).into();
        let server = parse_smtp_server(&config.server)?;
        let mut resolver = SecretResolver::new();
        let sasl: Option<Sasl> = match config.sasl {
            // NOTE: a `unix://` sirup socket is already authenticated, so
            // no SASL is negotiated over it.
            Some(_) if server.scheme() == "unix" => None,
            Some(cfg) => {
                let host = server
                    .host_str()
                    .ok_or_else(|| anyhow!("Cannot derive host from SMTP server `{server}`"))?;
                // NOTE: url knows no smtp default port, so the fallback is
                // io-smtp's own connection default.
                let port = server
                    .port()
                    .unwrap_or(Inner::default_port(server.scheme()));
                Some(cfg.try_into_sasl(host, port, &mut resolver)?)
            }
            None => None,
        };
        let opts = SmtpClientStdConnectOptions {
            tls,
            proxy: ProxyConfig::resolve(config.proxy, &mut resolver)?,
            sasl,
            session: SmtpSessionOpenOptions {
                starttls: config.starttls,
            },
        };
        let (inner, _capabilities) = Inner::connect(&server, domain, opts)?;
        Ok(Self { inner })
    }
}

/// Parses an SMTP server string into a URL.
///
/// A full `smtp://` or `smtps://` URL, a bare authority or host taking
/// `smtps://`, or a `unix://` socket for a local proxy such as sirup. Any
/// other scheme is rejected.
pub fn parse_smtp_server(server: &str) -> Result<Url> {
    parse_server(server, "smtps", &["smtp", "smtps", "unix"])
}

impl Deref for SmtpClient {
    type Target = Inner;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl DerefMut for SmtpClient {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

/// Opens the SMTP session of an already-resolved account, returning it
/// beside the merged [`Account`].
///
/// Bails when the account declares no `[smtp]` block. The account rides
/// along for uniformity with the other builders, the SMTP subcommands
/// ignoring it.
pub fn build_smtp_client(
    config: Config,
    name: String,
    mut account_config: AccountConfig,
) -> Result<(Account, SmtpClient)> {
    let smtp_config = account_config
        .smtp
        .take()
        .ok_or_else(|| anyhow!("SMTP config is missing for account `{name}`"))?;
    let account = Account::from(config).merge(Account::from(account_config));
    let client = SmtpClient::new(smtp_config)?;
    Ok((account, client))
}