samotop 0.13.2

SMTP server and library built on async-std
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
101
102
103
104
105
106
107
108
109
110
111

//! Reference implementation of a mail guard
//! converting recipient addresses according to a regex map.

use crate::{
    common::*,
    mail::*,
    smtp::{SmtpParser, SmtpSession},
};
use log::*;
use regex::Regex;

/// A mail guard that converts recipient addresses according to a regex map.
#[derive(Clone, Debug, Default)]
pub struct Mapper {
    map: Vec<(Regex, String)>,
}

impl Mapper {
    pub fn new(map: Vec<(Regex, String)>) -> Self {
        Self { map }
    }
}

impl<T: AcceptsGuard> MailSetup<T> for Mapper {
    fn setup(self, config: &mut T) {
        config.add_last_guard(self)
    }
}

impl MailGuard for Mapper {
    fn add_recipient<'a, 's, 'f>(
        &'a self,
        _session: &'s mut SmtpSession,
        mut rcpt: Recipient,
    ) -> S2Fut<'f, AddRecipientResult>
    where
        'a: 'f,
        's: 'f,
    {
        let mut addr = rcpt.address.address();
        for conversion in self.map.iter() {
            addr = conversion
                .0
                .replace(addr.as_ref(), conversion.1.as_str())
                .into();
        }
        let addr = format!("<{}>", addr);

        match SmtpParser.forward_path(addr.as_bytes()) {
            Ok((i, new_path)) => {
                trace!("Converted {} into {}", rcpt.address, addr);
                assert_eq!(i, addr.len());
                rcpt.address = new_path;
                Box::pin(ready(AddRecipientResult::Inconclusive(rcpt)))
            }
            Err(e) => {
                let err = format!(
                    "Map conversions of {:?} produced invalid forward path {:?}. Error: {}",
                    rcpt.address.to_string(),
                    addr,
                    e
                );
                Box::pin(ready(AddRecipientResult::Failed(
                    AddRecipientFailure::FailedTemporarily,
                    err,
                )))
            }
        }
    }

    fn start_mail<'a, 's, 'f>(&'a self, _session: &'s mut SmtpSession) -> S2Fut<'f, StartMailResult>
    where
        'a: 'f,
        's: 'f,
    {
        Box::pin(ready(StartMailResult::Accepted))
    }
}

#[cfg(test)]
mod tests {
    use crate::smtp::SmtpHost;
    use crate::smtp::SmtpPath;
    use regex::Regex;

    use super::*;

    #[async_std::test]
    async fn test() -> Result<()> {
        // use the domain as a user, converting to linux like user name
        let sut = Mapper::new(vec![
            (Regex::new(".*@(.*)")?, "$1@localhost".to_owned()),
            (Regex::new("[^@a-zA-Z0-9]")?, "-".to_owned()),
        ]);
        let mut sess = SmtpSession::default();
        let rcpt = Recipient::new(SmtpPath::Mailbox {
            name: "user".to_owned(),
            host: SmtpHost::Domain("example.org".to_owned()),
            relays: vec![],
        });

        let res = sut.add_recipient(&mut sess, rcpt).await;
        match res {
            AddRecipientResult::Inconclusive(rcpt) => {
                assert_eq!(rcpt.address.address(), "example-org@localhost")
            }
            other => panic!("Unexpected {:?}", other),
        }
        Ok(())
    }
}