ic-bn-lib 0.2.3

Internet Computer Boundary Nodes shared modules
Documentation 
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

use std::str::FromStr;

use fqdn::FQDN;
use tracing::{debug, info};

use crate::{
    http::dns::is_error_negative_lookup,
    network::AsyncReadWrite,
    smtp::{
        ProtocolError,
        inbound::{Session, SessionResult},
    },
};

impl<S: AsyncReadWrite> Session<S> {
    /// Handles EHLO/HELO commands
    pub async fn handle_ehlo(&mut self, host: &str, extended: bool) -> SessionResult<()> {
        // Validate hostname
        let Ok(ehlo_hostname) = FQDN::from_str(host) else {
            info!("{self}: {host}: Invalid EHLO hostname");
            self.set_error(ProtocolError::InvalidEhloHostname(format!(
                "{host}: incorrect hostname"
            )));
            return self.reply("550", "5.5.0", "Invalid EHLO hostname.").await;
        };

        // If EHLO hostname is already set to the same value - just reply directly,
        // avoid redundant checks
        if let Some(v) = &self.data.ehlo_hostname
            && v == &ehlo_hostname
        {
            return self.send_ehlo(extended).await;
        }

        if ehlo_hostname.depth() < 2 {
            info!("{self}: {host}: EHLO is not FQDN");
            self.set_error(ProtocolError::InvalidEhloHostname(format!(
                "{host}: not FQDN"
            )));
            return self
                .reply("550", "5.5.0", "EHLO hostname must be an FQDN.")
                .await;
        };

        // Check if EHLO hostname resolves if configured
        if self.cfg.verify_ehlo_hostname {
            match self.cfg.authenticator.resolver().lookup_ip(host).await {
                Ok(v) => match v.iter().next() {
                    Some(v) => {
                        debug!("{self}: {host}: EHLO hostname found in DNS: {v}");
                    }
                    None => {
                        info!("{self}: {host}: EHLO not found in DNS");
                        self.set_error(ProtocolError::InvalidEhloHostname(format!(
                            "{host}: not found in DNS"
                        )));
                        return self
                            .reply("550", "5.5.0", "EHLO hostname not found in DNS.")
                            .await;
                    }
                },

                Err(e) => {
                    info!("{self}: {host}: EHLO not found in DNS: {e:#}");

                    if is_error_negative_lookup(&e) {
                        self.set_error(ProtocolError::InvalidEhloHostname(format!(
                            "{host}: not found in DNS: {e:#}"
                        )));

                        return self
                            .reply("550", "5.5.0", "EHLO hostname not found in DNS.")
                            .await;
                    }

                    return self
                        .reply("451", "4.7.25", "Temporary error validating EHLO hostname.")
                        .await;
                }
            }
        }

        self.reset_message();
        self.data.ehlo_hostname = Some(ehlo_hostname);

        return self.send_ehlo(extended).await;
    }

    async fn send_ehlo(&mut self, extended: bool) -> SessionResult<()> {
        let buf = if !extended {
            &self.cfg.helo
        } else if self.tls_info.is_none() && self.cfg.tls_mode.enabled() {
            &self.cfg.ehlo_tls
        } else {
            &self.cfg.ehlo
        };

        self.write(&buf.clone()).await
    }
}