mirror of
https://github.com/mailcow/mailcow-dockerized.git
synced 2026-11-15 21:00:14 +00:00
[Web] Add archive module classes
This commit is contained in:
17 files changed
+1685
No files matched your search
@@ -0,0 +1,125 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Mailcow\Archive\Service;
|
||||
|
||||
use DateTime;
|
||||
use Mailcow\Archive\Model\Journal;
|
||||
use Mailcow\Archive\Model\Settings;
|
||||
|
||||
/**
|
||||
* Metadata header block in front of an archive copy, by profile:
|
||||
*
|
||||
* - archivecow: X-Archive-Owner, -Rcpt, -From, -Queue-ID, -Received, -Direction, -Source, -SHA256 and as the last
|
||||
* line X-Archive-Signature: v=1; a=hmac-sha256; s=<hex>. The signature is HMAC-SHA256 with the signing key over
|
||||
* the lines above it, each as "<lower case name>:<value without any whitespace>", joined by "\n".
|
||||
* The block ends with the signature line, everything after it is the mail as accepted (CRLF line ends).
|
||||
* - envelope: SMTP sender and recipients under configurable names (default X-Envelope-From / X-Envelope-To).
|
||||
* - none: no headers.
|
||||
*
|
||||
* Empty values are left out. Lists are folded after commas (CRLF + space).
|
||||
*/
|
||||
class HeaderBuilder
|
||||
{
|
||||
/** Fold a list before a line would get longer */
|
||||
private const FOLD_AT = 78;
|
||||
|
||||
public function build(Settings $settings, Journal $journal): string
|
||||
{
|
||||
return match ($settings->profile) {
|
||||
'archivecow' => $this->archivecow($settings, $journal),
|
||||
'envelope' => $this->envelope($settings, $journal),
|
||||
default => '',
|
||||
};
|
||||
}
|
||||
|
||||
/** One line of the signed text */
|
||||
public static function canonical(string $name, string $value): string
|
||||
{
|
||||
return strtolower($name) . ':' . preg_replace('/\s+/', '', $value);
|
||||
}
|
||||
|
||||
private function archivecow(Settings $settings, Journal $journal): string
|
||||
{
|
||||
$values = [
|
||||
'X-Archive-Owner' => $journal->owners,
|
||||
'X-Archive-Rcpt' => $journal->rcpts,
|
||||
'X-Archive-From' => $journal->from,
|
||||
'X-Archive-Queue-ID' => $journal->qid,
|
||||
'X-Archive-Received' => self::time($journal->received),
|
||||
'X-Archive-Direction' => $journal->direction,
|
||||
'X-Archive-Source' => $journal->source,
|
||||
'X-Archive-SHA256' => $journal->sha256,
|
||||
];
|
||||
$lines = [];
|
||||
$signed = [];
|
||||
foreach ($values as $name => $value) {
|
||||
$value = is_array($value) ? self::cleanList($value) : self::clean($value);
|
||||
if ($value === '' || $value === []) {
|
||||
continue;
|
||||
}
|
||||
$lines[] = self::line($name, $value);
|
||||
$signed[] = self::canonical($name, is_array($value) ? implode(',', $value) : $value);
|
||||
}
|
||||
$lines[] = 'X-Archive-Signature: v=1; a=hmac-sha256; s=' . hash_hmac('sha256', implode("\n", $signed), $settings->signingKey);
|
||||
return implode("\r\n", $lines) . "\r\n";
|
||||
}
|
||||
|
||||
private function envelope(Settings $settings, Journal $journal): string
|
||||
{
|
||||
$from = self::clean($journal->from);
|
||||
$lines = [self::line($settings->headerFrom, ($from === '') ? '<>' : $from)];
|
||||
$rcpts = self::cleanList($journal->rcpts);
|
||||
if ($rcpts !== []) {
|
||||
$lines[] = self::line($settings->headerRcpt, $rcpts);
|
||||
}
|
||||
return implode("\r\n", $lines) . "\r\n";
|
||||
}
|
||||
|
||||
/** Header line; a list is folded after commas */
|
||||
private static function line(string $name, string|array $value): string
|
||||
{
|
||||
if (is_string($value)) {
|
||||
return $name . ': ' . $value;
|
||||
}
|
||||
$out = $name . ': ' . array_shift($value);
|
||||
$length = strlen($out);
|
||||
foreach ($value as $item) {
|
||||
if ($length + strlen($item) + 1 > self::FOLD_AT) {
|
||||
$out .= ",\r\n " . $item;
|
||||
$length = strlen($item) + 1;
|
||||
} else {
|
||||
$out .= ',' . $item;
|
||||
$length += strlen($item) + 1;
|
||||
}
|
||||
}
|
||||
return $out;
|
||||
}
|
||||
|
||||
/** Header value without control characters (no header injection) */
|
||||
private static function clean(string $value): string
|
||||
{
|
||||
return trim((string)preg_replace('/[\x00-\x1f\x7f]+/', ' ', $value));
|
||||
}
|
||||
|
||||
/** @return string[] */
|
||||
private static function cleanList(array $values): array
|
||||
{
|
||||
$list = [];
|
||||
foreach ($values as $value) {
|
||||
$value = is_string($value) ? str_replace(',', '', self::clean($value)) : '';
|
||||
if ($value !== '') {
|
||||
$list[] = $value;
|
||||
}
|
||||
}
|
||||
return $list;
|
||||
}
|
||||
|
||||
/** RFC 3339 in UTC with milliseconds */
|
||||
private static function time(float $time): string
|
||||
{
|
||||
$date = DateTime::createFromFormat('U.u', sprintf('%.3F', $time));
|
||||
return $date ? $date->format('Y-m-d\TH:i:s.v\Z') : '';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Mailcow\Archive\Service;
|
||||
|
||||
use Mailcow\Archive\Model\Journal;
|
||||
use Mailcow\Archive\Model\Settings;
|
||||
use Mailcow\Archive\Redis\ArchiveState;
|
||||
use Mailcow\Archive\Repository\SettingsRepository;
|
||||
use Mailcow\Archive\Smtp\SmtpClient;
|
||||
use Mailcow\Archive\Smtp\SmtpException;
|
||||
use Mailcow\Core\Context;
|
||||
use Mailcow\Core\UserError;
|
||||
use Throwable;
|
||||
|
||||
/**
|
||||
* Archive copies: a copy of every accepted mail of an archived mailbox goes by SMTP to the archive, through the
|
||||
* Postfix queue. rspamd sends the copies of mails it scanned (rspamd.local.lua) and asks prepare() whether to send
|
||||
* one and for its header block; mails that bypass rspamd (quarantine release, mass mail) are sent here.
|
||||
*
|
||||
* Copies have the envelope sender Settings::SENDER, Postfix drops every notice to it: an archive copy never causes
|
||||
* a bounce or delay warning to a real sender.
|
||||
*/
|
||||
class JournalService
|
||||
{
|
||||
/** Postfix service that takes copies (no milter, mynetworks only) */
|
||||
private const SUBMIT_PORT = 591;
|
||||
|
||||
public function __construct(
|
||||
private SettingsRepository $settings,
|
||||
private OwnerResolver $resolver,
|
||||
private HeaderBuilder $headers,
|
||||
private SmtpClient $smtp,
|
||||
private ArchiveState $state,
|
||||
private Context $context,
|
||||
private string $postfixHost = 'postfix'
|
||||
) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Archive decision for a mail rspamd accepted (dynmap archive.php), no copy while archiving is off or no
|
||||
* archived mailbox is involved.
|
||||
*
|
||||
* @param array $request from, rcpt[], user, bcc, qid, received, sha256 (of the content rspamd sends)
|
||||
* @return array{archive: bool, rcpt?: string, sender?: string, headers?: string}
|
||||
*/
|
||||
public function prepare(array $request): array
|
||||
{
|
||||
$settings = $this->settings->load();
|
||||
$this->state->setEnabled($settings->enabled);
|
||||
if (!$settings->enabled || !$settings->canDeliver()) {
|
||||
return ['archive' => false];
|
||||
}
|
||||
$from = self::text($request['from'] ?? '');
|
||||
$rcpts = is_array($request['rcpt'] ?? null) ? array_values(array_filter($request['rcpt'], 'is_string')) : [];
|
||||
$resolved = $this->resolver->resolve($from, $rcpts, self::text($request['user'] ?? ''), ($request['bcc'] ?? false) === true);
|
||||
if ($resolved['owners'] === []) {
|
||||
return ['archive' => false];
|
||||
}
|
||||
$sha256 = self::text($request['sha256'] ?? '');
|
||||
$journal = new Journal($resolved['owners'], $rcpts, $from, mb_strcut(self::text($request['qid'] ?? ''), 0, 64),
|
||||
$resolved['direction'], 'smtp', is_numeric($request['received'] ?? null) ? (float)$request['received'] : microtime(true),
|
||||
preg_match('/^[0-9a-f]{64}$/', $sha256) ? $sha256 : '');
|
||||
return ['archive' => true, 'rcpt' => $settings->address, 'sender' => Settings::SENDER, 'headers' => $this->headers->build($settings, $journal)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends the copy of a mail that reached its mailbox without rspamd (quarantine release, mass mail) for its
|
||||
* archived recipients. Errors are logged and counted, never thrown: the mail is delivered already.
|
||||
*
|
||||
* @param string[] $rcpts
|
||||
*/
|
||||
public function submitDelivered(string $message, string $from, array $rcpts, string $source): bool
|
||||
{
|
||||
try {
|
||||
$settings = $this->settings->load();
|
||||
if (!$settings->enabled || !$settings->canDeliver()) {
|
||||
return false;
|
||||
}
|
||||
$resolved = $this->resolver->resolve($from, $rcpts, '', false);
|
||||
if ($resolved['owners'] === []) {
|
||||
return false;
|
||||
}
|
||||
$this->send($settings, $message, $resolved['owners'], array_values($rcpts), $from, 'in', $source);
|
||||
return true;
|
||||
} catch (Throwable $e) {
|
||||
error_log('ARCHIVE: cannot send the archive copy (' . $source . '): ' . $e->getMessage());
|
||||
$this->state->dropped('', $source . ': ' . $e->getMessage(), self::messageId($message));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends a test copy through Postfix to the archive and returns the Postfix queue id.
|
||||
*
|
||||
* @throws UserError
|
||||
*/
|
||||
public function testMail(): string
|
||||
{
|
||||
$this->context->requireAdmin();
|
||||
$settings = $this->settings->load();
|
||||
if (!$settings->canDeliver()) {
|
||||
throw new UserError('archive_incomplete');
|
||||
}
|
||||
$message = implode("\r\n", [
|
||||
'From: mailcow <' . Settings::SENDER . '>',
|
||||
'To: <' . $settings->address . '>',
|
||||
'Subject: mailcow archive test',
|
||||
'Date: ' . date(DATE_RFC2822),
|
||||
'Message-ID: <' . bin2hex(random_bytes(12)) . '@archive-test.mailcow>',
|
||||
'MIME-Version: 1.0',
|
||||
'Content-Type: text/plain; charset=utf-8',
|
||||
'',
|
||||
'Test copy from mailcow (System - Configuration - Archive).',
|
||||
'',
|
||||
]);
|
||||
try {
|
||||
return $this->send($settings, $message, [], [$settings->address], Settings::SENDER, 'in', 'test');
|
||||
} catch (SmtpException $e) {
|
||||
throw new UserError('archive_testmail_failed', [htmlspecialchars($e->describe())]);
|
||||
}
|
||||
}
|
||||
|
||||
/** @throws SmtpException */
|
||||
private function send(Settings $settings, string $message, array $owners, array $rcpts, string $from, string $direction, string $source): string
|
||||
{
|
||||
$message = SmtpClient::crlf($message);
|
||||
$journal = new Journal($owners, $rcpts, $from, '', $direction, $source, microtime(true), hash('sha256', $message));
|
||||
return $this->smtp->submit($this->postfixHost, self::SUBMIT_PORT, Settings::SENDER, $settings->address,
|
||||
$this->headers->build($settings, $journal) . $message);
|
||||
}
|
||||
|
||||
/** Message-ID of a mail, for the archive log */
|
||||
private static function messageId(string $message): string
|
||||
{
|
||||
$headers = explode("\n\n", str_replace("\r\n", "\n", $message), 2)[0];
|
||||
return preg_match('/^Message-ID:\s*<?([^>\s]+)>?/mi', $headers, $m) ? $m[1] : '';
|
||||
}
|
||||
|
||||
private static function text(mixed $value): string
|
||||
{
|
||||
return is_scalar($value) ? trim((string)preg_replace('/[\x00-\x1f\x7f]+/', ' ', (string)$value)) : '';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Mailcow\Archive\Service;
|
||||
|
||||
use Mailcow\Archive\Model\Mailbox;
|
||||
use Mailcow\Archive\Repository\LookupRepository;
|
||||
use Mailcow\Archive\Repository\SettingsRepository;
|
||||
use Mailcow\Core\AccessDenied;
|
||||
use Mailcow\Core\Context;
|
||||
|
||||
/**
|
||||
* The mailboxes archived now (GET archive/mailboxes), the list archivecow keeps its mailboxes in line with.
|
||||
* Same rule as the owners of a mail: the global switch, then the mailbox setting, 'inherit' follows the domain.
|
||||
*/
|
||||
class MailboxListService
|
||||
{
|
||||
public function __construct(private LookupRepository $lookup, private SettingsRepository $settings, private Context $context)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Admins, read-only API keys included.
|
||||
*
|
||||
* @return array{enabled: int, mailboxes: array[]}
|
||||
* @throws AccessDenied
|
||||
*/
|
||||
public function archived(): array
|
||||
{
|
||||
$this->context->requireAdmin(false);
|
||||
$enabled = $this->settings->load()->enabled;
|
||||
return [
|
||||
'enabled' => (int)$enabled,
|
||||
'mailboxes' => $enabled ? array_map(fn(Mailbox $mailbox): array => $mailbox->toArray(), $this->lookup->archivedMailboxes()) : [],
|
||||
];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,264 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Mailcow\Archive\Service;
|
||||
|
||||
use Mailcow\Archive\Model\Mailbox;
|
||||
use Mailcow\Archive\Repository\LookupRepository;
|
||||
|
||||
/**
|
||||
* Finds the mailboxes a mail belongs to in the archive, following the way Postfix delivers it.
|
||||
*
|
||||
* Incoming: each envelope recipient goes through recipient_maps (one rewrite) and the virtual alias expansion:
|
||||
* alias rows (incl. catch-alls and groups), resources (discarded), spam aliases and mailboxes of alias domains,
|
||||
* each tried as u+ext@d, u@d and @d, recursively. The local mailboxes at the end receive the mail. BCC map
|
||||
* destinations count as recipients when rspamd sends the BCC copy (it bypasses rspamd).
|
||||
*
|
||||
* Outgoing: the SASL user and the mailbox the user sent as (its address, with +tag or in an alias domain);
|
||||
* Postfix already checked that the login may use that sender. Without a login the sender never counts, so a
|
||||
* forged local sender cannot make a mailbox an owner.
|
||||
*
|
||||
* Only mailboxes with archiving become owners.
|
||||
*/
|
||||
class OwnerResolver
|
||||
{
|
||||
/** virtual_alias_recursion_limit and virtual_alias_expansion_limit of Postfix */
|
||||
private const MAX_DEPTH = 1000;
|
||||
private const MAX_ADDRESSES = 1000;
|
||||
|
||||
public function __construct(private LookupRepository $lookup)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @param string[] $rcpts SMTP envelope recipients
|
||||
* @param bool $bcc rspamd sent the BCC copies of this mail
|
||||
* @return array{owners: string[], direction: string} sorted usernames; direction in, out or internal
|
||||
*/
|
||||
public function resolve(string $from, array $rcpts, string $user, bool $bcc): array
|
||||
{
|
||||
$from = self::address($from);
|
||||
$incoming = [];
|
||||
foreach ($rcpts as $rcpt) {
|
||||
$rcpt = self::address($rcpt);
|
||||
if ($rcpt !== '') {
|
||||
$this->deliver($rcpt, $incoming);
|
||||
}
|
||||
}
|
||||
if ($bcc) {
|
||||
foreach ($this->bccDestinations($from, $rcpts) as $destination) {
|
||||
$this->deliver($destination, $incoming);
|
||||
}
|
||||
}
|
||||
$outgoing = $this->senders($from, self::address($user));
|
||||
$owners = [];
|
||||
foreach (array_merge(array_values($incoming), array_values($outgoing)) as $mailbox) {
|
||||
if ($mailbox->archived()) {
|
||||
$owners[$mailbox->username] = true;
|
||||
}
|
||||
}
|
||||
$owners = array_keys($owners);
|
||||
sort($owners);
|
||||
$direction = empty($outgoing) ? 'in' : (empty($incoming) ? 'out' : 'internal');
|
||||
return ['owners' => $owners, 'direction' => $direction];
|
||||
}
|
||||
|
||||
/** Adds the local mailboxes a recipient ends in to $mailboxes (username => Mailbox) */
|
||||
private function deliver(string $address, array &$mailboxes): void
|
||||
{
|
||||
$seen = [];
|
||||
$this->expand($this->canonical($address), 0, $mailboxes, $seen);
|
||||
}
|
||||
|
||||
/** recipient_maps: first matching key form, one rewrite */
|
||||
private function canonical(string $address): string
|
||||
{
|
||||
foreach (self::keys($address) as $key) {
|
||||
$target = self::target($this->lookup->recipientMap($key));
|
||||
if ($target !== '') {
|
||||
return self::rewrite($address, $key, $target);
|
||||
}
|
||||
}
|
||||
return $address;
|
||||
}
|
||||
|
||||
private function expand(string $address, int $depth, array &$mailboxes, array &$seen): void
|
||||
{
|
||||
if ($depth > self::MAX_DEPTH || count($seen) >= self::MAX_ADDRESSES || isset($seen[$address])) {
|
||||
return;
|
||||
}
|
||||
$seen[$address] = true;
|
||||
$targets = $this->virtual($address);
|
||||
if ($targets === null) {
|
||||
$this->final($address, $mailboxes);
|
||||
return;
|
||||
}
|
||||
foreach ($targets as $target) {
|
||||
// an address that expands to itself is delivered as it is
|
||||
if ($target === $address) {
|
||||
$this->final($address, $mailboxes);
|
||||
} else {
|
||||
$this->expand($target, $depth + 1, $mailboxes, $seen);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Targets from the first key form a virtual alias map knows, null if none does */
|
||||
private function virtual(string $address): ?array
|
||||
{
|
||||
if (self::split($address)[1] === 'localhost') {
|
||||
// null@, spam@, ham@localhost: local delivery of Postfix, never a mailbox
|
||||
return [];
|
||||
}
|
||||
foreach (self::keys($address) as $key) {
|
||||
$targets = $this->virtualLookup($key);
|
||||
if ($targets !== null) {
|
||||
return array_map(fn(string $target): string => self::rewrite($address, $key, $target), $targets);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** virtual_alias_maps in the order of main.cf: alias, resource, spam alias, alias domain mailbox */
|
||||
private function virtualLookup(string $key): ?array
|
||||
{
|
||||
$domainKey = str_starts_with($key, '@');
|
||||
$targets = self::targets($this->lookup->aliasGoto($key));
|
||||
if ($targets === null && !$domainKey && $this->lookup->isResource($key)) {
|
||||
$targets = ['null@localhost'];
|
||||
}
|
||||
$targets ??= self::targets($this->lookup->spamAliasGoto($key));
|
||||
if ($targets === null && !$domainKey) {
|
||||
[$local, $domain] = self::split($key);
|
||||
$targets = self::targets($this->lookup->aliasDomainMailbox($local, $domain));
|
||||
}
|
||||
return $targets;
|
||||
}
|
||||
|
||||
/** A final address: a mailbox (as u+ext@d or u@d) or anything else, which is not ours */
|
||||
private function final(string $address, array &$mailboxes): void
|
||||
{
|
||||
foreach (array_unique([$address, self::untagged($address)]) as $candidate) {
|
||||
$mailbox = $this->lookup->mailbox($candidate);
|
||||
if ($mailbox !== null) {
|
||||
$mailboxes[$mailbox->username] = $mailbox;
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** BCC destinations of rspamd: rcpt maps for every recipient and its domain, sender maps for MAIL FROM and its domain */
|
||||
private function bccDestinations(string $from, array $rcpts): array
|
||||
{
|
||||
$destinations = [];
|
||||
foreach ($rcpts as $rcpt) {
|
||||
$rcpt = self::address($rcpt);
|
||||
if ($rcpt !== '') {
|
||||
$destinations[] = $this->lookup->bccDestination(self::untagged($rcpt), 'rcpt');
|
||||
$destinations[] = $this->lookup->bccDestination('@' . self::split($rcpt)[1], 'rcpt');
|
||||
}
|
||||
}
|
||||
if ($from !== '') {
|
||||
$destinations[] = $this->lookup->bccDestination(self::untagged($from), 'sender');
|
||||
$destinations[] = $this->lookup->bccDestination('@' . self::split($from)[1], 'sender');
|
||||
}
|
||||
return array_values(array_unique(array_filter(array_map(fn(?string $address): string => self::address($address), $destinations))));
|
||||
}
|
||||
|
||||
/** Mailboxes on the sending side: the SASL user and the mailbox the user sent as */
|
||||
private function senders(string $from, string $user): array
|
||||
{
|
||||
$mailbox = ($user !== '') ? $this->lookup->mailbox($user) : null;
|
||||
if ($mailbox === null) {
|
||||
return [];
|
||||
}
|
||||
$senders = [$mailbox->username => $mailbox];
|
||||
$sentAs = ($from !== '') ? $this->sentAs(self::untagged($from)) : null;
|
||||
if ($sentAs !== null) {
|
||||
$senders[$sentAs->username] = $sentAs;
|
||||
}
|
||||
return $senders;
|
||||
}
|
||||
|
||||
/** Mailbox a sender address belongs to: the mailbox itself or the mailbox behind an alias domain address, not aliases */
|
||||
private function sentAs(string $address): ?Mailbox
|
||||
{
|
||||
$mailbox = $this->lookup->mailbox($address);
|
||||
if ($mailbox === null) {
|
||||
[$local, $domain] = self::split($address);
|
||||
$username = $this->lookup->aliasDomainMailbox($local, $domain);
|
||||
$mailbox = ($username !== null) ? $this->lookup->mailbox(strtolower($username)) : null;
|
||||
}
|
||||
return $mailbox;
|
||||
}
|
||||
|
||||
/** Lookup keys in the order of Postfix: u+ext@d, u@d, @d */
|
||||
private static function keys(string $address): array
|
||||
{
|
||||
$keys = [$address, self::untagged($address), '@' . self::split($address)[1]];
|
||||
return array_values(array_unique($keys));
|
||||
}
|
||||
|
||||
/**
|
||||
* Result of a lookup for $address under $key: '@domain' keeps the local part, a match without the extension
|
||||
* passes it on (propagate_unmatched_extensions).
|
||||
*/
|
||||
private static function rewrite(string $address, string $key, string $target): string
|
||||
{
|
||||
[$local] = self::split($address);
|
||||
if (str_starts_with($target, '@')) {
|
||||
return $local . $target;
|
||||
}
|
||||
$extension = self::extension($local);
|
||||
if ($key === $address || $extension === '') {
|
||||
return $target;
|
||||
}
|
||||
[$targetLocal, $targetDomain] = self::split($target);
|
||||
return ($targetDomain === 'localhost' || self::extension($targetLocal) !== '')
|
||||
? $target
|
||||
: $targetLocal . '+' . $extension . '@' . $targetDomain;
|
||||
}
|
||||
|
||||
/** Comma separated lookup result; null when empty (not found) */
|
||||
private static function targets(?string $value): ?array
|
||||
{
|
||||
$targets = array_values(array_filter(array_map(fn(string $target): string => self::target($target), explode(',', (string)$value))));
|
||||
return empty($targets) ? null : $targets;
|
||||
}
|
||||
|
||||
/** Address or '@domain' from a lookup result, lower case; '' if invalid */
|
||||
private static function target(?string $value): string
|
||||
{
|
||||
$value = strtolower(trim((string)$value));
|
||||
return preg_match('/^[^@\s,<>]*@[^@\s,<>]+$/', $value) ? $value : '';
|
||||
}
|
||||
|
||||
/** Lower case address without angle brackets; '' unless local@domain */
|
||||
private static function address(mixed $value): string
|
||||
{
|
||||
$value = is_string($value) ? strtolower(trim($value, " \t\r\n<>")) : '';
|
||||
return preg_match('/^[^@\s,<>]+@[^@\s,<>]+$/', $value) ? $value : '';
|
||||
}
|
||||
|
||||
private static function untagged(string $address): string
|
||||
{
|
||||
[$local, $domain] = self::split($address);
|
||||
$pos = strpos($local, '+');
|
||||
return ($pos === false || $pos === 0) ? $address : substr($local, 0, $pos) . '@' . $domain;
|
||||
}
|
||||
|
||||
/** Address extension after the recipient delimiter "+" */
|
||||
private static function extension(string $local): string
|
||||
{
|
||||
$pos = strpos($local, '+');
|
||||
return ($pos === false || $pos === 0) ? '' : substr($local, $pos + 1);
|
||||
}
|
||||
|
||||
/** [local part, domain] of an address or '@domain' */
|
||||
private static function split(string $address): array
|
||||
{
|
||||
$at = strrpos($address, '@');
|
||||
return ($at === false) ? [$address, ''] : [substr($address, 0, $at), substr($address, $at + 1)];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Mailcow\Archive\Service;
|
||||
|
||||
use Mailcow\Archive\Model\Settings;
|
||||
use Mailcow\Archive\Redis\ArchiveState;
|
||||
use Mailcow\Archive\Repository\LookupRepository;
|
||||
use Mailcow\Archive\Repository\SettingsRepository;
|
||||
use Mailcow\Archive\Smtp\SmtpClient;
|
||||
use Mailcow\Archive\Smtp\SmtpException;
|
||||
use Mailcow\Core\AccessDenied;
|
||||
use Mailcow\Core\Context;
|
||||
use Mailcow\Core\Input;
|
||||
use Mailcow\Core\UserError;
|
||||
use PDOException;
|
||||
|
||||
/**
|
||||
* Admin use cases of the archive target. Read-only API keys may read the settings (never password or key).
|
||||
*/
|
||||
class SettingsService
|
||||
{
|
||||
private const MAX_SECRET_LENGTH = 255;
|
||||
/** Extensions the archive should announce: Postfix passes 8-bit mails unchanged (archive_smtp in master.cf) */
|
||||
private const WANTED_EXTENSIONS = ['8BITMIME'];
|
||||
|
||||
public function __construct(private SettingsRepository $repo, private LookupRepository $lookup, private ArchiveState $state,
|
||||
private SmtpClient $smtp, private Context $context)
|
||||
{
|
||||
}
|
||||
|
||||
/** @throws AccessDenied */
|
||||
public function get(): Settings
|
||||
{
|
||||
$this->context->requireAdmin(false);
|
||||
return $this->repo->load();
|
||||
}
|
||||
|
||||
/** Global switch for internal callers (page templates, mailbox details), no permission check; off while the table is missing */
|
||||
public function enabled(): bool
|
||||
{
|
||||
try {
|
||||
return $this->repo->load()->enabled;
|
||||
} catch (PDOException) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Saves the settings: attributes missing in $input keep their value, an empty password or signing key keeps
|
||||
* the stored one, `password_remove` deletes the password. Switching on needs an address (and a signing key for archivecow).
|
||||
*
|
||||
* @throws UserError
|
||||
*/
|
||||
public function save(array $input): Settings
|
||||
{
|
||||
$this->context->requireAdmin();
|
||||
$settings = $this->repo->load();
|
||||
if (array_key_exists('address', $input)) {
|
||||
$address = strtolower((string)Input::text($input['address']));
|
||||
if (!is_scalar($input['address']) || ($address !== '' && !filter_var($address, FILTER_VALIDATE_EMAIL))) {
|
||||
throw new UserError('archive_address_invalid');
|
||||
}
|
||||
// Postfix would treat an own address as local (aliases, unknown users) before the copy reaches the archive
|
||||
if ($address !== '' && $this->lookup->isMailcowDomain(substr($address, strrpos($address, '@') + 1))) {
|
||||
throw new UserError('archive_address_local');
|
||||
}
|
||||
$settings->address = $address;
|
||||
}
|
||||
if (array_key_exists('host', $input)) {
|
||||
$host = strtolower(trim((string)Input::text($input['host']), " []"));
|
||||
if (!is_scalar($input['host']) || ($host !== '' && !filter_var($host, FILTER_VALIDATE_IP)
|
||||
&& !filter_var($host, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME))) {
|
||||
throw new UserError('archive_host_invalid');
|
||||
}
|
||||
$settings->host = $host;
|
||||
}
|
||||
if (array_key_exists('port', $input)) {
|
||||
$settings->port = Input::intInRange($input['port'], 1, 65535) ?? throw new UserError('archive_port_invalid');
|
||||
}
|
||||
if (array_key_exists('tls', $input)) {
|
||||
$settings->tls = in_array($input['tls'], Settings::TLS_MODES, true) ? $input['tls'] : throw new UserError('archive_tls_invalid');
|
||||
}
|
||||
if (array_key_exists('username', $input)) {
|
||||
$username = Input::text($input['username']);
|
||||
if ($username === null || strlen($username) > self::MAX_SECRET_LENGTH || preg_match('/[\s:]/', $username)) {
|
||||
throw new UserError('archive_username_invalid');
|
||||
}
|
||||
$settings->username = $username;
|
||||
}
|
||||
if (array_key_exists('password', $input)) {
|
||||
$settings->password = self::secret($input['password'], $settings->password, 'archive_password_invalid');
|
||||
}
|
||||
if (self::flag($input['password_remove'] ?? '0')) {
|
||||
$settings->password = '';
|
||||
}
|
||||
if (array_key_exists('profile', $input)) {
|
||||
$settings->profile = in_array($input['profile'], Settings::PROFILES, true) ? $input['profile'] : throw new UserError('archive_profile_invalid');
|
||||
}
|
||||
if (array_key_exists('signing_secret', $input)) {
|
||||
$settings->signingKey = self::secret($input['signing_secret'], $settings->signingKey, 'archive_signing_secret_invalid');
|
||||
}
|
||||
foreach (['header_from' => 'headerFrom', 'header_rcpt' => 'headerRcpt'] as $key => $property) {
|
||||
if (array_key_exists($key, $input)) {
|
||||
$name = Input::text($input[$key]);
|
||||
if ($name === null || !preg_match('/^[A-Za-z][A-Za-z0-9-]{0,63}$/', $name)) {
|
||||
throw new UserError('archive_header_invalid');
|
||||
}
|
||||
$settings->$property = $name;
|
||||
}
|
||||
}
|
||||
if (array_key_exists('enabled', $input)) {
|
||||
$settings->enabled = self::flag($input['enabled']);
|
||||
}
|
||||
if ($settings->enabled && !$settings->canDeliver()) {
|
||||
throw new UserError('archive_incomplete');
|
||||
}
|
||||
$this->repo->save($settings);
|
||||
$this->state->setEnabled($settings->enabled);
|
||||
return $settings;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the stored target: connection, TLS, AUTH and whether the archive accepts the address (no mail is sent).
|
||||
* Returns the success message, with the missing extension when the archive lacks 8BITMIME.
|
||||
*
|
||||
* @throws UserError
|
||||
*/
|
||||
public function test(): string|array
|
||||
{
|
||||
$this->context->requireAdmin();
|
||||
$settings = $this->repo->load();
|
||||
if ($settings->address === '') {
|
||||
throw new UserError('archive_incomplete');
|
||||
}
|
||||
$host = ($settings->host !== '') ? $settings->host : $this->smtp->mailHost(substr($settings->address, strrpos($settings->address, '@') + 1));
|
||||
try {
|
||||
$extensions = $this->smtp->probe($host, $settings->port, $settings->tls, $settings->username, $settings->password,
|
||||
Settings::SENDER, $settings->address);
|
||||
} catch (SmtpException $e) {
|
||||
throw new UserError('archive_test_failed', [htmlspecialchars($host . ':' . $settings->port . ' ' . $e->describe())]);
|
||||
}
|
||||
$missing = array_values(array_diff(self::WANTED_EXTENSIONS, $extensions));
|
||||
return empty($missing) ? 'archive_test_ok' : ['archive_test_ok_missing', implode(', ', $missing)];
|
||||
}
|
||||
|
||||
/** A new secret, or the stored one when $value is empty */
|
||||
private static function secret(mixed $value, string $current, string $error): string
|
||||
{
|
||||
$secret = Input::text($value);
|
||||
if ($secret === null || strlen($secret) > self::MAX_SECRET_LENGTH || preg_match('/[^\x21-\x7e]/', $secret)) {
|
||||
throw new UserError($error);
|
||||
}
|
||||
return ($secret === '') ? $current : $secret;
|
||||
}
|
||||
|
||||
/** Checkbox or API flag; a hidden "0" + checkbox pair arrives as ["0", "1"] when checked */
|
||||
private static function flag(mixed $value): bool
|
||||
{
|
||||
if (is_array($value)) {
|
||||
$value = end($value);
|
||||
}
|
||||
return filter_var($value, FILTER_VALIDATE_BOOLEAN);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
<?php
|
||||
|
||||
declare(strict_types=1);
|
||||
|
||||
namespace Mailcow\Archive\Service;
|
||||
|
||||
use Mailcow\Archive\Legacy\LegacyQueue;
|
||||
use Mailcow\Archive\Model\Settings;
|
||||
use Mailcow\Archive\Redis\ArchiveState;
|
||||
use Mailcow\Archive\Repository\SettingsRepository;
|
||||
use Mailcow\Core\AccessDenied;
|
||||
use Mailcow\Core\Context;
|
||||
|
||||
/**
|
||||
* State of the archive for the admin: the summary of the archive tab (copies waiting in the Postfix queue with the
|
||||
* reason Postfix gives, last delivery, mails not archived) and the archive log of the dashboard.
|
||||
*/
|
||||
class StatusService
|
||||
{
|
||||
/** Mails not archived count as a problem for a day */
|
||||
private const DROPPED_WINDOW = 86400;
|
||||
|
||||
public function __construct(private SettingsRepository $settings, private ArchiveState $state, private LegacyQueue $queue,
|
||||
private Context $context)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* GET archive/status (admins, read-only keys included).
|
||||
*
|
||||
* @throws AccessDenied
|
||||
*/
|
||||
public function status(): array
|
||||
{
|
||||
$this->context->requireAdmin(false);
|
||||
$settings = $this->settings->load();
|
||||
$copies = $this->queue->entries(Settings::SENDER);
|
||||
$reasons = [];
|
||||
$oldest = null;
|
||||
$bytes = 0;
|
||||
foreach ($copies as $copy) {
|
||||
$arrival = (int)($copy['arrival_time'] ?? 0);
|
||||
$oldest = ($oldest === null) ? $arrival : min($oldest, $arrival);
|
||||
$bytes += (int)($copy['message_size'] ?? 0);
|
||||
foreach ((array)($copy['recipients'] ?? []) as $rcpt) {
|
||||
if (is_string($rcpt) && preg_match('/^\S+ \((.+)\)$/', $rcpt, $m)) {
|
||||
$reasons[$m[1]] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
$dropped = $this->state->droppedStats();
|
||||
$recent = array_values(array_filter($dropped['recent'], fn(array $d): bool => $d['time'] >= time() - self::DROPPED_WINDOW));
|
||||
$lastDelivery = null;
|
||||
foreach ($this->state->events() as $event) {
|
||||
if ($event['status'] === 'sent') {
|
||||
$lastDelivery = $event['time'];
|
||||
break;
|
||||
}
|
||||
}
|
||||
return [
|
||||
'enabled' => (int)$settings->enabled,
|
||||
'configured' => (int)$settings->canDeliver(),
|
||||
'queued' => count($copies),
|
||||
'queued_bytes' => $bytes,
|
||||
'oldest_queued' => $oldest,
|
||||
'delay_reasons' => array_slice(array_keys($reasons), 0, 5),
|
||||
'last_delivery' => $lastDelivery,
|
||||
'dropped' => $dropped['count'],
|
||||
'dropped_24h' => count($recent),
|
||||
'last_dropped' => $recent ? ['time' => $recent[0]['time'], 'reason' => $recent[0]['reason']] : null,
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* GET archive/log: deliveries, expired copies and mails not archived, newest first (admins, read-only keys included).
|
||||
*
|
||||
* @throws AccessDenied
|
||||
*/
|
||||
public function log(): array
|
||||
{
|
||||
$this->context->requireAdmin(false);
|
||||
return $this->state->events();
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user