#ifndef __SMTPServer_h__ # define __SMTPServer_h__ # include # include # include # include # include "EPoll.h" # include "TCPServer.h" # include "TLSInfo.h" # include "SMTPSession.h" # include "MailFileSystem.h" # include "__SMTP_AUTH.h" # include "__SMTP_DATA.h" # include "__SMTP_EHLO.h" # include "__SMTP_EXPN.h" # include "__SMTP_HELO.h" # include "__SMTP_HELP.h" # include "__SMTP_MAIL.h" # include "__SMTP_NOOP.h" # include "__SMTP_QUIT.h" # include "__SMTP_RCPT.h" # include "__SMTP_RSET.h" # include "__SMTP_STARTTLS.h" # include "__SMTP_VRFY.h" # include "INotify.h" # include "SendMail.h" # include "DKIMSigner.h" # include "SpamAssassinFilter.h" namespace mail { class SMTPServer : public core::TCPServer, public core::INotify { public: // watchQueue controls whether this instance watches the mail // queue directory and relays/delivers what lands in it - true by // default for the ordinary single-listener case. Running a // second SMTPServer for a submission/TLS port alongside the // plaintext one needs watchQueue=false on exactly one of the two: // each SMTPServer's own INotify watch is independent, so two // watchers on the same directory would each fire inCreate() for // every queued message, delivering it twice. // dkimSigners is optional (nullptr = outbound mail goes out // unsigned for every domain) and not owned - passed straight // through to every SendMail this instance's inCreate() constructs // for outbound relay, which picks the entry matching each // individual message's own sender domain (see SendMail's own doc // comment). SMTPServer(core::EPoll &ePoll, std::string hostName, MailFileSystem &mailFileSystem, core::IPAddress ipAddress, core::TLSInfo *tlsInfo, bool watchQueue = true, std::map *dkimSigners = nullptr); MailFileSystem &mailFileSystem; std::string hostName; core::EPoll &ePoll; std::map *dkimSigners; // Advertised via EHLO's "250-SIZE " and enforced by __SMTP_DATA // while accumulating a message body - RFC 1870. 25MB, matching // the limit most real providers (e.g. Gmail) use. static const size_t maxMessageSize = 25 * 1024 * 1024; // RFC 5321 4.5.3.1.8 requires accepting at least 100 recipients per // transaction; past this many, RCPT gets 452 4.5.3 and the client // sends the rest in another transaction. static const size_t maxRecipients = 1000; SMTPSession * getSocketAccept(core::EPoll &ePoll) override; void sessionErrorHandler(std::string errorString, std::stringstream &out); /// /// When true (the default) and the session can be encrypted (it is /// already, or STARTTLS is available), AUTH is offered and accepted /// only once the session is encrypted, so mailbox passwords never /// cross the network in clear (RFC 4954 4 and 14). With no TLS /// certificate loaded at all, AUTH stays available in clear rather /// than locking mail clients out. /// bool requireTLSForAuth = true; bool authAllowed(SMTPSession &session) { return session.isTLS() || (!startTLSContext && !ctx) || !requireTLSForAuth; } /// /// True if `domain` (lower case) is one this server holds mailboxes /// for - i.e. a domain directory exists under the mail path. /// bool isLocalDomain(const std::string &domain); /// /// Where mail for the bare "postmaster" address goes (RFC 5321 4.5.1: /// it MUST be accepted, with or without a domain). postmaster@ the /// server's own host name if that mailbox or alias exists, else the /// same for each parent domain (mail.barant.com, then barant.com). /// Empty if none exists anywhere. /// std::string postmasterAddress(); protected: void inCreate(coreutils::ZString &name); private: __SMTP_AUTH _smtp_auth; __SMTP_DATA _smtp_data; __SMTP_EHLO _smtp_ehlo; __SMTP_EXPN _smtp_expn; __SMTP_HELO _smtp_helo; __SMTP_HELP _smtp_help; __SMTP_MAIL _smtp_mail; __SMTP_NOOP _smtp_noop; __SMTP_QUIT _smtp_quit; __SMTP_RCPT _smtp_rcpt; __SMTP_RSET _smtp_rset; __SMTP_STARTTLS _smtp_starttls; __SMTP_VRFY _smtp_vrfy; int wd; void processExisting(); // Writes one already-scanned message into one mailbox's Inbox // or Spam folder - factored out of inCreate() so an alias // (MailFileSystem::ifAliasExists()/getAliasMailboxes()) can // deliver the same scanned copy to each of its target mailboxes, // not just the single recipient a plain local delivery has. // `sender` is the envelope reverse-path, recorded as Return-Path: // (RFC 5321 4.4 - the final delivery server MUST add it). void deliverToMailbox(coreutils::ZString &mailbox, coreutils::ZString &messageId, SpamAssassinFilter::Result &scan, const std::string &sender); }; } #endif