Give mail delivery its own admin page and move the origin probe off /.well-known

The mail page under System tries SMTP, PHP mail() and both sendmail
modes one by one or all at once, and saves the chosen way to .env
without ever showing the password. IONOS answers everything under
/.well-known/ itself with 403, so the address and HTTPS checks never
reached the installation; the probe now lives at /kantsites-origin
(ADR 122).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/Controller/MailController.php

@@ -0,0 +1,188 @@
+<?php
+
+namespace App\Controller;
+
+use App\Ops\Environment;
+use App\Ops\MailCheck;
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Mime\Address;
+use Symfony\Component\Mime\Email;
+use Symfony\Component\Routing\Attribute\Route;
+
+/**
+ * E-Mail-Versand (ADR 121, 122): eigene Seite unter „System“, damit die Systemseite nicht alles
+ * trägt. Weg wählen, ausprobieren, alle Wege des Servers testen, speichern - und die letzten
+ * Versuche mit Ursache.
+ */
+final class MailController extends AbstractController
+{
+    public function __construct(private MailCheck $mail, private string $projectDir, private string $siteOrigin)
+    {
+    }
+
+    #[Route('/%kant.admin_path%/system/e-mail', name: 'admin_mail', methods: ['GET'])]
+    public function index(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        $session = $request->getSession();
+
+        return $this->render('admin/mail.html.twig', [
+            'mail' => $this->mailFacts(),
+            'mailResult' => $session->remove('mail_result'),
+            'mailResults' => $session->remove('mail_results'),
+            'mailNotice' => $session->remove('mail_notice'),
+            // Die letzte Eingabe bleibt stehen, ohne Passwort.
+            'mailForm' => $session->remove('mail_form'),
+        ]);
+    }
+
+    /**
+     * Versand einstellen und ausprobieren (ADR 121, 122): ein Weg testen, alle Wege des Servers
+     * nacheinander testen, oder den gewählten Weg als MAILER_DSN in .env speichern.
+     *
+     * Das SMTP-Passwort steht nie im Formular. Bleibt das Feld leer, gilt das gespeicherte, solange
+     * Server und Benutzer gleich bleiben.
+     */
+    #[Route('/%kant.admin_path%/system/e-mail', name: 'admin_mail_save', methods: ['POST'])]
+    public function save(Request $request): Response
+    {
+        $this->denyAccessUnlessGranted('ROLE_ADMIN');
+        $session = $request->getSession();
+        if (!$this->isCsrfTokenValid('system', $request->request->getString('_csrf_token'))) {
+            return $this->backToMail($request, 'Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
+        }
+        $eingabe = [
+            'weg' => $request->request->getString('weg'),
+            'server' => trim($request->request->getString('server')),
+            'port' => $request->request->getInt('port', 587),
+            'benutzer' => trim($request->request->getString('benutzer')),
+            'an' => trim($request->request->getString('to')),
+            'von' => trim($request->request->getString('from')),
+        ];
+        $session->set('mail_form', $eingabe);
+        $aktion = $request->request->getString('aktion');
+
+        if ('alle' === $aktion) {
+            if (null !== $fehler = $this->mailAdressFehler($eingabe)) {
+                return $this->backToMail($request, $fehler);
+            }
+            $wege = array_map(static fn (array $weg): string => $weg['dsn'], MailCheck::serverWege());
+            if ('' !== $eingabe['server']) {
+                try {
+                    $wege['smtp'] = $this->smtpDsn($request, $eingabe);
+                } catch (\InvalidArgumentException) {
+                    // Unvollständiges SMTP bleibt bei „alle“ einfach draußen.
+                }
+            }
+            $ergebnisse = [];
+            foreach ($wege as $schluessel => $dsn) {
+                $ergebnisse[] = ['schluessel' => $schluessel] + $this->mail->send($this->testEmail($request, $eingabe), 'Testmail (alle Wege)', $dsn);
+            }
+            $session->set('mail_results', $ergebnisse);
+
+            return $this->backToMail($request);
+        }
+
+        try {
+            $dsn = isset(MailCheck::serverWege()[$eingabe['weg']]) ? MailCheck::serverWege()[$eingabe['weg']]['dsn'] : $this->smtpDsn($request, $eingabe);
+        } catch (\InvalidArgumentException $fehler) {
+            return $this->backToMail($request, $fehler->getMessage());
+        }
+
+        if ('speichern' === $aktion) {
+            if ('.env' !== $this->environmentSource('MAILER_DSN')) {
+                return $this->backToMail($request, 'MAILER_DSN ist in der Server-Umgebung gesetzt und hat dort Vorrang. Ändern lässt sie sich nur beim Hoster.');
+            }
+            try {
+                Environment::write($this->projectDir, ['MAILER_DSN' => $dsn]);
+            } catch (\RuntimeException $fehler) {
+                return $this->backToMail($request, $fehler->getMessage());
+            }
+            $weg = $this->mail->route($dsn);
+
+            return $this->backToMail($request, sprintf('Gespeichert: %s%s. Formulare versenden ab jetzt auf diesem Weg.', $weg['art'], '' !== $weg['ziel'] ? ' über '.$weg['ziel'] : ''), 'ok');
+        }
+
+        if (null !== $fehler = $this->mailAdressFehler($eingabe)) {
+            return $this->backToMail($request, $fehler);
+        }
+        $session->set('mail_result', ['an' => $eingabe['an']] + $this->mail->send($this->testEmail($request, $eingabe), 'Testmail', $dsn));
+
+        return $this->backToMail($request);
+    }
+
+    /** @param array{an: string, von: string} $eingabe */
+    private function mailAdressFehler(array $eingabe): ?string
+    {
+        foreach ([$eingabe['an'], $eingabe['von'] ?: $eingabe['an']] as $adresse) {
+            if (false === filter_var($adresse, FILTER_VALIDATE_EMAIL)) {
+                return '' === $adresse ? 'Für eine Testmail bitte eine Empfängeradresse eintragen.' : sprintf('„%s“ ist keine gültige E-Mail-Adresse.', mb_substr($adresse, 0, 100));
+            }
+        }
+
+        return null;
+    }
+
+    /** @param array{server: string, port: int, benutzer: string} $eingabe */
+    private function smtpDsn(Request $request, array $eingabe): string
+    {
+        if ('' === $eingabe['server']) {
+            throw new \InvalidArgumentException('Für SMTP bitte den Server eintragen, etwa smtp.ionos.de.');
+        }
+        $passwort = $request->request->getString('passwort');
+        if ('' === $passwort) {
+            $passwort = $this->mail->gespeichertesPasswort($eingabe['server'], $eingabe['benutzer']);
+        }
+        if ('' !== $eingabe['benutzer'] && '' === $passwort) {
+            throw new \InvalidArgumentException('Für SMTP bitte das Passwort des Postfachs eintragen.');
+        }
+
+        return MailCheck::smtpDsn($eingabe['server'], $eingabe['port'], $eingabe['benutzer'], $passwort);
+    }
+
+    /** @param array{an: string, von: string} $eingabe */
+    private function testEmail(Request $request, array $eingabe): Email
+    {
+        $website = rtrim($this->siteOrigin, '/') ?: $request->getSchemeAndHttpHost();
+
+        return (new Email())
+            ->from(new Address($eingabe['von'] ?: $eingabe['an']))
+            ->to(new Address($eingabe['an']))
+            ->subject('Testmail von '.(parse_url($website, PHP_URL_HOST) ?: $website))
+            ->text("Diese Testmail kommt aus der Verwaltung von {$website} (System → E-Mail-Versand).\n\nWenn sie angekommen ist, funktioniert der Versand der Formulare auf diesem Weg.\n");
+    }
+
+    private function backToMail(Request $request, ?string $meldung = null, string $art = 'error'): Response
+    {
+        if (null !== $meldung) {
+            $request->getSession()->set('mail_notice', ['art' => $art, 'text' => $meldung]);
+        }
+
+        return $this->redirect($this->generateUrl('admin_mail'));
+    }
+
+    /** @return array<string, mixed> */
+    private function mailFacts(): array
+    {
+        $route = $this->mail->route();
+
+        return $route + [
+            'einstellung' => $this->mail->einstellung(),
+            'wege' => MailCheck::serverWege(),
+            'quelle' => $this->environmentSource('MAILER_DSN'),
+            // Wer sich mit einer Adresse anmeldet, versendet meist auch nur unter ihr.
+            'absender' => false !== filter_var($route['benutzer'], FILTER_VALIDATE_EMAIL) ? $route['benutzer'] : '',
+            'protokoll' => $this->mail->recent(),
+        ];
+    }
+
+    /** Explicit server values take precedence over the single installation file. */
+    private function environmentSource(string $name): string
+    {
+        $loaded = explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? '');
+
+        return in_array($name, $loaded, true) ? '.env' : 'Server-Umgebung';
+    }
+}

src/Controller/SystemController.php

@@ -11,7 +11,6 @@ use App\Ops\Backup;
 use App\Ops\Environment;
 use App\Ops\HttpsRedirect;
 use App\Ops\Installation;
-use App\Ops\MailCheck;
 use App\Ops\OriginCheck;
 use App\Ops\SitePackage;
 use App\Ops\Updater;
@@ -20,8 +19,6 @@ use Symfony\Component\HttpFoundation\JsonResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\HttpKernelInterface;
-use Symfony\Component\Mime\Address;
-use Symfony\Component\Mime\Email;
 use Symfony\Component\Routing\Attribute\Route;
 
 /**
@@ -33,7 +30,7 @@ use Symfony\Component\Routing\Attribute\Route;
  */
 final class SystemController extends AbstractController
 {
-    public function __construct(private Updater $updater, private Backup $backup, private ArchiveUpdate $archive, private Installation $installation, private string $adminPath, private string $databaseUrl, private string $mediaDirectory, private string $projectDir, private string $siteOrigin, private OriginCheck $originCheck, private HttpKernelInterface $kernel, private PageRepository $pages, private SiteSettings $settings, private SitePackage $packages, private HttpsRedirect $https, private MailCheck $mail)
+    public function __construct(private Updater $updater, private Backup $backup, private ArchiveUpdate $archive, private Installation $installation, private string $adminPath, private string $databaseUrl, private string $mediaDirectory, private string $projectDir, private string $siteOrigin, private OriginCheck $originCheck, private HttpKernelInterface $kernel, private PageRepository $pages, private SiteSettings $settings, private SitePackage $packages, private HttpsRedirect $https)
     {
     }
 
@@ -74,9 +71,6 @@ final class SystemController extends AbstractController
             // HTTPS erzwingen und HSTS (ADR 120): der Stand in public/.htaccess.
             'https' => $this->https->state(),
             'secure' => $request->isSecure(),
-            // E-Mail-Versand (ADR 121): Weg ohne Passwort, Testmail, die letzten Versuche.
-            'mail' => $this->mailFacts(),
-            'mailResult' => $request->getSession()->remove('mail_result'),
         ]);
     }
 
@@ -526,51 +520,6 @@ final class SystemController extends AbstractController
         return $this->back($result['message'], $result['ok'] ? 'success' : 'error');
     }
 
-    /**
-     * Eine Testmail an eine frei eingetragene Adresse (ADR 121). Das Ergebnis - Meldung, Hinweis,
-     * Antworten des Servers - steht danach auf der Seite und in var/log/mail.log.
-     */
-    #[Route('/%kant.admin_path%/system/testmail', name: 'admin_system_testmail', methods: ['POST'])]
-    public function testMail(Request $request): Response
-    {
-        $this->denyAccessUnlessGranted('ROLE_ADMIN');
-        if (!$this->isCsrfTokenValid('system', $request->request->getString('_csrf_token'))) {
-            return $this->back('Deine Sitzung ist abgelaufen. Bitte melde dich erneut an.');
-        }
-        $an = trim($request->request->getString('to'));
-        $von = trim($request->request->getString('from')) ?: $an;
-        foreach ([$an, $von] as $adresse) {
-            if (false === filter_var($adresse, FILTER_VALIDATE_EMAIL)) {
-                return $this->back(sprintf('„%s“ ist keine gültige E-Mail-Adresse.', mb_substr($adresse, 0, 100)));
-            }
-        }
-        $website = rtrim($this->siteOrigin, '/') ?: $request->getSchemeAndHttpHost();
-        $email = (new Email())
-            ->from(new Address($von))
-            ->to(new Address($an))
-            ->subject('Testmail von '.(parse_url($website, PHP_URL_HOST) ?: $website))
-            ->text("Diese Testmail kommt aus der Verwaltung von {$website} (System → E-Mail-Versand).
-
-Wenn sie angekommen ist, funktioniert der Versand der Formulare auf demselben Weg.
-");
-        $request->getSession()->set('mail_result', ['an' => $an, 'von' => $von] + $this->mail->send($email, 'Testmail'));
-
-        return $this->redirect($this->generateUrl('admin_system').'#mail');
-    }
-
-    /** @return array<string, mixed> */
-    private function mailFacts(): array
-    {
-        $route = $this->mail->route();
-
-        return $route + [
-            'quelle' => $this->environmentSource('MAILER_DSN'),
-            // Wer sich mit einer Adresse anmeldet, versendet meist auch nur unter ihr.
-            'absender' => false !== filter_var($route['benutzer'], FILTER_VALIDATE_EMAIL) ? $route['benutzer'] : '',
-            'protokoll' => $this->mail->recent(),
-        ];
-    }
-
     /** Die Gegenstelle zur Prüfung oben: öffentlich, und sie verrät nichts als diese Kennung. */
     #[Route(OriginCheck::PATH, name: 'site_origin_probe', methods: ['GET'], priority: 10)]
     public function originProbe(): Response

src/EventSubscriber/MaintenanceSubscriber.php

@@ -35,7 +35,7 @@ final class MaintenanceSubscriber implements EventSubscriberInterface
             return;
         }
         $path = $event->getRequest()->getPathInfo();
-        if (preg_match('#^/('.preg_quote($this->adminPath, '#').'|assets/|media/|favicon|\.well-known/kantsites-origin)#', $path)) {
+        if (preg_match('#^/('.preg_quote($this->adminPath, '#').'|assets/|media/|favicon|kantsites-origin$)#', $path)) {
             return;
         }
         $since = @file_get_contents($this->projectDir.'/'.Updater::MAINTENANCE_FILE);

src/Ops/MailCheck.php

@@ -4,6 +4,7 @@ namespace App\Ops;
 
 use Symfony\Component\DependencyInjection\Attribute\Autowire;
 use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
+use Symfony\Component\Mailer\Transport;
 use Symfony\Component\Mailer\Transport\Dsn;
 use Symfony\Component\Mailer\Transport\TransportInterface;
 use Symfony\Component\Mime\Email;
@@ -30,32 +31,118 @@ final class MailCheck
      * Der Transport erst beim ersten Versand: Eine ungültige MAILER_DSN soll den Versand scheitern
      * lassen und im Protokoll stehen, nicht schon die Seite, die ihn anbietet.
      */
-    public function __construct(#[Autowire(service: 'mailer.transports', lazy: true)] private TransportInterface $transport, private string $dsn, private string $logFile)
+    /** Baut einen Transport aus einer DSN, die (noch) nicht eingestellt ist - zum Ausprobieren. */
+    private \Closure $fabrik;
+
+    public function __construct(#[Autowire(service: 'mailer.transports', lazy: true)] private TransportInterface $transport, private string $dsn, private string $logFile, ?\Closure $fabrik = null)
     {
+        $this->fabrik = $fabrik ?? static fn (string $dsn): TransportInterface => Transport::fromDsn($dsn);
+    }
+
+    /**
+     * Die Wege, die ein gewöhnliches Hosting ohne Zugangsdaten anbietet (ADR 122). Bei IONOS etwa
+     * scheitert sendmail -bs, mail() geht.
+     *
+     * @return array<string, array{label: string, dsn: string}>
+     */
+    public static function serverWege(): array
+    {
+        return [
+            'native' => ['label' => 'PHP mail() des Servers', 'dsn' => 'native://default'],
+            'sendmail-t' => ['label' => 'sendmail -t des Servers', 'dsn' => 'sendmail://default?command=/usr/sbin/sendmail%20-t%20-i'],
+            'sendmail-bs' => ['label' => 'sendmail -bs des Servers', 'dsn' => 'sendmail://default'],
+        ];
+    }
+
+    /** smtp://… aus Einzelfeldern; Benutzer und Passwort URL-kodiert. Port 465 heißt smtps. */
+    public static function smtpDsn(string $server, int $port, string $benutzer, string $passwort): string
+    {
+        $server = trim($server);
+        if (1 !== preg_match('/^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/iD', $server)) {
+            throw new \InvalidArgumentException('Der SMTP-Server ist kein gültiger Rechnername, etwa smtp.ionos.de.');
+        }
+        if ($port < 1 || $port > 65535) {
+            throw new \InvalidArgumentException('Der Port muss zwischen 1 und 65535 liegen, meist 587.');
+        }
+        $anmeldung = '' === $benutzer ? '' : rawurlencode($benutzer).('' === $passwort ? '' : ':'.rawurlencode($passwort)).'@';
+
+        return (465 === $port ? 'smtps' : 'smtp').'://'.$anmeldung.strtolower($server).':'.$port;
+    }
+
+    /**
+     * Die aktuelle Einstellung zum Vorbelegen der Felder - ohne Passwort, nur ob es eins gibt.
+     *
+     * @return array{weg: string, server: string, port: int, benutzer: string, passwort: bool}
+     */
+    public function einstellung(): array
+    {
+        $leer = ['weg' => 'smtp', 'server' => '', 'port' => 587, 'benutzer' => '', 'passwort' => false];
+        foreach (self::serverWege() as $schluessel => $weg) {
+            if ($weg['dsn'] === $this->dsn) {
+                return ['weg' => $schluessel] + $leer;
+            }
+        }
+        try {
+            $dsn = Dsn::fromString($this->dsn);
+        } catch (\Throwable) {
+            return $leer;
+        }
+        if (!in_array($dsn->getScheme(), ['smtp', 'smtps'], true)) {
+            return ['weg' => 'native' === $dsn->getScheme() ? 'native' : ('sendmail' === $dsn->getScheme() ? 'sendmail-bs' : 'smtp')] + $leer;
+        }
+
+        return [
+            'weg' => 'smtp',
+            'server' => $dsn->getHost(),
+            'port' => $dsn->getPort() ?? ('smtps' === $dsn->getScheme() ? 465 : 587),
+            'benutzer' => (string) $dsn->getUser(),
+            'passwort' => '' !== (string) $dsn->getPassword(),
+        ];
+    }
+
+    /** Das gespeicherte SMTP-Passwort, wenn Server und Benutzer gleich bleiben - sonst leer. */
+    public function gespeichertesPasswort(string $server, string $benutzer): string
+    {
+        try {
+            $dsn = Dsn::fromString($this->dsn);
+        } catch (\Throwable) {
+            return '';
+        }
+        if (!in_array($dsn->getScheme(), ['smtp', 'smtps'], true) || strtolower($dsn->getHost()) !== strtolower(trim($server)) || (string) $dsn->getUser() !== $benutzer) {
+            return '';
+        }
+
+        return (string) $dsn->getPassword();
     }
 
     /**
      * Schickt die Nachricht und hält das Ergebnis fest. Wirft nie - ein kaputter Versand darf
      * keine Anfrage und keine Seite kosten.
      *
-     * @return array{ok: bool, meldung: string, hinweis: string, dialog: string}
+     * Mit $dsn geht der Versand über diesen Weg statt über den eingestellten - zum Ausprobieren
+     * vor dem Speichern.
+     *
+     * @return array{ok: bool, meldung: string, hinweis: string, dialog: string, weg: string}
      */
-    public function send(Email $email, string $anlass): array
+    public function send(Email $email, string $anlass, ?string $dsn = null): array
     {
         $an = implode(', ', array_map(static fn ($adresse): string => $adresse->getAddress(), $email->getTo()));
+        $scheme = self::schemeVon($dsn ?? $this->dsn);
         try {
-            $gesendet = $this->transport->send($email);
+            // Derselbe Weg wie eingestellt: der Transport des Frameworks, samt seinen Ereignissen.
+            $transport = null === $dsn || $dsn === $this->dsn ? $this->transport : ($this->fabrik)($dsn);
+            $gesendet = $transport->send($email);
             $ergebnis = [
                 'ok' => true,
                 'meldung' => 'Vom Mailserver angenommen.',
-                'hinweis' => self::hinweisNachErfolg($this->scheme()),
+                'hinweis' => self::hinweisNachErfolg($scheme),
                 'dialog' => self::dialog((string) $gesendet?->getDebug()),
             ];
         } catch (TransportExceptionInterface $fehler) {
             $ergebnis = [
                 'ok' => false,
                 'meldung' => self::einzeilig($fehler->getMessage()),
-                'hinweis' => self::hinweis($fehler->getMessage(), $this->scheme()),
+                'hinweis' => self::hinweis($fehler->getMessage(), $scheme),
                 'dialog' => self::dialog($fehler->getDebug()),
             ];
         } catch (\Throwable $fehler) {
@@ -63,10 +150,12 @@ final class MailCheck
             $ergebnis = [
                 'ok' => false,
                 'meldung' => self::einzeilig($fehler->getMessage()),
-                'hinweis' => self::hinweis($fehler->getMessage(), $this->scheme()),
+                'hinweis' => self::hinweis($fehler->getMessage(), $scheme),
                 'dialog' => '',
             ];
         }
+        $weg = $this->route($dsn);
+        $ergebnis['weg'] = trim($weg['art'].' '.$weg['ziel']);
         $this->protokollieren(['zeit' => gmdate('Y-m-d H:i:s'), 'anlass' => $anlass, 'an' => $an, 'von' => $email->getFrom()[0]?->getAddress() ?? ''] + $ergebnis);
 
         return $ergebnis;
@@ -77,16 +166,16 @@ final class MailCheck
      *
      * @return array{art: string, ziel: string, benutzer: string, gueltig: bool}
      */
-    public function route(): array
+    public function route(?string $roh = null): array
     {
         try {
-            $dsn = Dsn::fromString($this->dsn);
+            $dsn = Dsn::fromString($roh ?? $this->dsn);
         } catch (\Throwable) {
             return ['art' => 'ungültig', 'ziel' => '', 'benutzer' => '', 'gueltig' => false];
         }
         $art = match ($dsn->getScheme()) {
             'smtp', 'smtps' => 'SMTP',
-            'sendmail', 'sendmail+smtp' => 'sendmail des Servers',
+            'sendmail', 'sendmail+smtp' => str_contains((string) $dsn->getOption('command'), ' -t') ? 'sendmail -t des Servers' : 'sendmail -bs des Servers',
             'native' => 'PHP mail() des Servers',
             'null' => 'kein Versand (null)',
             default => $dsn->getScheme(),
@@ -135,11 +224,12 @@ final class MailCheck
 
         return match (true) {
             'null' === $scheme => 'MAILER_DSN steht auf null://null - es wird gar nichts verschickt.',
-            (str_contains($m, 'dsn') && (str_contains($m, 'invalid') || str_contains($m, 'malformed') || str_contains($m, 'must contain'))) || (str_contains($m, 'scheme') && str_contains($m, 'not supported')) => 'MAILER_DSN in .env ist ungültig. Form: smtp://benutzer:passwort@server:587 - @ und Sonderzeichen in Benutzer und Passwort URL-kodiert (@ → %40, # → %23, / → %2F, % → %25).',
+            (str_contains($m, 'dsn') && (str_contains($m, 'invalid') || str_contains($m, 'malformed') || str_contains($m, 'must contain'))) || (str_contains($m, 'scheme') && str_contains($m, 'not supported')) => 'Die Einstellung des Versands ist ungültig. Unter System → E-Mail-Versand neu setzen.',
             str_contains($m, '535') || str_contains($m, 'authenticat') => 'Der Mailserver lehnt die Anmeldung ab. Benutzer (die volle Adresse) und Passwort prüfen; Sonderzeichen im Passwort URL-kodieren (# → %23, / → %2F, % → %25, @ → %40). Bei Microsoft 365 muss für das Postfach „Authentifiziertes SMTP“ eingeschaltet sein.',
             str_contains($m, 'connection could not be established') || str_contains($m, 'connection refused') || str_contains($m, 'timed out') || str_contains($m, 'getaddrinfo') || str_contains($m, 'unable to connect') => 'Der Mailserver ist von hier aus nicht erreichbar. Servername und Port prüfen (meist 587); manche Hoster sperren ausgehende Verbindungen auf bestimmten Ports.',
             str_contains($m, 'certificate') || str_contains($m, 'ssl') || str_contains($m, 'tls') => 'Die verschlüsselte Verbindung kam nicht zustande. Port 587 nutzt STARTTLS, Port 465 braucht smtps:// - Port und Schema müssen zusammenpassen, und der Servername muss zum Zertifikat passen.',
-            str_contains($scheme, 'sendmail') => 'sendmail ist auf diesem Server so nicht nutzbar. Besser über SMTP mit einem echten Postfach versenden: MAILER_DSN=smtp://benutzer:passwort@server:587 in .env.',
+            str_contains($m, 'sender address is not allowed') || str_contains($m, 'envelope from address') => 'Der Server lehnt den Absender ab. Beim Versand über den Server (mail(), sendmail) muss der Absender zu einer eigenen Domain beim Hoster gehören, nicht etwa Gmail; bei SMTP ist es meist genau das angemeldete Postfach.',
+            str_contains($scheme, 'sendmail') => 'sendmail ist auf diesem Server so nicht nutzbar. Zuerst „PHP mail() des Servers“ probieren, dauerhaft besser SMTP mit einem echten Postfach.',
             1 === preg_match('/\b55[0-4]\b/', $m) || str_contains($m, 'sender') || str_contains($m, 'relay') => 'Der Mailserver nimmt Absender oder Empfänger nicht an. Der Absender muss meist genau das Postfach sein, mit dem angemeldet wird.',
             default => '',
         };
@@ -171,10 +261,10 @@ final class MailCheck
         return implode("\n", array_slice($zeilen, -12));
     }
 
-    private function scheme(): string
+    private static function schemeVon(string $roh): string
     {
         try {
-            return Dsn::fromString($this->dsn)->getScheme();
+            return Dsn::fromString($roh)->getScheme();
         } catch (\Throwable) {
             return '';
         }

src/Ops/OriginCheck.php

@@ -13,7 +13,11 @@ namespace App\Ops;
  */
 class OriginCheck
 {
-    public const PATH = '/.well-known/kantsites-origin';
+    /**
+     * Bewusst nicht unter /.well-known/: IONOS beantwortet alles darunter selbst mit 403, bevor
+     * die Anfrage die Installation erreicht (huefner-gartenbau.de, 12.10.2026, ADR 122).
+     */
+    public const PATH = '/kantsites-origin';
 
     private Download $download;