ntfy/server/smtp_sender.go

159 lines
3.9 KiB
Go
Raw Normal View History

2021-12-24 00:03:04 +01:00
package server
import (
2021-12-25 00:13:09 +01:00
_ "embed" // required by go:embed
"encoding/json"
2021-12-24 00:03:04 +01:00
"fmt"
2023-02-06 05:34:27 +01:00
"heckel.io/ntfy/log"
2021-12-25 00:13:09 +01:00
"heckel.io/ntfy/util"
"mime"
2021-12-24 00:03:04 +01:00
"net"
"net/smtp"
"strings"
2022-06-02 05:24:44 +02:00
"sync"
2021-12-25 00:13:09 +01:00
"time"
2021-12-24 00:03:04 +01:00
)
type mailer interface {
2022-06-02 05:24:44 +02:00
Send(v *visitor, m *message, to string) error
Counts() (total int64, success int64, failure int64)
2021-12-24 00:03:04 +01:00
}
2021-12-27 16:39:28 +01:00
type smtpSender struct {
2022-06-02 05:24:44 +02:00
config *Config
success int64
failure int64
mu sync.Mutex
2021-12-24 00:03:04 +01:00
}
2022-06-02 05:24:44 +02:00
func (s *smtpSender) Send(v *visitor, m *message, to string) error {
return s.withCount(v, m, func() error {
host, _, err := net.SplitHostPort(s.config.SMTPSenderAddr)
if err != nil {
return err
}
message, err := formatMail(s.config.BaseURL, v.ip.String(), s.config.SMTPSenderFrom, to, m)
2022-06-02 05:24:44 +02:00
if err != nil {
return err
}
auth := smtp.PlainAuth("", s.config.SMTPSenderUser, s.config.SMTPSenderPass, host)
2023-02-15 16:55:01 +01:00
ev := logvm(v, m).
2023-02-04 04:21:50 +01:00
Tag(tagEmail).
2023-02-06 05:34:27 +01:00
Fields(log.Context{
2023-02-04 04:21:50 +01:00
"email_via": s.config.SMTPSenderAddr,
"email_user": s.config.SMTPSenderUser,
"email_to": to,
2023-02-15 16:55:01 +01:00
})
if ev.IsTrace() {
ev.Field("email_body", message).Trace("Sending email")
} else if ev.IsDebug() {
ev.Debug("Sending email")
}
2022-06-02 05:24:44 +02:00
return smtp.SendMail(s.config.SMTPSenderAddr, auth, s.config.SMTPSenderFrom, []string{to}, []byte(message))
})
}
func (s *smtpSender) Counts() (total int64, success int64, failure int64) {
s.mu.Lock()
defer s.mu.Unlock()
return s.success + s.failure, s.success, s.failure
}
func (s *smtpSender) withCount(v *visitor, m *message, fn func() error) error {
err := fn()
s.mu.Lock()
defer s.mu.Unlock()
2021-12-25 00:13:09 +01:00
if err != nil {
2023-02-04 04:21:50 +01:00
logvm(v, m).Err(err).Debug("Sending mail failed")
2022-06-02 05:24:44 +02:00
s.failure++
} else {
s.success++
2021-12-25 00:13:09 +01:00
}
2022-06-02 05:24:44 +02:00
return err
2021-12-25 00:13:09 +01:00
}
func formatMail(baseURL, senderIP, from, to string, m *message) (string, error) {
topicURL := baseURL + "/" + m.Topic
2021-12-24 00:03:04 +01:00
subject := m.Title
if subject == "" {
subject = m.Message
}
subject = strings.ReplaceAll(strings.ReplaceAll(subject, "\r", ""), "\n", " ")
2021-12-24 15:01:29 +01:00
message := m.Message
2021-12-25 00:13:09 +01:00
trailer := ""
2021-12-24 15:01:29 +01:00
if len(m.Tags) > 0 {
2021-12-25 00:13:09 +01:00
emojis, tags, err := toEmojis(m.Tags)
if err != nil {
return "", err
}
if len(emojis) > 0 {
subject = strings.Join(emojis, " ") + " " + subject
}
if len(tags) > 0 {
trailer = "Tags: " + strings.Join(tags, ", ")
}
2021-12-24 15:01:29 +01:00
}
if m.Priority != 0 && m.Priority != 3 {
2021-12-25 00:13:09 +01:00
priority, err := util.PriorityString(m.Priority)
if err != nil {
return "", err
}
if trailer != "" {
trailer += "\n"
}
trailer += fmt.Sprintf("Priority: %s", priority)
2021-12-24 15:01:29 +01:00
}
2021-12-25 00:13:09 +01:00
if trailer != "" {
message += "\n\n" + trailer
}
subject = mime.BEncoding.Encode("utf-8", subject)
body := `From: "{shortTopicURL}" <{from}>
2021-12-25 00:13:09 +01:00
To: {to}
Subject: {subject}
Content-Type: text/plain; charset="utf-8"
2021-12-25 00:13:09 +01:00
{message}
--
This message was sent by {ip} at {time} via {topicURL}`
body = strings.ReplaceAll(body, "{from}", from)
body = strings.ReplaceAll(body, "{to}", to)
body = strings.ReplaceAll(body, "{subject}", subject)
body = strings.ReplaceAll(body, "{message}", message)
body = strings.ReplaceAll(body, "{topicURL}", topicURL)
body = strings.ReplaceAll(body, "{shortTopicURL}", util.ShortTopicURL(topicURL))
body = strings.ReplaceAll(body, "{time}", time.Unix(m.Time, 0).UTC().Format(time.RFC1123))
body = strings.ReplaceAll(body, "{ip}", senderIP)
return body, nil
}
var (
//go:embed "mailer_emoji.json"
emojisJSON string
)
type emoji struct {
Emoji string `json:"emoji"`
Aliases []string `json:"aliases"`
}
func toEmojis(tags []string) (emojisOut []string, tagsOut []string, err error) {
var emojis []emoji
if err = json.Unmarshal([]byte(emojisJSON), &emojis); err != nil {
return nil, nil, err
}
tagsOut = make([]string, 0)
emojisOut = make([]string, 0)
nextTag:
for _, t := range tags { // TODO Super inefficient; we should just create a .json file with a map
for _, e := range emojis {
2022-10-01 21:50:48 +02:00
if util.Contains(e.Aliases, t) {
2021-12-25 00:13:09 +01:00
emojisOut = append(emojisOut, e.Emoji)
continue nextTag
}
}
tagsOut = append(tagsOut, t)
}
return
2021-12-24 00:03:04 +01:00
}