117 lines
2.9 KiB
Rust
117 lines
2.9 KiB
Rust
use std::{
|
|
error::Error,
|
|
fs::{read_dir, DirEntry},
|
|
net::TcpStream,
|
|
path::PathBuf,
|
|
vec::IntoIter, collections::HashMap,
|
|
};
|
|
|
|
use imap::Session;
|
|
use rustls_connector::RustlsConnector;
|
|
|
|
pub trait EmailReader {
|
|
fn read_rfc822_messages(&mut self) -> Box<IntoIter<(String, Vec<u8>)>>;
|
|
}
|
|
|
|
pub(crate) struct TestMessagesReader {
|
|
path: PathBuf,
|
|
}
|
|
|
|
impl TestMessagesReader {
|
|
pub fn new(path: PathBuf) -> Self {
|
|
TestMessagesReader { path }
|
|
}
|
|
}
|
|
|
|
impl EmailReader for TestMessagesReader {
|
|
fn read_rfc822_messages(&mut self) -> Box<IntoIter<(String, Vec<u8>)>> {
|
|
let reader = match read_dir(&self.path) {
|
|
Ok(r) => r,
|
|
Err(_) => return Box::new(Vec::new().into_iter()),
|
|
};
|
|
|
|
let items = reader
|
|
.filter(|i| i.is_ok())
|
|
.map(|i| i.unwrap() as DirEntry)
|
|
.filter(|d| match d.path().extension() {
|
|
Some(ext) => ext == "eml",
|
|
None => false,
|
|
})
|
|
.map(|i| {
|
|
let uid = i.path().file_stem().unwrap().to_owned();
|
|
if let Ok(data) = std::fs::read(i.path()) {
|
|
Some((uid.into_string().unwrap(), data))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.filter(|i| i.is_some())
|
|
.map(|i| i.unwrap());
|
|
|
|
let iter = items.collect::<Vec<(String, Vec<u8>)>>().into_iter();
|
|
|
|
Box::new(iter)
|
|
}
|
|
}
|
|
|
|
fn connect(
|
|
server: &str,
|
|
port: u16,
|
|
username: &str,
|
|
password: &str,
|
|
) -> Result<HashMap<String, Vec<u8>>, Box<dyn Error>> {
|
|
let mut session = open_session(server, port, username, password)?;
|
|
|
|
session.examine("INBOX")?;
|
|
|
|
let items = match session.uid_search("ALL") {
|
|
Ok(i) => i,
|
|
Err(e) => return Err(Box::new(e)),
|
|
};
|
|
|
|
let mut msgs = HashMap::<String, Vec<u8>>::with_capacity(items.len());
|
|
|
|
//println!("# of messages: {}", &items.len());
|
|
|
|
for item in items {
|
|
let msg = session.uid_fetch(&item.to_string(), "(BODY.PEEK[] UID)")?;
|
|
|
|
let message = if let Some(m) = msg.iter().next() {
|
|
m
|
|
} else {
|
|
continue;
|
|
};
|
|
|
|
let body = message.body().expect("Message did not have a body.");
|
|
|
|
msgs.insert(item.to_string(), body.to_owned());
|
|
}
|
|
|
|
session.logout().expect("Could not log out");
|
|
|
|
Ok(msgs)
|
|
}
|
|
|
|
fn open_session(
|
|
server: &str,
|
|
port: u16,
|
|
username: &str,
|
|
password: &str,
|
|
) -> Result<
|
|
Session<
|
|
rustls_connector::rustls::StreamOwned<
|
|
rustls_connector::rustls::ClientConnection,
|
|
TcpStream,
|
|
>,
|
|
>,
|
|
Box<dyn Error + 'static>,
|
|
> {
|
|
let stream = TcpStream::connect((server, port))?;
|
|
let tls = RustlsConnector::new_with_webpki_roots_certs();
|
|
let tls_stream = tls.connect(server, stream)?;
|
|
|
|
let client = imap::Client::new(tls_stream);
|
|
|
|
Ok(client.login(username, password).map_err(|e| e.0)?)
|
|
}
|