logo

drewdevault.com

[mirror] blog and personal website of Drew DeVault git clone https://hacktivis.me/git/mirror/drewdevault.com.git

Local-mail-server.md (5217B)

    

  1. ---
  2. date: 2018-08-05
  3. layout: post
  4. title: Setting up a local dev mail server
  5. tags: [mail, instructional]
  6. ---
  8. As part of my work on [lists.sr.ht](https://meta.sr.ht), it was necessary for
  9. me to configure a self-contained mail system on localhost that I could test
  10. with. I hope that others will go through a similar process in the future when
  11. they set up [the code](https://git.sr.ht/~sircmpwn/lists.sr.ht) for hacking on
  12. locally or when working on other email related software, so here's a guide on
  13. how you can set it up.
  15. There are lots of things you can set up on a mail server, like virtual mail
  16. accounts backed by a relational database, IMAP access, spam filtering, and so
  17. on. We're not going to do any of that in this article - we're just interested in
  18. something we can test our email code with. To start, install your distribution
  19. of `postfix` and pop open that `/etc/postfix/main.cf` file.
  21. Let's quickly touch on the less interesting config keys to change. If you want
  22. the details about how these work, consult the postfix manual.
  24. - *myhostname* should be your local hostname
  25. - *mydomain* should also be your local hostname
  26. - *mydestination* should be `$myhostname, localhost.$mydomain, localhost`
  27. - *mynetworks* should be `127.0.0.0/8`
  28. - *home_mailbox* should be `Maildir/`
  30. Also ensure your hostname is set up right in `/etc/hosts`, something like this:
  32. ```
  33. 127.0.0.1 homura.localdomain homura
  34. ```
  36. Okay, those are the easy ones. That just makes it so that your mail server
  37. oversees mail delivery for the `127.0.0.0/8` network (localhost) and delivers
  38. mail to local Unix user mailboxes. It will store incoming email in each user's
  39. home directory at `~/Maildir`, and will deliver email to other Unix users. Let's
  40. set up an email client for reading these emails with. Here's my development
  41. [mutt](http://mutt.org) config:
  43. ```
  44. set edit_headers=yes
  45. set realname="Drew DeVault"
  46. set from="sircmpwn@homura"
  47. set editor=vim
  48. set spoolfile="~/Maildir/"
  49. set folder="~/Maildir/"
  50. set timeout=5
  51. color index blue default ~P
  52. ```
  54. Make any necessary edits. If you use mutt to read your normal mail, I suggest
  55. also setting up an alias which runs `mutt -C path/to/dev/config`. Now, you
  56. should be able to send an email to yourself or other Unix accounts with
  57. mutt[^1]. Hooray!
  59. [^1]: Mutt crash course: run `mutt`, press `m` to compose a new email, enter the recipient (`$USER@$HOSTNAME` to send to yourself) and the subject, then compose your email, exit the editor, and press `y` to send. A few moments later the email should arrive.
  61. To accept email over SMTP, mozy on over to `/etc/postfix/master.cf` and
  62. uncomment the submission service. You're looking for something like this:
  64. ```
  65. 127.0.0.1:submission inet n       -       n       -       -       smtpd
  66. #  -o syslog_name=postfix/submission
  67. #  -o smtpd_tls_security_level=encrypt
  68. #  -o smtpd_sasl_auth_enable=yes
  69. #  -o smtpd_tls_auth_only=yes
  70. #  -o smtpd_reject_unlisted_recipient=no
  71. #  -o smtpd_client_restrictions=$mua_client_restrictions
  72. #  -o smtpd_helo_restrictions=$mua_helo_restrictions
  73. #  -o smtpd_sender_restrictions=$mua_sender_restrictions
  74. #  -o smtpd_recipient_restrictions=
  75. #  -o smtpd_relay_restrictions=
  76. #  -o milter_macro_daemon_name=ORIGINATING
  77. ```
  79. This will permit delivery via localhost on the submission port (587) to anyone
  80. whose hostname is in `$mydestination`. A good old `postfix reload` later and you
  81. should be able to send yourself an email with SMTP:
  83. ```
  84. $ telnet 127.0.0.1 587
  85. Trying 127.0.0.1...
  86. Connected to 127.0.0.1.
  87. Escape character is '^]'.
  88. 220 homura ESMTP Postfix
  89. EHLO example.org
  90. 250-homura
  91. 250-PIPELINING
  92. 250-SIZE 10240000
  93. 250-VRFY
  94. 250-ETRN
  95. 250-ENHANCEDSTATUSCODES
  96. 250-8BITMIME
  97. 250-DSN
  98. 250 SMTPUTF8
  99. MAIL FROM:<sircmpwn@homura>
  100. 250 2.1.0 Ok
  101. RCPT TO:<sircmpwn@homura> 
  102. 250 2.1.5 Ok
  103. DATA
  104. 354 End data with <CR><LF>.<CR><LF>
  105. From: Drew DeVault <sircmpwn@homura>
  106. To: Drew DeVault <sircmpwn@homura>
  107. Subject: Hello world
  109. Hey there 
  110. .
  111. 250 2.0.0 Ok: queued as 8267416366B
  112. QUIT
  113. 221 2.0.0 Bye
  114. Connection closed by foreign host.
  115. ```
  117. Pull up mutt again to read this. Any software which will be sending out mail and
  118. speaks SMTP (for example, sr.ht) can be configured now. Last step is to set up
  119. LTMP delivery to lists.sr.ht or any other software you want to process incoming
  120. emails. I want most mail to deliver normally - I only want LTMP configured for
  121. my lists.sr.ht test domain. I'll set up some transport maps for this purpose. In
  122. `main.cf`:
  124. ```
  125. local_transport = local:$myhostname
  126. transport_maps = lmdb:/etc/postfix/transport
  127. ```
  129. Then I'll edit `/etc/postfix/transport` and add these lines:
  131. ```
  132. lists.homura lmtp:unix:/tmp/lists.sr.ht-lmtp.sock
  133. homura local:homura
  134. ```
  136. This will deliver mail normally to `$user@homura` (my hostname), but will
  137. forward mail sent to `$user@lists.homura` to the Unix socket where the
  138. [lists.sr.ht LMTP
  139. server](https://git.sr.ht/~sircmpwn/lists.sr.ht/tree/master/listssrht-lmtp) lives.
  141. Add the subdomain to `/etc/hosts`:
  143. ```
  144. 127.0.0.1 lists.homura.localdomain lists.homura
  145. ```
  147. Run `postmap /etc/postfix/transport` and `postfix reload` and you're good to go.
  148. If you have the lists.sr.ht daemon working, send some emails to
  149. `~someone/example-list@lists.$hostname` and you should see them get picked up.