// MIME: a message as the text mail servers exchange (RFC 5322, RFC 2045–2047, RFC 2231). import { uuid } from "std/random" import { emailOf, nameOf } from "./email" import type { Address, Attachment, Message } from "./email" fn isAscii(s: string): boolean { for i of 0..s.length { let c = s.codeUnitAt(i) ?? 0 if c >= 127 || c < 32 { return false } } return true } /// `text` for a header: as it is when it is plain ASCII, otherwise as RFC 2047 encoded words of at most 75 characters, /// never splitting a character. export fn encodeHeader(text: string): string { if isAscii(text) { return text } let mut words: string[] = [] let mut chunk: int[] = [] for ch of text { let bytes = Bytes.fromUtf8(ch).toList() // 45 bytes of base64 fill an encoded word's 60 characters. if chunk.length + bytes.length > 45 { words.push(`=?UTF-8?B?${Bytes.of(chunk).toBase64()}?=`) chunk = [] } chunk.push(...bytes) } if chunk.length > 0 { words.push(`=?UTF-8?B?${Bytes.of(chunk).toBase64()}?=`) } return words.join("\r\n ") } fn quoted(name: string): string { return `"${name.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"` } /// An address as a header writes it. export fn formatAddress(address: Address): string { let email = emailOf(address) let name = nameOf(address) if name == null || name == "" { return email } return isAscii(name) ? `${quoted(name)} <${email}>` : `${encodeHeader(name)} <${email}>` } fn addressList(list: Address[]): string { return list.map(formatAddress).join(",\r\n ") } /// One character of a line in quoted-printable. Spaces and tabs at the end of a line are encoded, as RFC 2045 requires. fn encodeChar(ch: string, last: boolean): string { let c = ch.codePointAt(0) ?? 0 if (c >= 33 && c <= 126 && c != 61) || ((c == 32 || c == 9) && !last) { return ch } return Bytes.fromUtf8(ch) .toList() .map(b => "=" + str(b, { radix: 16 }).toUpperCase().padStart(2, "0")) .join("") } /// `text` in quoted-printable (RFC 2045): lines of at most 76 characters, with no character split across two of them. export fn quotedPrintable(text: string): string { let source = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n") let mut lines: string[] = [] for line of source.split("\n") { let mut all: string[] = [] for ch of line { all.push(ch) } let mut out: string[] = [] let mut width = 0 for [i, ch] of all.entries() { let piece = encodeChar(ch, i == all.length - 1) if width + piece.length > 75 { out.push("=\r\n") width = 0 } out.push(piece) width += piece.length } lines.push(out.join("")) } return lines.join("\r\n") } fn wrapBase64(bytes: Bytes): string { let text = bytes.toBase64() let mut lines: string[] = [] let mut i = 0 while i < text.length { lines.push(text.slice(i, i + 76)) i += 76 } return lines.join("\r\n") } fn textPart(media: string, body: string): string { return `Content-Type: ${media}; charset=UTF-8\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\n${quotedPrintable(body)}` } fn quotedParam(value: string): string { return quoted(value) } fn percentEncoded(text: string): string { let mut out: string[] = [] for b of Bytes.fromUtf8(text).toList() { let plain = (b >= 48 && b <= 57) || (b >= 65 && b <= 90) || (b >= 97 && b <= 122) || b == 45 || b == 46 || b == 95 out.push(plain ? String.fromCharCode(b) : "%" + str(b, { radix: 16 }).toUpperCase().padStart(2, "0")) } return out.join("") } fn fileParam(name: string, filename: string): string { return isAscii(filename) ? `${name}=${quotedParam(filename)}` : `${name}*=UTF-8''${percentEncoded(filename)}` } fn attachmentPart(a: Attachment): string { let media = a.type ?? "application/octet-stream" let inline = a.contentId != null let head = [ `Content-Type: ${media}; ${fileParam("name", a.filename)}`, "Content-Transfer-Encoding: base64", `Content-Disposition: ${inline ? "inline" : "attachment"}; ${fileParam("filename", a.filename)}`, ] let cid = a.contentId let lines = cid != null ? [...head, `Content-ID: <${cid}>`] : head return `${lines.join("\r\n")}\r\n\r\n${wrapBase64(a.content)}` } fn multipart(subtype: string, boundary: string, parts: string[]): string { let body = parts.map(p => `--${boundary}\r\n${p}\r\n`).join("") return `Content-Type: multipart/${subtype};\r\n boundary="${boundary}"\r\n\r\n${body}--${boundary}--` } /// `id` makes the boundaries and the `Message-ID` repeatable, and `date` is the `Date` header (RFC 5322 form), for tests. export type MimeOptions = { id?: string, date?: string } fn domainOf(address: Address): string { let email = emailOf(address) return email.slice(email.indexOf("@") + 1) } /// The whole message as MIME text, with CRLF line endings and only ASCII in it: what an SMTP server is given after `DATA`. /// `bcc` isn't written, since every recipient would see it. /// /// ```weft /// let source = toMime({ from: "a@example.com", to: ["b@example.com"], subject: "Hi", text: "Hello" }) /// ``` export fn toMime(message: Message, options: MimeOptions = {}): string { let id = options.id ?? uuid() let mut headers: string[] = [ `From: ${formatAddress(message.from)}`, `To: ${addressList(message.to)}`, ] let cc = message.cc ?? [] if cc.length > 0 { headers.push(`Cc: ${addressList(cc)}`) } let replyTo = message.replyTo if replyTo != null { headers.push(`Reply-To: ${formatAddress(replyTo)}`) } headers.push(`Subject: ${encodeHeader(message.subject)}`) let date = options.date if date != null { headers.push(`Date: ${date}`) } headers.push(`Message-ID: <${id}@${domainOf(message.from)}>`) headers.push("MIME-Version: 1.0") for [name, value] of message.headers ?? [] { headers.push(`${name}: ${encodeHeader(value)}`) } let text = message.text ?? "" let html = message.html ?? "" let mut body = text != "" && html != "" ? multipart( "alternative", `alt-${id}`, [textPart("text/plain", text), textPart("text/html", html)], ) : html != "" ? textPart("text/html", html) : textPart("text/plain", text) let attachments = message.attachments ?? [] let inline = attachments.filter(a => a.contentId != null) let files = attachments.filter(a => a.contentId == null) if inline.length > 0 { body = multipart("related", `rel-${id}`, [body, ...inline.map(attachmentPart)]) } if files.length > 0 { body = multipart("mixed", `mix-${id}`, [body, ...files.map(attachmentPart)]) } return `${headers.join("\r\n")}\r\n${body}\r\n` }