
go-message
Open Source Go Bibliotheek voor E-mail & Internet Message Format
Parse, Genereer & Verwerk RFC 5322, MIME en Content-Disposition-headers via Streaming Go API.
Wat is go-message?
go-message is een high-performance, streaming Go-bibliotheek ontworpen voor het parseren en genereren van e-mailberichten die voldoen aan het Internet Message Format (RFC 5322), MIME-extensies (RFC 2045–2047) en Content-Disposition-headers (RFC 2183). Het stelt Go-ontwikkelaars in staat e-mailinhoud efficiënt te verwerken zonder volledige berichten in het geheugen te laden, waardoor het ideaal is voor schaalbare mailservers en -clients. De bibliotheek ondersteunt automatische charset-decodering en integreert naadloos met de standaardbibliotheek van Go.
Gebouwd met modulariteit en uitbreidbaarheid in gedachten, bevat go-message toegewijde subpakketten zoals `mail` voor high‑level mailverwerking en `textproto` voor low‑level protocolparsing. Het DKIM‑vriendelijke ontwerp zorgt voor compatibiliteit met moderne e‑mailauthenticatieworkflows. Met ingebouwde streamingmogelijkheden en charset‑normalisatie vereenvoudigt go-message complexe e‑mailverwerkingstaken zoals het parseren van multipart‑lichamen, het decoderen van gecodeerde headers en het afhandelen van geneste MIME‑structuren — allemaal terwijl het geheugen efficiëntie en prestaties behoudt.
Aan de slag met go-message
Om go-message te gaan gebruiken, installeer je het via `go get` vanuit de officiële [go-message GitHub](https://github.com/emersion/go-message) repository. De aanbevolen aanpak is om Go-modules te gebruiken: voer `go get github.com/emersion/go-message` uit in je projectdirectory. Voor ondersteuning van charset-decodering, voeg `import _ "github.com/emersion/go-message/charset"` toe om alle standaardcoderingen in te schakelen. De bibliotheek is lichtgewicht, afhankelijkheidsvrij, en integreert soepel in bestaande Go-toepassingen.
Installeer go-message via Go-modules
go get github.com/emersion/go-message
# Optional: enable full charset support
import _ "github.com/emersion/go-message/charset"
E-mailparsing via streaming
go-message biedt een streaming parser die e-mailberichten incrementeel verwerkt zonder de volledige inhoud in het geheugen te laden. Dit is vooral gunstig voor het verwerken van grote e-mails of mailverwerking met een hoog volume. De parser leest headers en body‑delen opeenvolgend, waardoor ontwikkelaars berichten in realtime kunnen inspecteren of doorsturen. Hij ondersteunt zowel RFC‑conforme als misvormde berichten op een elegante manier, waardoor hij geschikt is voor productie‑mailservers. Door gebruik te maken van Go’s `io.Reader` integreert de bibliotheek natuurlijk met netwerk‑ en bestands‑I/O‑operaties.
Hoe een e-mailbericht te parseren via de streaming-API?
import (
"bytes"
"github.com/emersion/go-message"
)
func parseEmail(data []byte) error {
r := bytes.NewReader(data)
m, err := message.Read(r)
if err != nil {
return err
}
// Access headers and body parts
return nil
}
MIME multipart-afhandeling
go-message ondersteunt volledig het parseren en genereren van MIME‑multipart‑berichten zoals gedefinieerd in RFC 2045 en RFC 2046. Ontwikkelaars kunnen complexe multipart‑structuren — inclusief geneste delen — navigeren met intuïtieve API’s. De bibliotheek decodeert automatisch overdrachts‑coderingen (bijv. base64, quoted‑printable) en biedt toegang tot individuele delen via de `Part`‑interface. Dit maakt robuuste e‑mailopbouw en het extraheren van bijlagen, HTML/tekst‑alternatieven en ingesloten bronnen mogelijk. De streaming‑karakteristiek zorgt voor efficiënte verwerking, zelfs voor grote multipart‑berichten met veel delen.
Hoe multipart-onderdelen uit een e-mail te extraheren?
import (
"github.com/emersion/go-message"
"github.com/emersion/go-message/textproto"
)
func extractParts(m *message.Message) error {
if m.Multipart() {
for _, p := range m.Parts() {
// Process each part (e.g., text, attachment)
mediaType, params, _ := p.Header.MediaType()
if mediaType == "text/plain" {
// Read plain text content
content, _ := io.ReadAll(p.Body)
}
}
}
return nil
}
Ondersteuning voor tekensets en codering
go-message omvat robuuste automatische charset- en coderingafhandeling voor e-mailheaders en de inhoud van het bericht. Het ondersteunt het decoderen van RFC 2047-gecodeerde headers (bijv. `=?utf-8?B?...?=`) en berichttekst in verschillende charsets (UTF-8, ISO-8859, enz.). Door het optionele `github.com/emersion/go-message/charset`-pakket te importeren, krijgen ontwikkelaars toegang tot alle geregistreerde IANA-charsets via `golang.org/x/text/encoding`. Dit zorgt voor een nauwkeurige weergave van internationale e-mailinhoud, inclusief niet‑Latijnse scripts en speciale symbolen, zonder handmatige charset-detectie of conversie.
Hoe een charset‑gecodeerde header te decoderen?
import (
"github.com/emersion/go-message"
_ "github.com/emersion/go-message/charset" // Enable all charsets
)
func decodeSubject(m *message.Message) (string, error) {
subject, err := m.Header.Get("Subject")
if err != nil {
return "", err
}
// Automatically decoded using registered charsets
return subject, nil
}
DKIM-vriendelijke berichtondertekening
go-message is ontworpen om DKIM-vriendelijk te zijn, waardoor naadloze integratie met cryptografische ondertekenings- en verificatiestromen mogelijk is. De streaming‑parser behoudt de integriteit van de berichtstructuur, waardoor ondertekenaars alleen de gecanoniseerde body en geselecteerde headers kunnen ondertekenen zonder opnieuw te coderen. De bibliotheek vermijdt onnodige transformaties (bijv. normalisatie van regeleinden) die DKIM‑handtekeningen kunnen breken. Ontwikkelaars kunnen e‑mailondertekenings‑pijplijnen bouwen door go-message te combineren met bibliotheken zoals `github.com/emersion/go-dkim`, waardoor naleving van RFC 6376 voor domein‑gebaseerde berichtauthenticatie wordt gegarandeerd.
Hoe een bericht voor DKIM‑ondertekening voor te bereiden?
import (
"bytes"
"github.com/emersion/go-message"
"github.com/emersion/go-message/textproto"
)
func prepareForDKIM(m *message.Message) (*bytes.Buffer, error) {
var buf bytes.Buffer
// Write canonicalized headers and body
h := m.Header
h.WriteTo(&buf)
buf.WriteString("\r\n")
if _, err := io.Copy(&buf, m.Body); err != nil {
return nil, err
}
return &buf, nil
}
