1package dsn

2

3import (

4 "bufio"

5 "fmt"

6 "io"

7 "net/textproto"

8 "strconv"

9 "strings"

10 "time"

11

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

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

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

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

16)

17

18// Parse reads a DSN message.

19//

20// A DSN is a multipart internet mail message with 2 or 3 parts: human-readable

21// text, machine-parsable text, and optional original message or headers.

22//

23// The first return value is the machine-parsed DSN message. The second value is

24// the entire MIME multipart message. Use its Parts field to access the

25// human-readable text and optional original message/headers.

26func Parse(log *mlog.Log, r io.ReaderAt) (*Message, *message.Part, error) {

27 // DSNs can mix and match subtypes with and without utf-8. ../rfc/6533:441

28

29 part, err := message.Parse(log, false, r)

30 if err != nil {

31 return nil, nil, fmt.Errorf("parsing message: %v", err)

32 }

33 if part.MediaType != "MULTIPART" || part.MediaSubType != "REPORT" {

34 return nil, nil, fmt.Errorf(`message has content-type %q, must have "message/report"`, strings.ToLower(part.MediaType+"/"+part.MediaSubType))

35 }

36 err = part.Walk(log, nil)

37 if err != nil {

38 return nil, nil, fmt.Errorf("parsing message parts: %v", err)

39 }

40 nparts := len(part.Parts)

41 if nparts != 2 && nparts != 3 {

42 return nil, nil, fmt.Errorf("invalid dsn, got %d multipart parts, 2 or 3 required", nparts)

43 }

44 p0 := part.Parts[0]

45 if !(p0.MediaType == "" && p0.MediaSubType == "") && !(p0.MediaType == "TEXT" && p0.MediaSubType == "PLAIN") {

46 return nil, nil, fmt.Errorf(`invalid dsn, first part has content-type %q, must have "text/plain"`, strings.ToLower(p0.MediaType+"/"+p0.MediaSubType))

47 }

48

49 p1 := part.Parts[1]

50 var m *Message

51 if !(p1.MediaType == "MESSAGE" && (p1.MediaSubType == "DELIVERY-STATUS" || p1.MediaSubType == "GLOBAL-DELIVERY-STATUS")) {

52 return nil, nil, fmt.Errorf(`invalid dsn, second part has content-type %q, must have "message/delivery-status" or "message/global-delivery-status"`, strings.ToLower(p1.MediaType+"/"+p1.MediaSubType))

53 }

54 utf8 := p1.MediaSubType == "GLOBAL-DELIVERY-STATUS"

55 m, err = Decode(p1.Reader(), utf8)

56 if err != nil {

57 return nil, nil, fmt.Errorf("parsing dsn delivery-status part: %v", err)

58 }

59

60 addressPath := func(a message.Address) (smtp.Path, error) {

61 d, err := dns.ParseDomain(a.Host)

62 if err != nil {

63 return smtp.Path{}, fmt.Errorf("parsing domain: %v", err)

64 }

65 return smtp.Path{Localpart: smtp.Localpart(a.User), IPDomain: dns.IPDomain{Domain: d}}, nil

66 }

67 if len(part.Envelope.From) == 1 {

68 m.From, err = addressPath(part.Envelope.From[0])

69 if err != nil {

70 return nil, nil, fmt.Errorf("parsing From-header: %v", err)

71 }

72 }

73 if len(part.Envelope.To) == 1 {

74 m.To, err = addressPath(part.Envelope.To[0])

75 if err != nil {

76 return nil, nil, fmt.Errorf("parsing To-header: %v", err)

77 }

78 }

79 m.Subject = part.Envelope.Subject

80 buf, err := io.ReadAll(p0.ReaderUTF8OrBinary())

81 if err != nil {

82 return nil, nil, fmt.Errorf("reading human-readable text part: %v", err)

83 }

84 m.TextBody = strings.ReplaceAll(string(buf), "\r\n", "\n")

85

86 if nparts == 2 {

87 return m, &part, nil

88 }

89

90 p2 := part.Parts[2]

91 ct := strings.ToLower(p2.MediaType + "/" + p2.MediaSubType)

92 switch ct {

93 case "text/rfc822-headers":

94 case "message/global-headers":

95 case "message/rfc822":

96 case "message/global":

97 default:

98 return nil, nil, fmt.Errorf("invalid content-type %q for optional third part with original message/headers", ct)

99 }

100

101 return m, &part, nil

102}

103

104// Decode parses the (global) delivery-status part of a DSN.

105//

106// utf8 indicates if UTF-8 is allowed for this message, if used by the media

107// subtype of the message parts.

108func Decode(r io.Reader, utf8 bool) (*Message, error) {

109 m := Message{SMTPUTF8: utf8}

110

111 // We are using textproto.Reader to read mime headers. It requires a header section ending in \r\n.

112 // ../rfc/3464:486

113 b := bufio.NewReader(io.MultiReader(r, strings.NewReader("\r\n")))

114 mr := textproto.NewReader(b)

115

116 // Read per-message lines.

117 // ../rfc/3464:1522 ../rfc/6533:366

118 msgh, err := mr.ReadMIMEHeader()

119 if err != nil {

120 return nil, fmt.Errorf("reading per-message lines: %v", err)

121 }

122 for k, l := range msgh {

123 if len(l) != 1 {

124 return nil, fmt.Errorf("multiple values for %q: %v", k, l)

125 }

126 v := l[0]

127 // note: headers are in canonical form, as parsed by textproto.

128 switch k {

129 case "Original-Envelope-Id":

130 m.OriginalEnvelopeID = v

131 case "Reporting-Mta":

132 mta, err := parseMTA(v, utf8)

133 if err != nil {

134 return nil, fmt.Errorf("parsing reporting-mta: %v", err)

135 }

136 m.ReportingMTA = mta

137 case "Dsn-Gateway":

138 mta, err := parseMTA(v, utf8)

139 if err != nil {

140 return nil, fmt.Errorf("parsing dsn-gateway: %v", err)

141 }

142 m.DSNGateway = mta

143 case "Received-From-Mta":

144 mta, err := parseMTA(v, utf8)

145 if err != nil {

146 return nil, fmt.Errorf("parsing received-from-mta: %v", err)

147 }

148 d, err := dns.ParseDomain(mta)

149 if err != nil {

150 return nil, fmt.Errorf("parsing received-from-mta domain %q: %v", mta, err)

151 }

152 m.ReceivedFromMTA = smtp.Ehlo{Name: dns.IPDomain{Domain: d}}

153 case "Arrival-Date":

154 tm, err := parseDateTime(v)

155 if err != nil {

156 return nil, fmt.Errorf("parsing arrival-date: %v", err)

157 }

158 m.ArrivalDate = tm

159 default:

160 // We'll assume it is an extension field, we'll ignore it for now.

161 }

162 }

163 m.MessageHeader = msgh

164

165 required := []string{"Reporting-Mta"}

166 for _, req := range required {

167 if _, ok := msgh[req]; !ok {

168 return nil, fmt.Errorf("missing required recipient field %q", req)

169 }

170 }

171

172 rh, err := parseRecipientHeader(mr, utf8)

173 if err != nil {

174 return nil, fmt.Errorf("reading per-recipient header: %v", err)

175 }

176 m.Recipients = []Recipient{rh}

177 for {

178 if _, err := b.Peek(1); err == io.EOF {

179 break

180 }

181 rh, err := parseRecipientHeader(mr, utf8)

182 if err != nil {

183 return nil, fmt.Errorf("reading another per-recipient header: %v", err)

184 }

185 m.Recipients = append(m.Recipients, rh)

186 }

187 return &m, nil

188}

189

190// ../rfc/3464:1530 ../rfc/6533:370

191func parseRecipientHeader(mr *textproto.Reader, utf8 bool) (Recipient, error) {

192 var r Recipient

193 h, err := mr.ReadMIMEHeader()

194 if err != nil {

195 return Recipient{}, err

196 }

197

198 for k, l := range h {

199 if len(l) != 1 {

200 return Recipient{}, fmt.Errorf("multiple values for %q: %v", k, l)

201 }

202 v := l[0]

203 // note: headers are in canonical form, as parsed by textproto.

204 var err error

205 switch k {

206 case "Original-Recipient":

207 r.OriginalRecipient, err = parseAddress(v, utf8)

208 case "Final-Recipient":

209 r.FinalRecipient, err = parseAddress(v, utf8)

210 case "Action":

211 a := Action(strings.ToLower(v))

212 actions := []Action{Failed, Delayed, Delivered, Relayed, Expanded}

213 var ok bool

214 for _, x := range actions {

215 if a == x {

216 ok = true

217 break

218 }

219 }

220 if !ok {

221 err = fmt.Errorf("unrecognized action %q", v)

222 }

223 case "Status":

224 // todo: parse the enhanced status code?

225 r.Status = v

226 case "Remote-Mta":

227 r.RemoteMTA = NameIP{Name: v}

228 case "Diagnostic-Code":

229 // ../rfc/3464:518

230 t := strings.SplitN(v, ";", 2)

231 dt := strings.TrimSpace(t[0])

232 if strings.ToLower(dt) != "smtp" {

233 err = fmt.Errorf("unknown diagnostic-type %q, expected smtp", dt)

234 } else if len(t) != 2 {

235 err = fmt.Errorf("missing semicolon to separate diagnostic-type from code")

236 } else {

237 r.DiagnosticCode = strings.TrimSpace(t[1])

238 }

239 case "Last-Attempt-Date":

240 r.LastAttemptDate, err = parseDateTime(v)

241 case "Final-Log-Id":

242 r.FinalLogID = v

243 case "Will-Retry-Until":

244 tm, err := parseDateTime(v)

245 if err == nil {

246 r.WillRetryUntil = &tm

247 }

248 default:

249 // todo future: parse localized diagnostic text field?

250 // We'll assume it is an extension field, we'll ignore it for now.

251 }

252 if err != nil {

253 return Recipient{}, fmt.Errorf("parsing field %q %q: %v", k, v, err)

254 }

255 }

256

257 required := []string{"Final-Recipient", "Action", "Status"}

258 for _, req := range required {

259 if _, ok := h[req]; !ok {

260 return Recipient{}, fmt.Errorf("missing required recipient field %q", req)

261 }

262 }

263

264 r.Header = h

265 return r, nil

266}

267

268// ../rfc/3464:525

269func parseMTA(s string, utf8 bool) (string, error) {

270 s = removeComments(s)

271 t := strings.SplitN(s, ";", 2)

272 if len(t) != 2 {

273 return "", fmt.Errorf("missing semicolon that splits type and name")

274 }

275 k := strings.TrimSpace(t[0])

276 if !strings.EqualFold(k, "dns") {

277 return "", fmt.Errorf("unknown type %q, expected dns", k)

278 }

279 return strings.TrimSpace(t[1]), nil

280}

281

282func parseDateTime(s string) (time.Time, error) {

283 s = removeComments(s)

284 return time.Parse(message.RFC5322Z, s)

285}

286

287func parseAddress(s string, utf8 bool) (smtp.Path, error) {

288 s = removeComments(s)

289 t := strings.SplitN(s, ";", 2)

290 // ../rfc/3464:513 ../rfc/6533:250

291 addrType := strings.ToLower(strings.TrimSpace(t[0]))

292 if len(t) != 2 {

293 return smtp.Path{}, fmt.Errorf("missing semicolon that splits address type and address")

294 } else if addrType == "utf-8" {

295 if !utf8 {

296 return smtp.Path{}, fmt.Errorf("utf-8 address type for non-utf-8 dsn")

297 }

298 } else if addrType != "rfc822" {

299 return smtp.Path{}, fmt.Errorf("unrecognized address type %q, expected rfc822", addrType)

300 }

301 s = strings.TrimSpace(t[1])

302 if !utf8 {

303 for _, c := range s {

304 if c > 0x7f {

305 return smtp.Path{}, fmt.Errorf("non-ascii without utf-8 enabled")

306 }

307 }

308 }

309 // todo: more proper parser

310 t = strings.SplitN(s, "@", 2)

311 if len(t) != 2 || t[0] == "" || t[1] == "" {

312 return smtp.Path{}, fmt.Errorf("invalid email address")

313 }

314 d, err := dns.ParseDomain(t[1])

315 if err != nil {

316 return smtp.Path{}, fmt.Errorf("parsing domain: %v", err)

317 }

318 var lp string

319 var esc string

320 for _, c := range t[0] {

321 if esc == "" && c == '\\' || esc == `\` && (c == 'x' || c == 'X') || esc == `\x` && c == '{' {

322 if c == 'X' {

323 c = 'x'

324 }

325 esc += string(c)

326 } else if strings.HasPrefix(esc, `\x{`) {

327 if c == '}' {

328 c, err := strconv.ParseInt(esc[3:], 16, 32)

329 if err != nil {

330 return smtp.Path{}, fmt.Errorf("parsing localpart with hexpoint: %v", err)

331 }

332 lp += string(rune(c))

333 esc = ""

334 } else {

335 esc += string(c)

336 }

337 } else {

338 lp += string(c)

339 }

340 }

341 if esc != "" {

342 return smtp.Path{}, fmt.Errorf("parsing localpart: unfinished embedded unicode char")

343 }

344 p := smtp.Path{Localpart: smtp.Localpart(lp), IPDomain: dns.IPDomain{Domain: d}}

345 return p, nil

346}

347

348func removeComments(s string) string {

349 n := 0

350 r := ""

351 for _, c := range s {

352 if c == '(' {

353 n++

354 } else if c == ')' && n > 0 {

355 n--

356 } else if n == 0 {

357 r += string(c)

358 }

359 }

360 return r

361}

362