Add authenticated domain/mailbox/alias/password admin console

Port 1027 used to be an unauthenticated console (see ServerCore's
ConsoleServer/ConsoleSession fix) that also exposed the raw SMTP
command set (AUTH/DATA/EHLO/EXPN/HELO/...) to anyone who could reach
it. It's now started only when barantmail.cfg has a real "admin"
section configured (BARANTMailConfig::hasAdmin/getAdminPort/
getAdminUser/getAdminPassword), matching the same optional-listener
pattern already used for smtpTLS/imap/pop3, and registers four real
commands instead of the SMTP command table:

  domain add|remove|list
  mailbox add|remove|list
  alias add|remove|list
  password reset

MailFileSystem gained the actual domain/mailbox/alias/password CRUD
these commands call (createDomain/removeDomain/listDomains,
createMailbox/removeMailbox/listMailboxes, createAlias/removeAlias/
listAliases, setPassword), matching its existing on-disk layout: a
domain is a directory, a mailbox is a directory with Inbox/Spam/Trash
and a .password file, an alias is a plain file listing target
mailboxes one per line.

getAliasMailboxes() was previously an unconditional stub that always
returned empty (confirmed via grep to have zero callers anywhere),
so an alias could be "created" but could never actually receive mail.
It's now wired for real: SMTPServer::inCreate() checks
ifAliasExists()/getAliasMailboxes() during local delivery and copies
the same spam-scanned message to every target mailbox (extracted into
a new deliverToMailbox() helper so the alias and single-mailbox
delivery paths share it).

MailFileSystem.cpp

@@ -4,6 +4,7 @@
 # include "Log.h"
 # include "File.h"
 # include <filesystem>
+# include <cerrno>
 
 namespace mail {
 
@@ -51,7 +52,27 @@ namespace mail {
    }
 
    std::vector<coreutils::MString> MailFileSystem::getAliasMailboxes(coreutils::ZString &alias) {
+      // Previously an unconditional stub - always returned empty,
+      // confirmed by grep to have zero callers anywhere until this
+      // change wired real aliasing into SMTPServer::inCreate() and the
+      // admin console. The file format is this class's own choice
+      // (createAlias() below writes it): one target mailbox per line.
       std::vector<coreutils::MString> returnValue;
+      coreutils::MString path = getMailBoxPath(alias);
+      try {
+         coreutils::File aliasFile(path, O_RDONLY);
+         aliasFile.read();
+         coreutils::ZString contents = aliasFile.asZString();
+         contents.split("\n");
+         for (auto &line : contents.getList()) {
+            coreutils::MString target(line);
+            if (!target.str().empty())
+               returnValue.push_back(target);
+         }
+      } catch (...) {
+         // Not a real alias (or unreadable) - caller sees an empty
+         // target list, same as before this method did anything.
+      }
       return returnValue;
    }
 
@@ -113,4 +134,194 @@ namespace mail {
       return folders;
    }
 
+   bool MailFileSystem::createDomain(coreutils::ZString &domain, std::string &error) {
+      coreutils::MString path;
+      path << mailPath << "/" << domain;
+      if (mkdir(path.c_str(), 0770) == -1 && errno != EEXIST) {
+         error = "could not create domain directory";
+         return false;
+      }
+      return true;
+   }
+
+   bool MailFileSystem::removeDomain(coreutils::ZString &domain, std::string &error) {
+      coreutils::MString path;
+      path << mailPath << "/" << domain;
+      if (!std::filesystem::is_directory(path.str())) {
+         error = "domain does not exist";
+         return false;
+      }
+      // Refuse rather than cascade-delete every mailbox/alias under a
+      // domain silently - the admin has to clear those first, same
+      // spirit as removeMailbox() not being implicitly called from here.
+      for (const auto &entry : std::filesystem::directory_iterator(path.str())) {
+         std::string name = entry.path().filename().string();
+         if (!name.empty() && name[0] != '.') {
+            error = "domain still has mailboxes or aliases - remove those first";
+            return false;
+         }
+      }
+      std::error_code ec;
+      std::filesystem::remove_all(path.str(), ec);
+      if (ec) {
+         error = "could not remove domain directory";
+         return false;
+      }
+      return true;
+   }
+
+   std::vector<coreutils::MString> MailFileSystem::listDomains() {
+      std::vector<coreutils::MString> domains;
+      std::string root = mailPath.str();
+      if (!std::filesystem::is_directory(root))
+         return domains;
+      for (const auto &entry : std::filesystem::directory_iterator(root)) {
+         std::string name = entry.path().filename().string();
+         if (!name.empty() && name[0] != '.' && entry.is_directory())
+            domains.push_back(coreutils::MString(name));
+      }
+      return domains;
+   }
+
+   bool MailFileSystem::createMailbox(coreutils::ZString &mailbox, coreutils::ZString &password, std::string &error) {
+      mailbox.split("@", 1);
+      if (mailbox.getList().size() < 2) {
+         error = "mailbox must be in the form user@domain";
+         return false;
+      }
+      coreutils::MString domainPath;
+      domainPath << mailPath << "/" << mailbox[1];
+      if (!std::filesystem::is_directory(domainPath.str())) {
+         error = "domain does not exist: " + mailbox[1].str();
+         return false;
+      }
+      coreutils::MString path = getMailBoxPath(mailbox);
+      if (std::filesystem::exists(path.str())) {
+         error = "a mailbox or alias already exists at that address";
+         return false;
+      }
+      if (mkdir(path.c_str(), 0770) == -1) {
+         error = "could not create mailbox directory";
+         return false;
+      }
+      for (std::string folder : {"Inbox", "Spam", "Trash"}) {
+         coreutils::MString folderPath;
+         folderPath << path << "/" << folder;
+         mkdir(folderPath.c_str(), 0770);
+      }
+      coreutils::MString passwordPath;
+      passwordPath << path << "/.password";
+      try {
+         coreutils::File secret(passwordPath, O_CREAT | O_WRONLY | O_TRUNC, 0660);
+         secret.write(password.str());
+      } catch (...) {
+         error = "could not write password file";
+         return false;
+      }
+      return true;
+   }
+
+   bool MailFileSystem::removeMailbox(coreutils::ZString &mailbox, std::string &error) {
+      if (!ifMailBoxExists(mailbox)) {
+         error = "mailbox does not exist";
+         return false;
+      }
+      coreutils::MString path = getMailBoxPath(mailbox);
+      std::error_code ec;
+      std::filesystem::remove_all(path.str(), ec);
+      if (ec) {
+         error = "could not remove mailbox";
+         return false;
+      }
+      return true;
+   }
+
+   std::vector<coreutils::MString> MailFileSystem::listMailboxes(coreutils::ZString &domain) {
+      std::vector<coreutils::MString> mailboxes;
+      coreutils::MString root;
+      root << mailPath << "/" << domain;
+      if (!std::filesystem::is_directory(root.str()))
+         return mailboxes;
+      for (const auto &entry : std::filesystem::directory_iterator(root.str())) {
+         std::string name = entry.path().filename().string();
+         if (!name.empty() && name[0] != '.' && entry.is_directory())
+            mailboxes.push_back(coreutils::MString(name));
+      }
+      return mailboxes;
+   }
+
+   bool MailFileSystem::createAlias(coreutils::ZString &alias, coreutils::ZString &targets, std::string &error) {
+      if (ifMailBoxExists(alias)) {
+         error = "a mailbox already exists at that address";
+         return false;
+      }
+      coreutils::MString path = getMailBoxPath(alias);
+      if (path.str().empty()) {
+         error = "alias must be in the form user@domain";
+         return false;
+      }
+      // Accept either comma- or whitespace-separated targets from the
+      // console command line - normalized here to one per line, which
+      // is this class's own on-disk format (see getAliasMailboxes()).
+      targets.split(",");
+      coreutils::MString contents;
+      for (auto &target : targets.getList()) {
+         coreutils::MString trimmed(target);
+         if (!trimmed.str().empty())
+            contents << trimmed << "\n";
+      }
+      try {
+         coreutils::File aliasFile(path, O_CREAT | O_WRONLY | O_TRUNC, 0660);
+         aliasFile.write(contents.str());
+      } catch (...) {
+         error = "could not write alias file";
+         return false;
+      }
+      return true;
+   }
+
+   bool MailFileSystem::removeAlias(coreutils::ZString &alias, std::string &error) {
+      if (!ifAliasExists(alias)) {
+         error = "alias does not exist";
+         return false;
+      }
+      coreutils::MString path = getMailBoxPath(alias);
+      if (unlink(path.c_str()) == -1) {
+         error = "could not remove alias file";
+         return false;
+      }
+      return true;
+   }
+
+   std::vector<coreutils::MString> MailFileSystem::listAliases(coreutils::ZString &domain) {
+      std::vector<coreutils::MString> aliases;
+      coreutils::MString root;
+      root << mailPath << "/" << domain;
+      if (!std::filesystem::is_directory(root.str()))
+         return aliases;
+      for (const auto &entry : std::filesystem::directory_iterator(root.str())) {
+         std::string name = entry.path().filename().string();
+         if (!name.empty() && name[0] != '.' && entry.is_regular_file())
+            aliases.push_back(coreutils::MString(name));
+      }
+      return aliases;
+   }
+
+   bool MailFileSystem::setPassword(coreutils::ZString &mailbox, coreutils::ZString &newPassword, std::string &error) {
+      if (!ifMailBoxExists(mailbox)) {
+         error = "mailbox does not exist";
+         return false;
+      }
+      coreutils::MString path;
+      path << getMailBoxPath(mailbox) << "/.password";
+      try {
+         coreutils::File secret(path, O_CREAT | O_WRONLY | O_TRUNC, 0660);
+         secret.write(newPassword.str());
+      } catch (...) {
+         error = "could not write password file";
+         return false;
+      }
+      return true;
+   }
+
 }