1package mtastsdb

2

3import (

4 "context"

5 "errors"

6 "fmt"

7 "log/slog"

8 mathrand "math/rand"

9 "runtime/debug"

10 "time"

11

12 "github.com/mjl-/bstore"

13

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

15 "github.com/mjl-/mox/metrics"

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

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

18 "github.com/mjl-/mox/mtasts"

19)

20

21func refresh() int {

22 interval := 24 * time.Hour

23 ticker := time.NewTicker(interval)

24 defer ticker.Stop()

25

26 var refreshed int

27

28 // Pro-actively refresh policies every 24 hours. ../rfc/8461:583

29 for {

30 ticker.Reset(interval)

31

32 log := mlog.New("mtastsdb", nil).WithCid(mox.Cid())

33 n, err := refresh1(mox.Context, log, dns.StrictResolver{Pkg: "mtastsdb"}, time.Sleep)

34 log.Check(err, "periodic refresh of cached mtasts policies")

35 if n > 0 {

36 refreshed += n

37 }

38

39 select {

40 case <-mox.Shutdown.Done():

41 return refreshed

42 case <-ticker.C:

43 }

44 }

45}

46

47// refresh policies that have not been updated in the past 12 hours and remove

48// policies not used for 180 days. We start with the first domain immediately, so

49// an admin can see any (configuration) issues that are logged. We spread the

50// refreshes evenly over the next 3 hours, randomizing the domains, and we add some

51// jitter to the timing. Each refresh is done in a new goroutine, so a single slow

52// refresh doesn't mess up the timing.

53func refresh1(ctx context.Context, log mlog.Log, resolver dns.Resolver, sleep func(d time.Duration)) (int, error) {

54 now := timeNow()

55 qdel := bstore.QueryDB[PolicyRecord](ctx, DB)

56 qdel.FilterLess("LastUse", now.Add(-180*24*time.Hour))

57 if _, err := qdel.Delete(); err != nil {

58 return 0, fmt.Errorf("deleting old unused policies: %s", err)

59 }

60

61 qup := bstore.QueryDB[PolicyRecord](ctx, DB)

62 qup.FilterLess("LastUpdate", now.Add(-12*time.Hour))

63 prs, err := qup.List()

64 if err != nil {

65 return 0, fmt.Errorf("querying policies to refresh: %s", err)

66 }

67

68 if len(prs) == 0 {

69 // Nothing to do.

70 return 0, nil

71 }

72

73 // Randomize list.

74 rand := mathrand.New(mathrand.NewSource(time.Now().UnixNano()))

75 for i := range prs {

76 if i == 0 {

77 continue

78 }

79 j := rand.Intn(i + 1)

80 prs[i], prs[j] = prs[j], prs[i]

81 }

82

83 // Launch goroutine with the refresh.

84 log.Debug("will refresh mta-sts policies over next 3 hours", slog.Int("count", len(prs)))

85 start := timeNow()

86 for i, pr := range prs {

87 go refreshDomain(ctx, log, DB, resolver, pr)

88 if i < len(prs)-1 {

89 interval := 3 * int64(time.Hour) / int64(len(prs)-1)

90 extra := time.Duration(rand.Int63n(interval) - interval/2)

91 next := start.Add(time.Duration(int64(i+1)*interval) + extra)

92 d := next.Sub(timeNow())

93 if d > 0 {

94 sleep(d)

95 }

96 }

97 }

98 return len(prs), nil

99}

100

101func refreshDomain(ctx context.Context, log mlog.Log, db *bstore.DB, resolver dns.Resolver, pr PolicyRecord) {

102 defer func() {

103 x := recover()

104 if x != nil {

105 // Should not happen, but make sure errors don't take down the application.

106 log.Error("refresh1", slog.Any("panic", x))

107 debug.PrintStack()

108 metrics.PanicInc(metrics.Mtastsdb)

109 }

110 }()

111

112 ctx, cancel := context.WithTimeout(ctx, time.Minute)

113 defer cancel()

114

115 d, err := dns.ParseDomain(pr.Domain)

116 if err != nil {

117 log.Errorx("refreshing mta-sts policy: parsing policy domain", err, slog.Any("domain", d))

118 return

119 }

120 log.Debug("refreshing mta-sts policy for domain", slog.Any("domain", d))

121 record, _, err := mtasts.LookupRecord(ctx, log.Logger, resolver, d)

122 if err == nil && record.ID == pr.RecordID {

123 qup := bstore.QueryDB[PolicyRecord](ctx, db)

124 qup.FilterNonzero(PolicyRecord{Domain: pr.Domain, LastUpdate: pr.LastUpdate})

125 now := timeNow()

126 update := PolicyRecord{

127 LastUpdate: now,

128 ValidEnd: now.Add(time.Duration(pr.MaxAgeSeconds) * time.Second),

129 }

130 if n, err := qup.UpdateNonzero(update); err != nil {

131 log.Errorx("updating refreshed, unmodified policy in database", err)

132 } else if n != 1 {

133 log.Info("expected to update 1 policy after refresh", slog.Int("count", n))

134 }

135 return

136 }

137 if err != nil && pr.Mode == mtasts.ModeNone {

138 if errors.Is(err, mtasts.ErrNoRecord) {

139 // Policy was in mode "none". Now it doesn't have a policy anymore. Remove from our

140 // database so we don't keep refreshing it.

141 err := db.Delete(ctx, &pr)

142 log.Check(err, "removing mta-sts policy with mode none, dns record is gone")

143 }

144 // Else, don't bother operator with temporary error about policy none.

145 // ../rfc/8461:587

146 return

147 } else if err != nil {

148 log.Errorx("looking up mta-sts record for domain", err, slog.Any("domain", d))

149 // Try to fetch new policy. It could be just DNS that is down. We don't want to let our policy expire.

150 }

151

152 p, _, err := mtasts.FetchPolicy(ctx, log.Logger, d)

153 if err != nil {

154 if !errors.Is(err, mtasts.ErrNoPolicy) || pr.Mode != mtasts.ModeNone {

155 log.Errorx("refreshing mtasts policy for domain", err, slog.Any("domain", d))

156 }

157 return

158 }

159 now := timeNow()

160 update := map[string]any{

161 "LastUpdate": now,

162 "ValidEnd": now.Add(time.Duration(p.MaxAgeSeconds) * time.Second),

163 "Backoff": false,

164 "Policy": *p,

165 }

166 if record != nil {

167 update["RecordID"] = record.ID

168 }

169 qup := bstore.QueryDB[PolicyRecord](ctx, db)

170 qup.FilterNonzero(PolicyRecord{Domain: pr.Domain, LastUpdate: pr.LastUpdate})

171 if n, err := qup.UpdateFields(update); err != nil {

172 log.Errorx("updating refreshed, modified policy in database", err)

173 } else if n != 1 {

174 log.Info("updating refreshed, did not update 1 policy", slog.Int("count", n))

175 }

176}

177