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).

tests/imapdebug.py

@@ -0,0 +1,25 @@
+import socket
+import ssl
+
+ctx = ssl.create_default_context()
+ctx.check_hostname = False
+ctx.verify_mode = ssl.CERT_NONE
+
+raw = socket.create_connection(("127.0.0.1", 993), timeout=10)
+s = ctx.wrap_socket(raw)
+
+def recv_line():
+    buf = b""
+    while not buf.endswith(b"\r\n"):
+        buf += s.recv(1)
+    print("S:", buf)
+    return buf
+
+recv_line()
+
+def send(line):
+    print("C:", line)
+    s.sendall(line.encode() + b"\r\n")
+
+send('a1 LOGIN "barant@barant.com" "imaptest123"')
+recv_line()

tests/imapsearchdebug.py

@@ -0,0 +1,25 @@
+import imaplib, ssl
+
+ctx = ssl.create_default_context()
+ctx.check_hostname = False
+ctx.verify_mode = ssl.CERT_NONE
+
+m = imaplib.IMAP4_SSL("127.0.0.1", 993, ssl_context=ctx)
+m.login("barant@barant.com", "imaptest123")
+typ, data = m.select("INBOX")
+last = int(data[0])
+print("last seq:", last)
+
+typ, data = m.fetch(str(last), "(ENVELOPE UID)")
+print("last message envelope:", data)
+
+typ, data = m.fetch(str(last), "(BODY[])")
+print("last message body:", data)
+
+typ, data = m.search(None, "ALL")
+print("all ids:", data)
+
+typ, data = m.search(None, 'SUBJECT "test"')
+print('SUBJECT "test":', data)
+
+m.logout()

tests/imaptest.py

@@ -0,0 +1,68 @@
+import imaplib
+import ssl
+import sys
+
+HOST = "127.0.0.1"
+USER = "barant@barant.com"
+PASS = "imaptest123"
+
+ctx = ssl.create_default_context()
+ctx.check_hostname = False
+ctx.verify_mode = ssl.CERT_NONE
+
+def step(name, fn):
+    try:
+        result = fn()
+        print(f"OK   {name}: {result}")
+        return result
+    except Exception as e:
+        print(f"FAIL {name}: {e}")
+        raise
+
+m = imaplib.IMAP4_SSL(HOST, 993, ssl_context=ctx)
+print("connected:", m.welcome)
+
+step("LOGIN", lambda: m.login(USER, PASS))
+step("CAPABILITY", lambda: m.capability())
+step("LIST", lambda: m.list())
+typ, data = step("SELECT INBOX", lambda: m.select("INBOX"))
+print("  EXISTS:", data)
+
+typ, data = step("SEARCH ALL", lambda: m.search(None, "ALL"))
+ids = data[0].split()
+print(f"  {len(ids)} messages")
+
+if ids:
+    first = ids[0]
+    typ, data = step("FETCH ENVELOPE", lambda: m.fetch(first, "(ENVELOPE)"))
+    print("  ", data)
+    typ, data = step("FETCH FLAGS UID", lambda: m.fetch(first, "(FLAGS UID)"))
+    print("  ", data)
+    typ, data = step("FETCH BODY[]", lambda: m.fetch(first, "(BODY[])"))
+    print("  body length:", len(data[0][1]) if data and data[0] else 0)
+    step("STORE +FLAGS \\Flagged", lambda: m.store(first, "+FLAGS", "\\Flagged"))
+    typ, data = step("SEARCH FLAGGED", lambda: m.search(None, "FLAGGED"))
+    print("  flagged ids:", data)
+    step("STORE -FLAGS \\Flagged", lambda: m.store(first, "-FLAGS", "\\Flagged"))
+
+step("STATUS INBOX", lambda: m.status("INBOX", "(MESSAGES UIDNEXT UIDVALIDITY UNSEEN)"))
+
+# APPEND a literal message, then verify it shows up, then clean it up via COPY+EXPUNGE
+msg = b"From: test@barant.com\r\nTo: barant@barant.com\r\nSubject: IMAP APPEND test\r\n\r\nHello from APPEND.\r\n"
+typ, data = step("APPEND", lambda: m.append("INBOX", "", None, msg))
+print("  ", data)
+
+typ, data = step("SEARCH SUBJECT", lambda: m.search(None, 'SUBJECT "APPEND test"'))
+appended_ids = data[0].split()
+print("  found:", appended_ids)
+
+if appended_ids:
+    step("COPY to Trash", lambda: m.copy(appended_ids[-1], "Trash"))
+    step("STORE +FLAGS \\Deleted", lambda: m.store(appended_ids[-1], "+FLAGS", "\\Deleted"))
+    step("EXPUNGE", lambda: m.expunge())
+
+typ, data = step("SELECT Trash", lambda: m.select("Trash"))
+print("  Trash EXISTS:", data)
+
+step("LOGOUT", lambda: m.logout())
+print("ALL DONE")

tests/pop3test.py

@@ -0,0 +1,63 @@
+import poplib
+import ssl
+
+ctx = ssl.create_default_context()
+ctx.check_hostname = False
+ctx.verify_mode = ssl.CERT_NONE
+
+USER = "barant@barant.com"
+PASS = "imaptest123"
+
+def step(name, fn):
+    try:
+        result = fn()
+        print(f"OK   {name}: {result}")
+        return result
+    except Exception as e:
+        print(f"FAIL {name}: {e}")
+        raise
+
+m = poplib.POP3_SSL("127.0.0.1", 995, context=ctx)
+print("welcome:", m.getwelcome())
+
+step("USER", lambda: m.user(USER))
+step("PASS", lambda: m.pass_(PASS))
+count, size = step("STAT", lambda: m.stat())
+print(f"  {count} messages, {size} octets")
+
+resp, items, octets = step("LIST", lambda: m.list())
+print(f"  {len(items)} items, sample: {items[0] if items else None}")
+
+if count > 0:
+    resp, lines, octets = step("RETR 1", lambda: m.retr(1))
+    print(f"  {len(lines)} lines, first: {lines[0] if lines else None}")
+
+    resp, uidls, octets = step("UIDL (all)", lambda: m.uidl())
+    print(f"  sample: {uidls[0] if uidls else None}")
+
+    resp = step("UIDL 1", lambda: m.uidl(1))
+    print(f"  {resp}")
+
+    resp, lines, octets = step("TOP 1 0", lambda: m.top(1, 0))
+    print(f"  {len(lines)} lines (should be 0 body lines)")
+
+    step("DELE 1", lambda: m.dele(1))
+    count2, size2 = step("STAT (after DELE)", lambda: m.stat())
+    print(f"  {count2} messages (should be {count - 1})")
+
+    step("RSET", lambda: m.rset())
+    count3, size3 = step("STAT (after RSET)", lambda: m.stat())
+    print(f"  {count3} messages (should be back to {count})")
+
+    step("DELE 1 (again, will commit)", lambda: m.dele(1))
+
+step("QUIT", lambda: m.quit())
+print("ALL DONE")
+
+# Reconnect to confirm the DELE really committed at QUIT.
+m2 = poplib.POP3_SSL("127.0.0.1", 995, context=ctx)
+m2.user(USER)
+m2.pass_(PASS)
+count4, size4 = m2.stat()
+print(f"after reconnect: {count4} messages (should be {count - 1})")
+m2.quit()

tests/sendtest.py

@@ -0,0 +1,31 @@
+import smtplib
+import ssl
+from email.mime.text import MIMEText
+from datetime import datetime, timezone
+
+HOST = "127.0.0.1"
+PORT = 465
+USER = "barant@barant.com"
+PASS = "imaptest123"
+TO = "brad.arant@gmail.com"
+
+ctx = ssl.create_default_context()
+ctx.check_hostname = False
+ctx.verify_mode = ssl.CERT_NONE
+
+msg = MIMEText(
+    "This is a live delivery test of the new BARANTMail server "
+    "(SMTP + DKIM signing + SPF/DMARC on inbound, IMAP/POP3 now real).\n\n"
+    f"Sent at {datetime.now(timezone.utc).isoformat()}."
+)
+msg["Subject"] = "BARANTMail delivery test"
+msg["From"] = USER
+msg["To"] = TO
+
+s = smtplib.SMTP_SSL(HOST, PORT, context=ctx, timeout=20)
+s.set_debuglevel(1)
+s.ehlo("mail.barant.com")
+s.login(USER, PASS)
+s.sendmail(USER, [TO], msg.as_string())
+s.quit()
+print("SENT")

tests/smtptest.py

@@ -0,0 +1,20 @@
+import smtplib
+import sys
+import time
+
+def send(subject, body, from_addr="test@barant.com", to_addr="barant@barant.com"):
+    msg = f"From: {from_addr}\r\nTo: {to_addr}\r\nSubject: {subject}\r\n\r\n{body}\r\n"
+    s = smtplib.SMTP("127.0.0.1", 25, timeout=15)
+    s.set_debuglevel(0)
+    s.ehlo("test-client.example.com")
+    s.sendmail(from_addr, [to_addr], msg)
+    s.quit()
+
+send("Auth stack test - normal mail", "This is an ordinary test message.")
+print("sent normal message")
+
+time.sleep(1)
+
+GTUBE = "XJS*C4JDBQADN1.NSBN3*2IDNEN*GTUBE-STANDARD-ANTI-UBE-TEST-EMAIL*C.34X"
+send("Auth stack test - spam probe", GTUBE)
+print("sent GTUBE spam-probe message")

tests/stresstest.py

@@ -0,0 +1,75 @@
+import imaplib, poplib, smtplib, ssl, threading, time, random
+
+ctx = ssl.create_default_context()
+ctx.check_hostname = False
+ctx.verify_mode = ssl.CERT_NONE
+
+USER = "barant@barant.com"
+PASS = "imaptest123"
+
+errors = []
+lock = threading.Lock()
+
+def note_error(name, e):
+    with lock:
+        errors.append(f"{name}: {e}")
+
+def imap_cycle(i):
+    try:
+        m = imaplib.IMAP4_SSL("127.0.0.1", 993, ssl_context=ctx)
+        m.login(USER, PASS)
+        m.select("INBOX")
+        m.search(None, "ALL")
+        typ, data = m.fetch("1", "(FLAGS UID)")
+        m.logout()
+    except Exception as e:
+        note_error(f"imap#{i}", e)
+
+def pop3_cycle(i):
+    try:
+        m = poplib.POP3_SSL("127.0.0.1", 995, context=ctx)
+        m.user(USER)
+        m.pass_(PASS)
+        m.stat()
+        m.list()
+        m.quit()
+    except Exception as e:
+        note_error(f"pop3#{i}", e)
+
+def smtp_cycle(i):
+    try:
+        s = smtplib.SMTP("127.0.0.1", 25, timeout=10)
+        s.ehlo("stress-client")
+        msg = f"From: stress{i}@barant.com\r\nTo: barant@barant.com\r\nSubject: stress {i}\r\n\r\nstress body {i}\r\n"
+        s.sendmail(f"stress{i}@barant.com", ["barant@barant.com"], msg)
+        s.quit()
+    except Exception as e:
+        note_error(f"smtp#{i}", e)
+
+def rude_disconnect(i):
+    # Connect and drop mid-handshake / mid-command without clean close -
+    # exercises the abrupt-disconnect path specifically.
+    import socket
+    try:
+        s = socket.create_connection(("127.0.0.1", 993), timeout=5)
+        s.recv(50)
+        s.close()
+    except Exception as e:
+        note_error(f"rude#{i}", e)
+
+threads = []
+N = 40
+for i in range(N):
+    fn = random.choice([imap_cycle, pop3_cycle, smtp_cycle, rude_disconnect])
+    t = threading.Thread(target=fn, args=(i,))
+    threads.append(t)
+    t.start()
+    time.sleep(0.02)
+
+for t in threads:
+    t.join(timeout=15)
+
+print(f"Completed {N} concurrent mixed-protocol cycles.")
+print(f"Errors: {len(errors)}")
+for e in errors[:20]:
+    print(" ", e)