Add real IMAP4rev1/POP3 implementations, DKIM/DMARC/SPF, SpamAssassin delivery hook

IMAP (RFC 3501): LOGIN through UID, previously all stubs except
CAPABILITY/LOGOUT/a partial APPEND. Multi-folder support with per-folder
UID/flag indexing (new MailFolder class, backed by .uidvalidity/.uidnext/
.imapindex sidecar files), ENVELOPE support (new MessageHeaders class:
header parsing, address-list parsing, IMAP quoting), and shared
cursor-based argument parsing (new IMAPArgs class: sequence sets, flag
lists, dates, folder-name normalization, and path-traversal protection
via isValidFolderName - a bare ".." folder name would otherwise resolve
into a sibling user's mailbox directory).

POP3 (RFC 1939): USER through QUIT, previously only CAPA. Added UIDL.
POP3 handlers use cursor-based parsing throughout rather than indexed
access - ZString's copy constructor doesn't copy its `list` field, and
POP3's dispatch passes the request by value, so indexed access into a
copy was silently reading nothing.

SMTP: DMARC evaluation added to the DATA-terminator path (DKIM
verification + alignment/policy, Authentication-Results header,
conditional rejection matching RFC 7489 6.3's p=reject + sampled pct=).
AUTH LOGIN now handles RFC 4954's optional inline initial response
(e.g. Python smtplib's "AUTH LOGIN <base64>" in one line) instead of
only the exact three-line form. Outbound relay now forces IPv4
(AF_INET) instead of AF_UNSPEC - this server's IPv4 has a correct PTR
record and SPF coverage, its IPv6 doesn't, and Gmail was rejecting
outbound mail with 550 5.7.25 as a result.

Delivery pipeline: local delivery now runs the message through
SpamAssassin (new SpamAssassinFilter class, speaking spamd's PROCESS
protocol directly over a raw socket - fails open/delivers unscanned if
spamd is unreachable) instead of a plain hardlink, since scanning can
tag/modify content.

BARANTMailConfig: extracted config loading into its own class.

compile: (see individual file changes - build script adjustments to
match the above).

Deliberately excluded from this commit: barantmail.log/
barantmail-service.log (operational logs, not source - barantmail.log
in particular was the runaway 55GB/12.9GB file from a busy-loop bug
fixed separately in ServerCore) and barantmail.cfg (this server's own
live deployment config, matching how APIServer's equivalent
config also stays untracked).

MailFileSystem.cpp

@@ -2,11 +2,19 @@
 #include "MailFileSystem.h"
 # include "INotify.h"
 # include "Log.h"
+# include "File.h"
+# include <filesystem>
 
 namespace mail {
 
    MailFileSystem::MailFileSystem(coreutils::ZString &mailPath) : mailPath(mailPath) {
       queuePath << mailPath << "/.queue/";
+      sendLogPath << mailPath << "/.sendlog/";
+      // Harmless if it already exists (EEXIST is ignored, same as
+      // every other error here - a failed mkdir just means the later
+      // File open in SendMail::deliver() throws instead, which does
+      // not affect whether the message itself is delivered).
+      mkdir(sendLogPath.c_str(), 0770);
    }
 
    bool MailFileSystem::ifMailBoxExists(coreutils::ZString &mailbox) {
@@ -27,6 +35,16 @@ namespace mail {
 
    coreutils::MString MailFileSystem::getMailBoxPath(coreutils::ZString &mailbox) {
       mailbox.split("@", 1);
+      // A mailbox string with no "@" splits to a single-element list -
+      // mailbox[1] would then be an out-of-bounds std::vector access
+      // (ZString::operator[] doesn't bounds-check), not even a
+      // catchable exception. Previously unreachable with a safe input
+      // in practice; now reachable directly from a client-supplied IMAP
+      // LOGIN/POP3 USER username, so a malformed one (a bare "barant"
+      // instead of "barant@barant.com", an easy real typo) needs to
+      // fail cleanly here rather than read adjacent memory.
+      if (mailbox.getList().size() < 2)
+         return coreutils::MString();
       coreutils::MString path;
       path << mailPath << "/" << mailbox[1] << "/" << mailbox[0];
       return path;
@@ -45,4 +63,54 @@ namespace mail {
       return queuePath;
    }
 
+   coreutils::ZString& MailFileSystem::getSendLogPath() {
+      return sendLogPath;
+   }
+
+   bool MailFileSystem::checkPassword(coreutils::ZString &userName, coreutils::ZString &password) {
+      // File's constructor throws if the mailbox or its .password file
+      // doesn't exist - an unknown username needs to come back as "not
+      // authenticated", not an uncaught exception. Previously (as
+      // __SMTP_AUTH::authLogin(), before this logic moved here) this
+      // was only saved from crashing the whole process by
+      // CommandList::processRequest()'s own unrelated catch-all, which
+      // treated the exception as "could not be parsed" and silently
+      // dropped the reply entirely - a client attempting AUTH LOGIN (or
+      // now IMAP LOGIN, POP3 USER/PASS) against a nonexistent user got
+      // no response at all rather than a clean authentication failure.
+      try {
+         coreutils::MString secretPath;
+         secretPath << getMailBoxPath(userName) << "/.password";
+         coreutils::File secret(secretPath);
+         secret.read();
+         return password == secret.asZString();
+      } catch (...) {
+         return false;
+      }
+   }
+
+   coreutils::MString MailFileSystem::getFolderPath(coreutils::ZString &mailbox, std::string folder) {
+      coreutils::MString path;
+      path << getMailBoxPath(mailbox) << "/" << folder;
+      return path;
+   }
+
+   bool MailFileSystem::ifFolderExists(coreutils::ZString &mailbox, std::string folder) {
+      struct stat folderStat;
+      return stat(getFolderPath(mailbox, folder).c_str(), &folderStat) != -1 && S_ISDIR(folderStat.st_mode);
+   }
+
+   std::vector<coreutils::MString> MailFileSystem::listFolders(coreutils::ZString &mailbox) {
+      std::vector<coreutils::MString> folders;
+      std::string root = getMailBoxPath(mailbox).str();
+      if (!std::filesystem::is_directory(root))
+         return folders;
+      for (const auto &entry : std::filesystem::directory_iterator(root)) {
+         std::string name = entry.path().filename().string();
+         if (!name.empty() && name[0] != '.' && entry.is_directory())
+            folders.push_back(coreutils::MString(name));
+      }
+      return folders;
+   }
+
 }