Files
jcoffey-dev 6afddcf43b Import upstream v1.1.0, renamed
Upstream commit 08ccf5ddfe9bcdd973df6cab8f89374e454af091, renamed by scripts/upstream-import.py.
2026-11-17 08:13:05 -07:00

303 lines
8.9 KiB
Rust

/*
* SPDX-FileCopyrightText: 2020 Stalwart Labs LLC <[email protected]>
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*/
use std::time::Duration;
use testcontainers::core::{IntoContainerPort, WaitFor};
use testcontainers::runners::{SyncBuilder, SyncRunner};
use testcontainers::{Container, GenericBuildableImage, GenericImage, ImageExt};
use super::data::load_mbox;
use super::error::{ContainerError, ContainerResult};
use super::imap_client::{ImapSeed, MailboxSeed, SeedProbes};
use super::layouts::{self};
use super::sieve_client::SieveSeed as SieveClient;
use super::{Account, Endpoint};
const IMAP_PORT: u16 = 143;
const SIEVE_PORT: u16 = 4190;
const DOCKERFILE: &str = r#"FROM debian:bookworm-20260518-slim
RUN apt-get update && \
DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
dovecot-imapd dovecot-managesieved dovecot-pop3d dovecot-sieve \
openssl ca-certificates && \
rm -rf /var/lib/apt/lists/* && \
addgroup --gid 5000 vmail && \
adduser --system --no-create-home --uid 5000 --gid 5000 vmail && \
mkdir -p /var/vmail && chown -R vmail:vmail /var/vmail && \
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/dovecot/dovecot.key \
-out /etc/dovecot/dovecot.crt \
-subj /CN=localhost && \
chmod 600 /etc/dovecot/dovecot.key
COPY dovecot.conf /etc/dovecot/dovecot.conf
COPY users /etc/dovecot/users
EXPOSE 143 4190
CMD ["dovecot", "-F"]
"#;
const DOVECOT_CONF: &str = r#"protocols = imap sieve
listen = *
mail_location = maildir:/var/vmail/%u/Maildir
mail_uid = 5000
mail_gid = 5000
mail_privileged_group = vmail
namespace inbox {
inbox = yes
separator = /
prefix =
}
auth_mechanisms = plain login
disable_plaintext_auth = no
passdb {
driver = passwd-file
args = /etc/dovecot/users
}
userdb {
driver = static
args = uid=5000 gid=5000 home=/var/vmail/%u
}
service imap-login {
inet_listener imap {
port = 143
}
}
service managesieve-login {
inet_listener sieve {
port = 4190
}
}
protocol imap {
mail_plugins = $mail_plugins imap_sieve
}
protocol sieve {
managesieve_max_line_length = 1M
managesieve_max_compile_errors = 5
}
ssl = yes
ssl_cert = </etc/dovecot/dovecot.crt
ssl_key = </etc/dovecot/dovecot.key
log_path = /dev/stderr
info_log_path = /dev/stderr
plugin {
sieve = file:~/sieve;active=~/.dovecot.sieve
sieve_max_script_size = 1M
imapsieve_url = sieve://127.0.0.1:4190
}
"#;
fn users_file() -> String {
let mut out = String::new();
for u in layouts::accounts() {
out.push_str(u);
out.push_str(":{plain}");
out.push_str(layouts::PASSWORD);
out.push_str(":5000:5000::/var/vmail/");
out.push_str(u);
out.push_str("::\n");
}
out
}
pub struct Dovecot {
container: Container<GenericImage>,
pub imap: Endpoint,
pub sieve: Endpoint,
pub accounts: Vec<Account>,
}
impl Dovecot {
pub fn start() -> ContainerResult<Self> {
let image: GenericImage = GenericBuildableImage::new("inbuxa-migrate-dovecot", "test")
.with_dockerfile_string(DOCKERFILE.to_owned())
.with_data(DOVECOT_CONF.as_bytes().to_vec(), "dovecot.conf")
.with_data(users_file().into_bytes(), "users")
.build_image()
.map_err(|e| ContainerError::Seed(format!("dovecot build: {e}")))?;
let request = image
.with_exposed_port(IMAP_PORT.tcp())
.with_exposed_port(SIEVE_PORT.tcp())
.with_wait_for(WaitFor::message_on_stderr("starting up"))
.with_startup_timeout(Duration::from_secs(120))
.with_labels([(super::OWNER_LABEL, "1")]);
let container = request.start()?;
let host = container.get_host()?.to_string();
let imap = Endpoint::new(host.clone(), container.get_host_port_ipv4(IMAP_PORT.tcp())?);
let sieve = Endpoint::new(host, container.get_host_port_ipv4(SIEVE_PORT.tcp())?);
ImapSeed::connect(&imap.host, imap.port)?.logout()?;
let accounts: Vec<Account> = layouts::accounts()
.iter()
.map(|name| Account {
username: (*name).to_owned(),
password: layouts::PASSWORD.to_owned(),
layout: layouts::layout_for(name),
})
.collect();
Ok(Self {
container,
imap,
sieve,
accounts,
})
}
pub fn seed_all(&self) -> ContainerResult<Vec<AccountSeed>> {
let limit = self
.accounts
.iter()
.map(|a| a.layout.email_count)
.max()
.unwrap_or(0)
.max(1);
let messages = load_mbox(limit)?;
let probes = SeedProbes {
flag: flag_probe_message(),
no_message_id: Some(no_message_id_probe()),
shared_message_id: Some(shared_message_id_probe()),
};
let mut out = Vec::new();
for acct in &self.accounts {
let mut client = ImapSeed::open(&self.imap, acct)?;
let mailbox = client.seed_layout(acct, &messages, &probes)?;
client.logout()?;
let sieve = self.seed_sieve(acct)?;
out.push(AccountSeed {
username: acct.username.clone(),
mailbox,
sieve,
});
}
Ok(out)
}
fn seed_sieve(&self, account: &Account) -> ContainerResult<SieveSeed> {
if account.layout.sieve_scripts.is_empty() {
return Ok(SieveSeed::default());
}
let mut client = SieveClient::connect_seed(&self.sieve.host, self.sieve.port)?;
client.authenticate(&account.username, &account.password)?;
let mut active_name: Option<&'static str> = None;
let mut names = Vec::new();
for script in account.layout.sieve_scripts {
client.putscript(script.name, script.body)?;
names.push(script.name.to_owned());
if script.active {
active_name = Some(script.name);
}
}
if let Some(name) = active_name {
client.setactive(name)?;
}
client.logout()?;
Ok(SieveSeed {
names,
active: active_name.map(str::to_owned),
})
}
pub fn create_leaves_without_parents(
&self,
account: &Account,
leaves: &[&str],
message: &[u8],
) -> ContainerResult<Vec<String>> {
let mut client = ImapSeed::open(&self.imap, account)?;
for name in leaves {
client.create(name)?;
client.append_with_flags(name, &[], message)?;
}
let listed = client.list_raw()?;
client.logout()?;
Ok(listed)
}
pub fn install_broken_sieve(&self, account: &Account) -> ContainerResult<String> {
let mut client = SieveClient::connect_seed(&self.sieve.host, self.sieve.port)?;
client.authenticate(&account.username, &account.password)?;
let name = "broken-script";
client.putscript_raw(name, "INVALID:::not_a_sieve_program;;;")?;
client.logout()?;
Ok(name.to_owned())
}
pub fn verify_seed(&self, seeds: &[AccountSeed]) -> ContainerResult<()> {
for (acct, seed) in self.accounts.iter().zip(seeds) {
let mut client = ImapSeed::open(&self.imap, acct)?;
client.verify_layout(acct, &seed.mailbox, &acct.username)?;
client.logout()?;
}
Ok(())
}
pub fn stop(self) -> ContainerResult<()> {
self.container.stop()?;
Ok(())
}
}
pub fn flag_probe_message() -> Vec<u8> {
let body = "From: [email protected]\r\n\
To: [email protected]\r\n\
Subject: Flag probe\r\n\
Message-ID: <[email protected]>\r\n\
Date: Wed, 01 Jan 2025 12:00:00 +0000\r\n\
\r\n\
Flag probe body.\r\n";
body.as_bytes().to_vec()
}
pub fn no_message_id_probe() -> Vec<u8> {
let body = "From: [email protected]\r\n\
To: [email protected]\r\n\
Subject: No Message-ID probe\r\n\
Date: Wed, 01 Jan 2025 12:00:00 +0000\r\n\
\r\n\
No Message-ID body.\r\n";
body.as_bytes().to_vec()
}
pub fn shared_message_id_probe() -> Vec<u8> {
let body = "From: [email protected]\r\n\
To: [email protected]\r\n\
Subject: Shared MID probe\r\n\
Message-ID: <[email protected]>\r\n\
Date: Wed, 01 Jan 2025 12:00:00 +0000\r\n\
\r\n\
Shared MID body.\r\n";
body.as_bytes().to_vec()
}
#[derive(Debug, Default, Clone)]
pub struct SieveSeed {
pub names: Vec<String>,
pub active: Option<String>,
}
#[derive(Debug, Clone)]
pub struct AccountSeed {
pub username: String,
pub mailbox: MailboxSeed,
pub sieve: SieveSeed,
}