1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// SPDX-FileCopyrightText: © 2020 Grégoire Duchêne <gduchene@awhk.org>
// SPDX-License-Identifier: ISC
package main
import (
"bytes"
"context"
"crypto/tls"
"fmt"
"log"
"net"
"net/smtp"
"text/template"
"time"
"go.awhk.org/fwdsms/pkg/twilio"
)
type email struct {
from, to string
body []byte
}
type mailer struct {
auth smtp.Auth
hostname string
sms <-chan twilio.SMS
tmplFrom, tmplTo, tmplMsg *template.Template
}
func (m *mailer) sendEmail(e email) error {
dialer := &net.Dialer{Timeout: time.Second}
conn, err := tls.DialWithDialer(dialer, "tcp", m.hostname, nil)
if err != nil {
return err
}
if err := conn.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
log.Printf("Failed to set the SMTP connection deadline: %s.", err)
}
h, _, _ := net.SplitHostPort(m.hostname)
c, err := smtp.NewClient(conn, h)
if err != nil {
conn.Close()
return err
}
defer c.Close()
if err := c.Auth(m.auth); err != nil {
return err
}
if err := c.Mail(e.from); err != nil {
return err
}
if err := c.Rcpt(e.to); err != nil {
return err
}
w, err := c.Data()
if err != nil {
return err
}
if _, err := w.Write(e.body); err != nil {
return err
}
if err = w.Close(); err != nil {
return nil
}
return c.Quit()
}
func (m *mailer) newEmail(sms twilio.SMS) email {
var from, to, msg bytes.Buffer
if err := m.tmplFrom.Execute(&from, sms); err != nil {
log.Printf("Failed to apply a template: %v.", err)
}
if err := m.tmplTo.Execute(&to, sms); err != nil {
log.Printf("Failed to apply a template: %v.", err)
}
if err := m.tmplMsg.Execute(&msg, sms); err != nil {
log.Printf("Failed to apply a template: %v.", err)
}
return email{from.String(), to.String(), msg.Bytes()}
}
func (m *mailer) start(ctx context.Context) {
for {
select {
case <-ctx.Done():
return
case sms := <-m.sms:
if err := m.sendEmail(m.newEmail(sms)); err != nil {
log.Printf("Failed to send email: %v.", err)
}
}
}
}
func newMailer(cfg *Config, sms <-chan twilio.SMS) *mailer {
if cfg.Message.From == "" {
log.Fatal("Missing From field.")
}
if cfg.Message.To == "" {
log.Fatal("Missing To field.")
}
if cfg.Message.Subject == "" {
log.Fatal("Missing Subject field.")
}
if cfg.Message.Template == "" {
log.Fatal("Missing Template field.")
}
tmplMsg := fmt.Sprintf("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n%s\r\n",
cfg.Message.From, cfg.Message.To, cfg.Message.Subject, cfg.Message.Template)
host, _, _ := net.SplitHostPort(cfg.SMTP.Address)
return &mailer{
auth: smtp.PlainAuth("", cfg.SMTP.Username, cfg.SMTP.Password, host),
hostname: cfg.SMTP.Address,
sms: sms,
tmplFrom: template.Must(template.New("from").Parse(cfg.Message.From)),
tmplTo: template.Must(template.New("to").Parse(cfg.Message.To)),
tmplMsg: template.Must(template.New("message").Parse(tmplMsg)),
}
}
|
