I used to run a fairly large (for two Ops people) mail system until 2014. I did it all, sendmail, MIMEDefang, my own milters, SPF, and a bunch of other accompanying acronyms and technologies. I’ve stopped doing that now. The big companies have both the money and the workforce to do it better. But I still run a small mailing list. It used to run on majordomo but then it started having issues with modern Perl and I moved it to Mailman. Which is kind of an overkill for just a list with 300 or so people on. So for a time I even run it manually using free GSuite (yes there was a time it was free) hosting.
Lately I wanted to really run it automated again. So I thought I should try something different that would also contribute to the general civility and high SNR of it. I’d been lurking around the picolisp mailing list for years and thought I should use it. Because it comes with a mailing list program:
# (c) Software Lab. Alexander Burger
*Mailings (make (in "/home/foobar/Mailings" (while (line T) (link @))))
*SmtpPort 25 )
# Process mails
(when (gt0 (car (info *SpoolFile)))
(unless (= "From" (till " " T))
(quit "Bad mbox file") )
(while (setq *From (lowc (till " " T)))
(line) # Skip rest of line and "\r\n"
*Name *Subject *Date *MessageID *InReplyTo *MimeVersion
*ContentType *ContentTransferEncoding *ContentDisposition *UserAgent )
(while (trim (split (line) " "))
(let L @
(while (and (sub? (peek) " \t") (char)) # Skip WSP
(conc L (trim (split (line) " "))) )
(setq *Line (glue " " (cdr L)))
(case (pack (car L))
("From:" (setq *Name *Line))
("Subject:" (setq *Subject *Line))
("Date:" (setq *Date *Line))
("Message-ID:" (setq *MessageID *Line))
("In-Reply-To:" (setq *InReplyTo *Line))
("MIME-Version:" (setq *MimeVersion *Line))
("Content-Type:" (setq *ContentType *Line))
("Content-Transfer-Encoding:" (setq *ContentTransferEncoding *Line))
("Content-Disposition:" (setq *ContentDisposition *Line))
("User-Agent:" (setq *UserAgent *Line)) ) ) )
(if (nor (member *From *Mailings) (= "subscribe" (lowc *Subject)))
(out "/dev/null" (echo "^JFrom ") (msg *From " discarded"))
(unless (setq *Sock (connect *SmtpHost *SmtpPort))
(quit "Can't connect to SMTP server") )
(pre? "220 " (in *Sock (line T)))
(out *Sock (prinl "HELO " *MailingDomain "^M"))
(pre? "250 " (in *Sock (line T)))
(out *Sock (prinl "MAIL FROM:" *MailingList "^M"))
(pre? "250 " (in *Sock (line T))) )
(quit "Can't HELO") )
(when (= "subscribe" (lowc *Subject))
(push1 '*Mailings *From)
(out "Mailings" (mapc prinl *Mailings)) )
(for To *Mailings
(out *Sock (prinl "RCPT TO:" To "^M"))
(unless (pre? "250 " (in *Sock (line T)))
(msg T " can't mail") ) )
(when (and (out *Sock (prinl "DATA^M")) (pre? "354 " (in *Sock (line T))))
(prinl "From: " (or *Name *From) "^M")
(prinl "Sender: " *MailingList "^M")
(prinl "Reply-To: " *MailingList "^M")
(prinl "To: " *MailingList "^M")
(prinl "Subject: " *Subject "^M")
(and *Date (prinl "Date: " @ "^M"))
(and *MessageID (prinl "Message-ID: " @ "^M"))
(and *InReplyTo (prinl "In-Reply-To: " @ "^M"))
(and *MimeVersion (prinl "MIME-Version: " @ "^M"))
(and *ContentType (prinl "Content-Type: " @ "^M"))
(and *ContentTransferEncoding (prinl "Content-Transfer-Encoding: " @ "^M"))
(and *ContentDisposition (prinl "Content-Disposition: " @ "^M"))
(and *UserAgent (prinl "User-Agent: " @ "^M"))
((= "subscribe" (lowc *Subject))
(prinl "Hello " (or *Name *From) " :-)^M")
(prinl "You are now subscribed^M")
(prinl "****^M^J^M") )
((= "unsubscribe" (lowc *Subject))
(mapc prinl (del *From '*Mailings)) )
(prinl "Good bye " (or *Name *From) " :-(^M")
(prinl "You are now unsubscribed^M")
(prinl "****^M^J^M") ) )
(echo "^JFrom ")
(prinl "^J-- ^M")
(prinl "UNSUBSCRIBE: mailto:" *MailingList "?subject=Unsubscribe^M")
(prinl "QUIT^M") ) )
(close *Sock) ) ) )
(out *SpoolFile (rewind)) ) )
(call "fetchmail" "-as")
(wait `(* 4 60 1000)) )
You do not have to understand a lot of Lisp to know how this is configured.
– Line 7 is where you put your mailing list’s address
– Line 8 is where incoming mail for the mailing list is saved. If you have a mail server and you run this there, just decide to run the list as a plain user and point to the user’s mailbox under
/var/mail. Or, if you run fetchmail point to the file fetchmail saves incoming mail. See line 96 for that.
– Related to the above: Since I run this on my mail server, I delete line 96.
– Line 9 is my machine’s HELO/EHLO name.
– Line 10 is where the list membership is saved.
– Line 11 is the outgoing mail server.
– Line 12 is the outgoing’s mail server SMTP listening port.
Since my own incoming mail server is on a cloud provider and does not enjoy good sending reputation, I am making use of mailgun as a forwarding service. My mail server forwards to mailgun and mailgun delivers to the recipients. If you need to run your own small mail server there are tons of tutorials out there. While I am a die-hard sendmail person, I am running Postfix these days.
The final issue that remains is how to run the mailing list processor.
mailing is a console program and you need to run it as a daemon somehow. Docker to the rescuse. I am building an image with the following Dockerfile:
RUN apt-get update && apt-get install -y picolisp
COPY ./mailing .
and I am executing this with:
docker run -d --name=foobar --restart=unless-stopped -v /var/mail/foobar:/var/mail/foobar -v /home/foobar/Mailings:/home/foobar/Mailings foobar_image
I can even inspect the logs with
docker logs foobar and have made it resilient through reboots with one command.
There. I hope this gives you some ideas on how to run your own (small) mailing list. With some tinkering, you do not even need to run your own incoming mail server. It can be a mailbox in Gmail or elsewhere, you fetch mails with fetchmail locally, and submit to a relay service and done. Also note: Relay services require payment after some threshold.