1package queue

3import (

4 "bufio"

5 "context"

6 "errors"

7 "fmt"

8 "log/slog"

9 "net"

10 "os"

11 "strings"

12 "time"

14 "github.com/prometheus/client_golang/prometheus"

15 "github.com/prometheus/client_golang/prometheus/promauto"

17 "github.com/mjl-/bstore"

19 "github.com/mjl-/mox/dns"

20 "github.com/mjl-/mox/dsn"

21 "github.com/mjl-/mox/message"

22 "github.com/mjl-/mox/mlog"

23 "github.com/mjl-/mox/mox-"

24 "github.com/mjl-/mox/smtp"

25 "github.com/mjl-/mox/smtpclient"

26 "github.com/mjl-/mox/store"

27)

29var (

30 metricDMARCReportFailure = promauto.NewCounter(

31 prometheus.CounterOpts{

32 Name: "mox_queue_dmarcreport_failure_total",

33 Help: "Permanent failures to deliver a DMARC report.",

34 },

35 )

36)

38// todo: rename function, perhaps put some of the params in a delivery struct so we don't pass all the params all the time?

39func fail(ctx context.Context, qlog mlog.Log, msgs []*Msg, dialedIPs map[string][]net.IP, backoff time.Duration, remoteMTA dsn.NameIP, err error) {

40 // todo future: when we implement relaying, we should be able to send DSNs to non-local users. and possibly specify a null mailfrom. ../rfc/5321:1503

41 // todo future: when we implement relaying, and a dsn cannot be delivered, and requiretls was active, we cannot drop the message. instead deliver to local postmaster? though ../rfc/8689:383 may intend to say the dsn should be delivered without requiretls?

42 // todo future: when we implement smtp dsn extension, parameter RET=FULL must be disregarded for messages with REQUIRETLS. ../rfc/8689:379

44 m0 := msgs[0]

46 var smtpLines []string

47 var cerr smtpclient.Error

48 var permanent bool

49 var errmsg = err.Error()

50 var code int

51 var secodeOpt string

52 if errors.As(err, &cerr) {

53 if cerr.Line != "" {

54 smtpLines = append([]string{cerr.Line}, cerr.MoreLines...)

55 }

56 permanent = cerr.Permanent

57 code = cerr.Code

58 secodeOpt = cerr.Secode

59 }

60 qlog = qlog.With(

61 slog.Bool("permanent", permanent),

62 slog.Int("code", code),

63 slog.String("secode", secodeOpt),

64 )

66 ids := make([]int64, len(msgs))

67 for i, m := range msgs {

68 ids[i] = m.ID

69 }

71 if permanent || m0.MaxAttempts == 0 && m0.Attempts >= 8 || m0.MaxAttempts > 0 && m0.Attempts >= m0.MaxAttempts {

72 for _, m := range msgs {

73 qmlog := qlog.With(slog.Int64("msgid", m.ID), slog.Any("recipient", m.Recipient()))

74 qmlog.Errorx("permanent failure delivering from queue", err)

75 deliverDSNFailure(ctx, qmlog, *m, remoteMTA, secodeOpt, errmsg, smtpLines)

76 }

77 if err := queueDelete(context.Background(), ids...); err != nil {

78 qlog.Errorx("deleting messages from queue after permanent failure", err)

79 }

80 return

81 }

83 // All messages should have the same DialedIPs, so we can update them all at once.

84 qup := bstore.QueryDB[Msg](context.Background(), DB)

85 qup.FilterIDs(ids)

86 if _, xerr := qup.UpdateNonzero(Msg{LastError: errmsg, DialedIPs: dialedIPs}); err != nil {

87 qlog.Errorx("storing delivery error", xerr, slog.String("deliveryerror", errmsg))

88 }

90 if m0.Attempts == 5 {

91 // We've attempted deliveries at these intervals: 0, 7.5m, 15m, 30m, 1h, 2u.

92 // Let sender know delivery is delayed.

94 retryUntil := m0.LastAttempt.Add((4 + 8 + 16) * time.Hour)

95 for _, m := range msgs {

96 qmlog := qlog.With(slog.Int64("msgid", m.ID), slog.Any("recipient", m.Recipient()))

97 qmlog.Errorx("temporary failure delivering from queue, sending delayed dsn", err, slog.Duration("backoff", backoff))

98 deliverDSNDelay(ctx, qmlog, *m, remoteMTA, secodeOpt, errmsg, smtpLines, retryUntil)

99 }

100 } else {

101 for _, m := range msgs {

102 qlog.Errorx("temporary failure delivering from queue", err,

103 slog.Int64("msgid", m.ID),

104 slog.Any("recipient", m.Recipient()),

105 slog.Duration("backoff", backoff),

106 slog.Time("nextattempt", m0.NextAttempt))

107 }

108 }

109}

110

111func deliverDSNFailure(ctx context.Context, log mlog.Log, m Msg, remoteMTA dsn.NameIP, secodeOpt, errmsg string, smtpLines []string) {

112 const subject = "mail delivery failed"

113 message := fmt.Sprintf(`

114Delivery has failed permanently for your email to:

115

116 %s

117

118No further deliveries will be attempted.

119

120Error during the last delivery attempt:

121

122 %s

123`, m.Recipient().XString(m.SMTPUTF8), errmsg)

124 if len(smtpLines) > 0 {

125 message += "\nFull SMTP response:\n\n\t" + strings.Join(smtpLines, "\n\t") + "\n"

126 }

127

128 deliverDSN(ctx, log, m, remoteMTA, secodeOpt, errmsg, smtpLines, true, nil, subject, message)

129}

130

131func deliverDSNDelay(ctx context.Context, log mlog.Log, m Msg, remoteMTA dsn.NameIP, secodeOpt, errmsg string, smtpLines []string, retryUntil time.Time) {

132 // Should not happen, but doesn't hurt to prevent sending delayed delivery

133 // notifications for DMARC reports. We don't want to waste postmaster attention.

134 if m.IsDMARCReport {

135 return

136 }

137

138 const subject = "mail delivery delayed"

139 message := fmt.Sprintf(`

140Delivery has been delayed of your email to:

141

142 %s

143

144Next attempts to deliver: in 4 hours, 8 hours and 16 hours.

145If these attempts all fail, you will receive a notice.

146

147Error during the last delivery attempt:

148

149 %s

150`, m.Recipient().XString(false), errmsg)

151 if len(smtpLines) > 0 {

152 message += "\nFull SMTP response:\n\n\t" + strings.Join(smtpLines, "\n\t") + "\n"

153 }

154

155 deliverDSN(ctx, log, m, remoteMTA, secodeOpt, errmsg, smtpLines, false, &retryUntil, subject, message)

156}

157

158// We only queue DSNs for delivery failures for emails submitted by authenticated

159// users. So we are delivering to local users. ../rfc/5321:1466

160// ../rfc/5321:1494

161// ../rfc/7208:490

162func deliverDSN(ctx context.Context, log mlog.Log, m Msg, remoteMTA dsn.NameIP, secodeOpt, errmsg string, smtpLines []string, permanent bool, retryUntil *time.Time, subject, textBody string) {

163 kind := "delayed delivery"

164 if permanent {

165 kind = "failure"

166 }

167

168 qlog := func(text string, err error) {

169 log.Errorx("queue dsn: "+text+": sender will not be informed about dsn", err, slog.String("sender", m.Sender().XString(m.SMTPUTF8)), slog.String("kind", kind))

170 }

171

172 msgf, err := os.Open(m.MessagePath())

173 if err != nil {

174 qlog("opening queued message", err)

175 return

176 }

177 msgr := store.FileMsgReader(m.MsgPrefix, msgf)

178 defer func() {

179 err := msgr.Close()

180 log.Check(err, "closing message reader after queuing dsn")

181 }()