Merge pull request #249 from wneessen/feature/145_add-eml-parser-to-generate-msg-from-eml-files

This PR introduces an EML parser to go-mail. It allows to read generic EML data from a file, a string or a reader into a go-mail Msg struct. It supports all types of message parts and encodings. It should be able to recognize Mulitpart messages as well as attachments and embeds (inline attachments). This PR closes #145
Add error handling for writing EML string to temp file
2024-11-23 22:20:51 +01:00 · 2024-06-28 14:11:30 +02:00 · 2024-06-28 13:59:08 +02:00 · 2024-06-28 13:53:00 +02:00 · 2024-06-28 13:51:49 +02:00 · 2024-06-28 13:49:34 +02:00
13 changed files with 1406 additions and 17 deletions
--- a/README.md
+++ b/README.md
@ -57,6 +57,7 @@ Some of the features of this library:
 * [X] Debug logging of SMTP traffic
 * [X] Custom error types for delivery errors
 * [X] Custom dial-context functions for more control over the connection (proxing, DNS hooking, etc.)
+* [X] Output a go-mail message as EML file and parse EML file into a go-mail message

 go-mail works like a programatic email client and provides lots of methods and functionalities you would consider
 standard in a MUA.
--- a/doc.go
+++ b/doc.go
@ -6,4 +6,4 @@
 package mail

 // VERSION is used in the default user agent string
-const VERSION = "0.4.1"
+const VERSION = "0.4.2"
--- a/eml.go
+++ b/eml.go
@ -0,0 +1,418 @@
+// SPDX-FileCopyrightText: 2022-2023 The go-mail Authors
+//
+// SPDX-License-Identifier: MIT
+
+package mail
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"mime/quotedprintable"
+	netmail "net/mail"
+	"os"
+	"strings"
+)
+
+// EMLToMsgFromString will parse a given EML string and returns a pre-filled Msg pointer
+func EMLToMsgFromString(emlString string) (*Msg, error) {
+	eb := bytes.NewBufferString(emlString)
+	return EMLToMsgFromReader(eb)
+}
+
+// EMLToMsgFromReader will parse a reader that holds EML content and returns a pre-filled
+// Msg pointer
+func EMLToMsgFromReader(reader io.Reader) (*Msg, error) {
+	msg := &Msg{
+		addrHeader:    make(map[AddrHeader][]*netmail.Address),
+		genHeader:     make(map[Header][]string),
+		preformHeader: make(map[Header]string),
+		mimever:       MIME10,
+	}
+
+	parsedMsg, bodybuf, err := readEMLFromReader(reader)
+	if err != nil || parsedMsg == nil {
+		return msg, fmt.Errorf("failed to parse EML from reader: %w", err)
+	}
+
+	if err := parseEML(parsedMsg, bodybuf, msg); err != nil {
+		return msg, fmt.Errorf("failed to parse EML contents: %w", err)
+	}
+
+	return msg, nil
+}
+
+// EMLToMsgFromFile will open and parse a .eml file at a provided file path and returns a
+// pre-filled Msg pointer
+func EMLToMsgFromFile(filePath string) (*Msg, error) {
+	msg := &Msg{
+		addrHeader:    make(map[AddrHeader][]*netmail.Address),
+		genHeader:     make(map[Header][]string),
+		preformHeader: make(map[Header]string),
+		mimever:       MIME10,
+	}
+
+	parsedMsg, bodybuf, err := readEML(filePath)
+	if err != nil || parsedMsg == nil {
+		return msg, fmt.Errorf("failed to parse EML file: %w", err)
+	}
+
+	if err := parseEML(parsedMsg, bodybuf, msg); err != nil {
+		return msg, fmt.Errorf("failed to parse EML contents: %w", err)
+	}
+
+	return msg, nil
+}
+
+// parseEML parses the EML's headers and body and inserts the parsed values into the Msg
+func parseEML(parsedMsg *netmail.Message, bodybuf *bytes.Buffer, msg *Msg) error {
+	if err := parseEMLHeaders(&parsedMsg.Header, msg); err != nil {
+		return fmt.Errorf("failed to parse EML headers: %w", err)
+	}
+	if err := parseEMLBodyParts(parsedMsg, bodybuf, msg); err != nil {
+		return fmt.Errorf("failed to parse EML body parts: %w", err)
+	}
+	return nil
+}
+
+// readEML opens an EML file and uses net/mail to parse the header and body
+func readEML(filePath string) (*netmail.Message, *bytes.Buffer, error) {
+	fileHandle, err := os.Open(filePath)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to open EML file: %w", err)
+	}
+	defer func() {
+		_ = fileHandle.Close()
+	}()
+	return readEMLFromReader(fileHandle)
+}
+
+// readEMLFromReader uses net/mail to parse the header and body from a given io.Reader
+func readEMLFromReader(reader io.Reader) (*netmail.Message, *bytes.Buffer, error) {
+	parsedMsg, err := netmail.ReadMessage(reader)
+	if err != nil {
+		return parsedMsg, nil, fmt.Errorf("failed to parse EML: %w", err)
+	}
+
+	buf := bytes.Buffer{}
+	if _, err = buf.ReadFrom(parsedMsg.Body); err != nil {
+		return nil, nil, err
+	}
+
+	return parsedMsg, &buf, nil
+}
+
+// parseEMLHeaders will check the EML headers for the most common headers and set the
+// according settings in the Msg
+func parseEMLHeaders(mailHeader *netmail.Header, msg *Msg) error {
+	commonHeaders := []Header{
+		HeaderContentType, HeaderImportance, HeaderInReplyTo, HeaderListUnsubscribe,
+		HeaderListUnsubscribePost, HeaderMessageID, HeaderMIMEVersion, HeaderOrganization,
+		HeaderPrecedence, HeaderPriority, HeaderReferences, HeaderSubject, HeaderUserAgent,
+		HeaderXMailer, HeaderXMSMailPriority, HeaderXPriority,
+	}
+
+	// Extract content type, charset and encoding first
+	parseEMLEncoding(mailHeader, msg)
+	parseEMLContentTypeCharset(mailHeader, msg)
+
+	// Extract address headers
+	if value := mailHeader.Get(HeaderFrom.String()); value != "" {
+		if err := msg.From(value); err != nil {
+			return fmt.Errorf(`failed to parse %q header: %w`, HeaderFrom, err)
+		}
+	}
+	addrHeaders := map[AddrHeader]func(...string) error{
+		HeaderTo:  msg.To,
+		HeaderCc:  msg.Cc,
+		HeaderBcc: msg.Bcc,
+	}
+	for addrHeader, addrFunc := range addrHeaders {
+		if v := mailHeader.Get(addrHeader.String()); v != "" {
+			var addrStrings []string
+			parsedAddrs, err := netmail.ParseAddressList(v)
+			if err != nil {
+				return fmt.Errorf(`failed to parse address list: %w`, err)
+			}
+			for _, addr := range parsedAddrs {
+				addrStrings = append(addrStrings, addr.String())
+			}
+			if err = addrFunc(addrStrings...); err != nil {
+				return fmt.Errorf(`failed to parse %q header: %w`, addrHeader, err)
+			}
+		}
+	}
+
+	// Extract date from message
+	date, err := mailHeader.Date()
+	if err != nil {
+		switch {
+		case errors.Is(err, netmail.ErrHeaderNotPresent):
+			msg.SetDate()
+		default:
+			return fmt.Errorf("failed to parse EML date: %w", err)
+		}
+	}
+	if err == nil {
+		msg.SetDateWithValue(date)
+	}
+
+	// Extract common headers
+	for _, header := range commonHeaders {
+		if value := mailHeader.Get(header.String()); value != "" {
+			if strings.EqualFold(header.String(), HeaderContentType.String()) &&
+				strings.HasPrefix(value, TypeMultipartMixed.String()) {
+				continue
+			}
+			msg.SetGenHeader(header, value)
+		}
+	}
+
+	return nil
+}
+
+// parseEMLBodyParts parses the body of a EML based on the different content types and encodings
+func parseEMLBodyParts(parsedMsg *netmail.Message, bodybuf *bytes.Buffer, msg *Msg) error {
+	// Extract the transfer encoding of the body
+	mediatype, params, err := mime.ParseMediaType(parsedMsg.Header.Get(HeaderContentType.String()))
+	if err != nil {
+		return fmt.Errorf("failed to extract content type: %w", err)
+	}
+	if value, ok := params["charset"]; ok {
+		msg.SetCharset(Charset(value))
+	}
+
+	switch {
+	case strings.EqualFold(mediatype, TypeTextPlain.String()),
+		strings.EqualFold(mediatype, TypeTextHTML.String()):
+		if err = parseEMLBodyPlain(mediatype, parsedMsg, bodybuf, msg); err != nil {
+			return fmt.Errorf("failed to parse plain body: %w", err)
+		}
+	case strings.EqualFold(mediatype, TypeMultipartAlternative.String()),
+		strings.EqualFold(mediatype, TypeMultipartMixed.String()),
+		strings.EqualFold(mediatype, TypeMultipartRelated.String()):
+		if err = parseEMLMultipart(params, bodybuf, msg); err != nil {
+			return fmt.Errorf("failed to parse multipart body: %w", err)
+		}
+	default:
+		return fmt.Errorf("failed to parse body, unknown content type: %s", mediatype)
+	}
+	return nil
+}
+
+// parseEMLBodyPlain parses the mail body of plain type mails
+func parseEMLBodyPlain(mediatype string, parsedMsg *netmail.Message, bodybuf *bytes.Buffer, msg *Msg) error {
+	contentTransferEnc := parsedMsg.Header.Get(HeaderContentTransferEnc.String())
+	if strings.EqualFold(contentTransferEnc, NoEncoding.String()) {
+		msg.SetEncoding(NoEncoding)
+		msg.SetBodyString(ContentType(mediatype), bodybuf.String())
+		return nil
+	}
+	if strings.EqualFold(contentTransferEnc, EncodingQP.String()) {
+		msg.SetEncoding(EncodingQP)
+		qpReader := quotedprintable.NewReader(bodybuf)
+		qpBuffer := bytes.Buffer{}
+		if _, err := qpBuffer.ReadFrom(qpReader); err != nil {
+			return fmt.Errorf("failed to read quoted-printable body: %w", err)
+		}
+		msg.SetBodyString(ContentType(mediatype), qpBuffer.String())
+		return nil
+	}
+	if strings.EqualFold(contentTransferEnc, EncodingB64.String()) {
+		msg.SetEncoding(EncodingB64)
+		b64Decoder := base64.NewDecoder(base64.StdEncoding, bodybuf)
+		b64Buffer := bytes.Buffer{}
+		if _, err := b64Buffer.ReadFrom(b64Decoder); err != nil {
+			return fmt.Errorf("failed to read base64 body: %w", err)
+		}
+		msg.SetBodyString(ContentType(mediatype), b64Buffer.String())
+		return nil
+	}
+	return fmt.Errorf("unsupported Content-Transfer-Encoding")
+}
+
+// parseEMLMultipart parses a multipart body part of a EML
+func parseEMLMultipart(params map[string]string, bodybuf *bytes.Buffer, msg *Msg) error {
+	boundary, ok := params["boundary"]
+	if !ok {
+		return fmt.Errorf("no boundary tag found in multipart body")
+	}
+	multipartReader := multipart.NewReader(bodybuf, boundary)
+ReadNextPart:
+	multiPart, err := multipartReader.NextPart()
+	defer func() {
+		if multiPart != nil {
+			_ = multiPart.Close()
+		}
+	}()
+	if err != nil && !errors.Is(err, io.EOF) {
+		return fmt.Errorf("failed to get next part of multipart message: %w", err)
+	}
+	for err == nil {
+		// Multipart/related and Multipart/alternative parts need to be parsed seperately
+		if contentTypeSlice, ok := multiPart.Header[HeaderContentType.String()]; ok && len(contentTypeSlice) == 1 {
+			contentType, _ := parseMultiPartHeader(contentTypeSlice[0])
+			if strings.EqualFold(contentType, TypeMultipartRelated.String()) ||
+				strings.EqualFold(contentType, TypeMultipartAlternative.String()) {
+				relatedPart := &netmail.Message{
+					Header: netmail.Header(multiPart.Header),
+					Body:   multiPart,
+				}
+				relatedBuf := &bytes.Buffer{}
+				if _, err = relatedBuf.ReadFrom(multiPart); err != nil {
+					return fmt.Errorf("failed to read related multipart message to buffer: %w", err)
+				}
+				if err := parseEMLBodyParts(relatedPart, relatedBuf, msg); err != nil {
+					return fmt.Errorf("failed to parse related multipart body: %w", err)
+				}
+			}
+		}
+
+		// Content-Disposition header means we have an attachment or embed
+		if contentDisposition, ok := multiPart.Header[HeaderContentDisposition.String()]; ok {
+			if err = parseEMLAttachmentEmbed(contentDisposition, multiPart, msg); err != nil {
+				return fmt.Errorf("failed to parse attachment/embed: %w", err)
+			}
+			goto ReadNextPart
+		}
+
+		multiPartData, mperr := io.ReadAll(multiPart)
+		if mperr != nil {
+			_ = multiPart.Close()
+			return fmt.Errorf("failed to read multipart: %w", err)
+		}
+
+		multiPartContentType, ok := multiPart.Header[HeaderContentType.String()]
+		if !ok {
+			return fmt.Errorf("failed to get content-type from part")
+		}
+		contentType, optional := parseMultiPartHeader(multiPartContentType[0])
+		if strings.EqualFold(contentType, TypeMultipartRelated.String()) {
+			goto ReadNextPart
+		}
+		part := msg.newPart(ContentType(contentType))
+		if charset, ok := optional["charset"]; ok {
+			part.SetCharset(Charset(charset))
+		}
+
+		mutliPartTransferEnc, ok := multiPart.Header[HeaderContentTransferEnc.String()]
+		if !ok {
+			// If CTE is empty we can assume that it's a quoted-printable CTE since the
+			// GO stdlib multipart packages deletes that header
+			// See: https://cs.opensource.google/go/go/+/refs/tags/go1.22.0:src/mime/multipart/multipart.go;l=161
+			mutliPartTransferEnc = []string{EncodingQP.String()}
+		}
+
+		switch {
+		case strings.EqualFold(mutliPartTransferEnc[0], EncodingB64.String()):
+			if err := handleEMLMultiPartBase64Encoding(multiPartData, part); err != nil {
+				return fmt.Errorf("failed to handle multipart base64 transfer-encoding: %w", err)
+			}
+		case strings.EqualFold(mutliPartTransferEnc[0], EncodingQP.String()):
+			part.SetContent(string(multiPartData))
+		default:
+			return fmt.Errorf("unsupported Content-Transfer-Encoding")
+		}
+
+		msg.parts = append(msg.parts, part)
+		multiPart, err = multipartReader.NextPart()
+	}
+	if !errors.Is(err, io.EOF) {
+		return fmt.Errorf("failed to read multipart: %w", err)
+	}
+	return nil
+}
+
+// parseEMLEncoding parses and determines the encoding of the message
+func parseEMLEncoding(mailHeader *netmail.Header, msg *Msg) {
+	if value := mailHeader.Get(HeaderContentTransferEnc.String()); value != "" {
+		switch {
+		case strings.EqualFold(value, EncodingQP.String()):
+			msg.SetEncoding(EncodingQP)
+		case strings.EqualFold(value, EncodingB64.String()):
+			msg.SetEncoding(EncodingB64)
+		default:
+			msg.SetEncoding(NoEncoding)
+		}
+	}
+}
+
+// parseEMLContentTypeCharset parses and determines the charset and content type of the message
+func parseEMLContentTypeCharset(mailHeader *netmail.Header, msg *Msg) {
+	if value := mailHeader.Get(HeaderContentType.String()); value != "" {
+		contentType, optional := parseMultiPartHeader(value)
+		if charset, ok := optional["charset"]; ok {
+			msg.SetCharset(Charset(charset))
+		}
+		msg.setEncoder()
+		if contentType != "" && !strings.EqualFold(contentType, TypeMultipartMixed.String()) {
+			msg.SetGenHeader(HeaderContentType, contentType)
+		}
+	}
+}
+
+// handleEMLMultiPartBase64Encoding sets the content body of a base64 encoded Part
+func handleEMLMultiPartBase64Encoding(multiPartData []byte, part *Part) error {
+	part.SetEncoding(EncodingB64)
+	content, err := base64.StdEncoding.DecodeString(string(multiPartData))
+	if err != nil {
+		return fmt.Errorf("failed to decode base64 part: %w", err)
+	}
+	part.SetContent(string(content))
+	return nil
+}
+
+// parseMultiPartHeader parses a multipart header and returns the value and optional parts as
+// separate map
+func parseMultiPartHeader(multiPartHeader string) (header string, optional map[string]string) {
+	optional = make(map[string]string)
+	headerSplit := strings.SplitN(multiPartHeader, ";", 2)
+	header = headerSplit[0]
+	if len(headerSplit) == 2 {
+		optString := strings.TrimLeft(headerSplit[1], " ")
+		optSplit := strings.SplitN(optString, "=", 2)
+		if len(optSplit) == 2 {
+			optional[optSplit[0]] = optSplit[1]
+		}
+	}
+	return
+}
+
+// parseEMLAttachmentEmbed parses a multipart that is an attachment or embed
+func parseEMLAttachmentEmbed(contentDisposition []string, multiPart *multipart.Part, msg *Msg) error {
+	cdType, optional := parseMultiPartHeader(contentDisposition[0])
+	filename := "generic.attachment"
+	if name, ok := optional["filename"]; ok {
+		filename = name[1 : len(name)-1]
+	}
+
+	var dataReader io.Reader
+	dataReader = multiPart
+	contentTransferEnc, _ := parseMultiPartHeader(multiPart.Header.Get(HeaderContentTransferEnc.String()))
+	b64Decoder := base64.NewDecoder(base64.StdEncoding, multiPart)
+	if strings.EqualFold(contentTransferEnc, EncodingB64.String()) {
+		dataReader = b64Decoder
+	}
+
+	switch strings.ToLower(cdType) {
+	case "attachment":
+		if err := msg.AttachReader(filename, dataReader); err != nil {
+			return fmt.Errorf("failed to attach multipart body: %w", err)
+		}
+	case "inline":
+		if contentID, _ := parseMultiPartHeader(multiPart.Header.Get(HeaderContentID.String())); contentID != "" {
+			if err := msg.EmbedReader(filename, dataReader, WithFileContentID(contentID)); err != nil {
+				return fmt.Errorf("failed to embed multipart body: %w", err)
+			}
+			return nil
+		}
+		if err := msg.EmbedReader(filename, dataReader); err != nil {
+			return fmt.Errorf("failed to embed multipart body: %w", err)
+		}
+	}
+	return nil
+}
--- a/eml_test.go
+++ b/eml_test.go
@ -0,0 +1,881 @@
+// SPDX-FileCopyrightText: 2022-2023 The go-mail Authors
+//
+// SPDX-License-Identifier: MIT
+
+package mail
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+const (
+	exampleMailPlainNoEnc = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it
+should be wrapped.
+
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainBrokenBody = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: base64
+
+This plain text body should not be parsed as Base64.
+`
+	exampleMailPlainNoContentType = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+
+This plain text body should not be parsed as Base64.
+`
+	exampleMailPlainUnknownContentType = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: application/unknown; charset=UTF-8
+Content-Transfer-Encoding: base64
+
+This plain text body should not be parsed as Base64.
+`
+	exampleMailPlainBrokenHeader = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version = 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent = go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From = "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding = 8bit
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it
+should be wrapped.
+
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainBrokenFrom = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: Toni Tester" go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it
+should be wrapped.
+
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainBrokenTo = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: go-mail+test.go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it
+should be wrapped.
+
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainNoEncInvalidDate = `Date: Inv, 99 Nov 9999 99:99:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it
+should be wrapped.
+
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainNoEncNoDate = `MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text without encoding
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it
+should be wrapped.
+
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainQP = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text quoted-printable
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: quoted-printable
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very lo=
+ng so it
+should be wrapped.
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainUnsupportedTransferEnc = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text quoted-printable
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=ISO-8859-1
+Content-Transfer-Encoding: unknown
+
+Dear Customer,
+
+This is a test mail. Please do not reply to this. Also this line is very long so it should be wrapped.
+㋛
+This is not ==D3
+
+Thank your for your business!
+The go-mail team
+
+--
+This is a signature`
+	exampleMailPlainB64 = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64
+User-Agent: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.0 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: base64
+
+RGVhciBDdXN0b21lciwKClRoaXMgaXMgYSB0ZXN0IG1haWwuIFBsZWFzZSBkbyBub3QgcmVwbHkg
+dG8gdGhpcy4gQWxzbyB0aGlzIGxpbmUgaXMgdmVyeSBsb25nIHNvIGl0CnNob3VsZCBiZSB3cmFw
+cGVkLgoKClRoYW5rIHlvdXIgZm9yIHlvdXIgYnVzaW5lc3MhClRoZSBnby1tYWlsIHRlYW0KCi0t
+ClRoaXMgaXMgYSBzaWduYXR1cmU=`
+	exampleMailPlainB64WithAttachment = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64 with attachment
+User-Agent: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: multipart/mixed;
+ boundary=45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+Content-Transfer-Encoding: base64
+Content-Type: text/plain; charset=UTF-8
+
+RGVhciBDdXN0b21lciwKClRoaXMgaXMgYSB0ZXN0IG1haWwuIFBsZWFzZSBkbyBub3QgcmVwbHkg
+dG8gdGhpcy4gQWxzbyB0aGlzIGxpbmUgaXMgdmVyeSBsb25nIHNvIGl0CnNob3VsZCBiZSB3cmFw
+cGVkLgoKClRoYW5rIHlvdXIgZm9yIHlvdXIgYnVzaW5lc3MhClRoZSBnby1tYWlsIHRlYW0KCi0t
+ClRoaXMgaXMgYSBzaWduYXR1cmU=
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+Content-Disposition: attachment; filename="test.attachment"
+Content-Transfer-Encoding: base64
+Content-Type: application/octet-stream; name="test.attachment"
+
+VGhpcyBpcyBhIHNpbXBsZSB0ZXN0IHRleHQgZmlsZSBhdHRhY2htZW50LgoKSXQgCiAgaGFzCiAg
+ICAgc2V2ZXJhbAogICAgICAgICAgICBuZXdsaW5lcwoJICAgICAgICAgICAgYW5kCgkgICAgc3Bh
+Y2VzCiAgICAgaW4KICBpdAouCgpBcyB3ZWxsIGFzIGFuIGVtb2ppOiDwn5mCCg==
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7--`
+	exampleMailPlainB64WithAttachmentNoBoundary = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64 with attachment
+User-Agent: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: multipart/mixed;
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+Content-Transfer-Encoding: base64
+Content-Type: text/plain; charset=UTF-8
+
+RGVhciBDdXN0b21lciwKClRoaXMgaXMgYSB0ZXN0IG1haWwuIFBsZWFzZSBkbyBub3QgcmVwbHkg
+dG8gdGhpcy4gQWxzbyB0aGlzIGxpbmUgaXMgdmVyeSBsb25nIHNvIGl0CnNob3VsZCBiZSB3cmFw
+cGVkLgoKClRoYW5rIHlvdXIgZm9yIHlvdXIgYnVzaW5lc3MhClRoZSBnby1tYWlsIHRlYW0KCi0t
+ClRoaXMgaXMgYSBzaWduYXR1cmU=
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+Content-Disposition: attachment; filename="test.attachment"
+Content-Transfer-Encoding: base64
+Content-Type: application/octet-stream; name="test.attachment"
+
+VGhpcyBpcyBhIHNpbXBsZSB0ZXN0IHRleHQgZmlsZSBhdHRhY2htZW50LgoKSXQgCiAgaGFzCiAg
+ICAgc2V2ZXJhbAogICAgICAgICAgICBuZXdsaW5lcwoJICAgICAgICAgICAgYW5kCgkgICAgc3Bh
+Y2VzCiAgICAgaW4KICBpdAouCgpBcyB3ZWxsIGFzIGFuIGVtb2ppOiDwn5mCCg==
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7--`
+	exampleMailPlainB64BrokenBody = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64 with attachment
+User-Agent: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: multipart/mixed;
+ boundary=45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+Content-Transfer-Encoding = base64
+Content-Type = text/plain; charset=UTF-8
+
+RGVhciBDdXN0b21lciwKClRoaXMgaXMgYSB0ZXN0IG1haWwuIFBsZWFzZSBkbyBub3QgcmVwbHkg
+dG8gdGhpcy4gQWxzbyB0aGlzIGxpbmUgaXMgdmVyeSBsb25nIHNvIGl0CnNob3VsZCBiZSB3cmFw
+cGVkLgoKClRoYW5rIHlvdXIgZm9yIHlvdXIgYnVzaW5lc3MhClRoZSBnby1tYWlsIHRlYW0KCi0t
+ClRoaXMgaXMgYSBzaWduYXR1cmU=
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7
+Content-Disposition: attachment; filename="test.attachment"
+Content-Transfer-Encoding: base64
+Content-Type: application/octet-stream; name="test.attachment"
+
+VGhpcyBpcyBhIHNpbXBsZSB0ZXN0IHRleHQgZmlsZSBhdHRhY2htZW50LgoKSXQgCiAgaGFzCiAg
+ICAgc2V2ZXJhbAogICAgICAgICAgICBuZXdsaW5lcwoJICAgICAgICAgICAgYW5kCgkgICAgc3Bh
+Y2VzCiAgICAgaW4KICBpdAouCgpBcyB3ZWxsIGFzIGFuIGVtb2ppOiDwn5mCCg==
+
+--45c75ff528359022eb03679fbe91877d75343f2e1f8193e349deffa33ff7--`
+	exampleMailPlainB64WithEmbed = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64 with embed
+User-Agent: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: multipart/related;
+ boundary=ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b
+
+--ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/plain; charset=UTF-8
+
+This is a test body string
+--ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b
+Content-Disposition: inline; filename="pixel.png"
+Content-Id: <pixel.png>
+Content-Transfer-Encoding: base64
+Content-Type: image/png; name="pixel.png"
+
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgYGD4DwABBAEAwS2O
+UAAAAABJRU5ErkJggg==
+
+--ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b--`
+	exampleMailPlainB64WithEmbedNoContentID = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64 with embed
+User-Agent: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: multipart/related;
+ boundary=ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b
+
+--ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b
+Content-Transfer-Encoding: quoted-printable
+Content-Type: text/plain; charset=UTF-8
+
+This is a test body string
+--ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b
+Content-Disposition: inline; filename="pixel.png"
+Content-Transfer-Encoding: base64
+Content-Type: image/png; name="pixel.png"
+
+iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgYGD4DwABBAEAwS2O
+UAAAAABJRU5ErkJggg==
+
+--ffbcfb94b44e5297325102f6ced05b3b37f1d70fc38a5e78dc73c1a8434b--`
+	exampleMailMultipartMixedAlternativeRelated = `Date: Wed, 01 Nov 2023 00:00:00 +0000
+MIME-Version: 1.0
+Message-ID: <1305604950.683004066175.AAAAAAAAaaaaaaaaB@go-mail.dev>
+Subject: Example mail // plain text base64 with attachment, embed and alternative part
+User-Agent: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+X-Mailer: go-mail v0.4.1 // https://github.com/wneessen/go-mail
+From: "Toni Tester" <go-mail@go-mail.dev>
+To: <go-mail+test@go-mail.dev>
+Cc: <go-mail+cc@go-mail.dev>
+Content-Type: multipart/mixed;
+ boundary=fe785e0384e2607697cc2ecb17cce003003bb7ca9112104f3e8ce727edb5
+
+--fe785e0384e2607697cc2ecb17cce003003bb7ca9112104f3e8ce727edb5
+Content-Type: multipart/related;
+ boundary=5897e40a22c608e252cfab849e966112fcbd5a1c291208026b3ca2bfab8a
+
+
+
+--5897e40a22c608e252cfab849e966112fcbd5a1c291208026b3ca2bfab8a
+Content-Type: multipart/alternative;
+ boundary=cbace12de35ef4eae53fd974ccd41cb2aee4f9c9c76057ec8bfdd0c97813
+
+
+
+--cbace12de35ef4eae53fd974ccd41cb2aee4f9c9c76057ec8bfdd0c97813
+Content-Transfer-Encoding: base64
+Content-Type: text/plain; charset=UTF-8
+
+RGVhciBDdXN0b21lciwKCkdvb2QgbmV3cyEgWW91ciBvcmRlciBpcyBvbiB0aGUgd2F5IGFuZCBp
+bnZvaWNlIGlzIGF0dGFjaGVkIQoKWW91IHdpbGwgZmluZCB5b3VyIHRyYWNraW5nIG51bWJlciBv
+biB0aGUgaW52b2ljZS4gVHJhY2tpbmcgZGF0YSBtYXkgdGFrZQp1cCB0byAyNCBob3VycyB0byBi
+ZSBhY2Nlc3NpYmxlIG9ubGluZS4KCuKAoiBQbGVhc2UgcmVtaXQgcGF5bWVudCBhdCB5b3VyIGVh
+cmxpZXN0IGNvbnZlbmllbmNlIHVubGVzcyBpbnZvaWNlIGlzCm1hcmtlZCDigJxQQUlE4oCdLgri
+gKIgU29tZSBpdGVtcyBtYXkgc2hpcCBzZXBhcmF0ZWx5IGZyb20gbXVsdGlwbGUgbG9jYXRpb25z
+LiBTZXBhcmF0ZQppbnZvaWNlcyB3aWxsIGJlIGlzc3VlZCB3aGVuIGFwcGxpY2FibGUuCuKAoiBQ
+TEVBU0UgSU5TUEVDVCBVUE9OIFJFQ0VJUFQgRk9SIFBBVFRFUk4sIENPTE9SLCBERUZFQ1RTLCBE
+QU1BR0UgRlJPTQpTSElQUElORywgQ09SUkVDVCBZQVJEQUdFLCBFVEMhIE9uY2UgYW4gb3JkZXIg
+aXMgY3V0IG9yIHNld24sIG5vIHJldHVybnMKd2lsbCBiZSBhY2NlcHRlZCBmb3IgYW55IHJlYXNv
+biwgbm8gbWF0dGVyIHRoZSBwYXJ0eSBpbiBlcnJvci4gTm8gcmV0dXJucwp3aWxsIGJlIGF1dGhv
+cml6ZWQgYWZ0ZXIgMzAgZGF5cyBvZiBpbnZvaWNlIGRhdGUuIE5vIGV4Y2VwdGlvbnMgd2lsbCBi
+ZQptYWRlLgoKVGhhbmsgeW91ciBmb3IgeW91ciBidXNpbmVzcyEKCk5haWxkb2N0b3IgRmFicmlj
+cw==
+
+--cbace12de35ef4eae53fd974ccd41cb2aee4f9c9c76057ec8bfdd0c97813
+Content-Transfer-Encoding: base64
+Content-Type: text/html; charset=UTF-8
+
+PCFET0NUWVBFIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KPGJvZHk+CjxwPlRoaXMgaXMgSFRNTCA8
+c3Ryb25nPmluIEJPTEQ8L3N0cm9uZz4KPHA+ClRoaXMgaXMgYW4gZW1iZWRkZWQgcGljdHVyZTog
+CjxpbWcgYWx0PSJwaXhlbC5wbmciIHNyYz0iY2lkOmltYWdlMS5wbmciPgo8YnI+Rm9vPC9wPg==
+
+--cbace12de35ef4eae53fd974ccd41cb2aee4f9c9c76057ec8bfdd0c97813--
+
+--5897e40a22c608e252cfab849e966112fcbd5a1c291208026b3ca2bfab8a
+Content-Disposition: inline; filename="pixel.png"
+Content-Id: image1.png
+Content-Transfer-Encoding: base64
+Content-Type: image/png; name="pixel.png"
+
+iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAAAAACoWZBhAAAFEmlUWHRYTUw6Y29tLmFkb2JlLnht
+cAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQi
+Pz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUg
+NS41LjAiPgogPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIy
+LXJkZi1zeW50YXgtbnMjIj4KICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgeG1s
+bnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgeG1sbnM6cGhvdG9zaG9w
+PSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8xLjAvIgogICAgeG1sbnM6ZXhpZj0iaHR0
+cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iCiAgICB4bWxuczp0aWZmPSJodHRwOi8vbnMuYWRv
+YmUuY29tL3RpZmYvMS4wLyIKICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hh
+cC8xLjAvbW0vIgogICAgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9z
+VHlwZS9SZXNvdXJjZUV2ZW50IyIKICAgeG1wOkNyZWF0ZURhdGU9IjIwMjQtMDYtMjhUMTM6MjY6
+MDYrMDIwMCIKICAgeG1wOk1vZGlmeURhdGU9IjIwMjQtMDYtMjhUMTM6Mjc6MDgrMDI6MDAiCiAg
+IHhtcDpNZXRhZGF0YURhdGU9IjIwMjQtMDYtMjhUMTM6Mjc6MDgrMDI6MDAiCiAgIHBob3Rvc2hv
+cDpEYXRlQ3JlYXRlZD0iMjAyNC0wNi0yOFQxMzoyNjowNiswMjAwIgogICBwaG90b3Nob3A6Q29s
+b3JNb2RlPSIxIgogICBwaG90b3Nob3A6SUNDUHJvZmlsZT0iR3JleXNjYWxlIEQ1MCIKICAgZXhp
+ZjpQaXhlbFhEaW1lbnNpb249IjEwIgogICBleGlmOlBpeGVsWURpbWVuc2lvbj0iMTAiCiAgIGV4
+aWY6Q29sb3JTcGFjZT0iNjU1MzUiCiAgIHRpZmY6SW1hZ2VXaWR0aD0iMTAiCiAgIHRpZmY6SW1h
+Z2VMZW5ndGg9IjEwIgogICB0aWZmOlJlc29sdXRpb25Vbml0PSIyIgogICB0aWZmOlhSZXNvbHV0
+aW9uPSI3Mi8xIgogICB0aWZmOllSZXNvbHV0aW9uPSI3Mi8xIj4KICAgPHhtcE1NOkhpc3Rvcnk+
+CiAgICA8cmRmOlNlcT4KICAgICA8cmRmOmxpCiAgICAgIHN0RXZ0OmFjdGlvbj0icHJvZHVjZWQi
+CiAgICAgIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFmZmluaXR5IFBob3RvIDIgMi4zLjAiCiAgICAg
+IHN0RXZ0OndoZW49IjIwMjQtMDYtMjhUMTM6Mjc6MDgrMDI6MDAiLz4KICAgIDwvcmRmOlNlcT4K
+ICAgPC94bXBNTTpIaXN0b3J5PgogIDwvcmRmOkRlc2NyaXB0aW9uPgogPC9yZGY6UkRGPgo8L3g6
+eG1wbWV0YT4KPD94cGFja2V0IGVuZD0iciI/PpwIGG4AAADdaUNDUEdyZXlzY2FsZSBENTAAABiV
+dVC9CsJAGEul6KCDg4vSoQ+gIIjiKoou6qAVrLiUs/5gq8e1In0v30TwGRycnc0VcRD9IJdwfMmR
+A4xlIMLIrAPhIVaDSceduws7d0cWFvIow/JEJEfTvoO/87zB0Hyt6az/ez/HXPmRIF+IlpAqJj+I
+4TmW1EaburR3Jl3qIXUxDE7i7dWvFvzDbEquEBYGUPCRIIKAh4DaRg9N6H6/ffXUN8aRm4KnpFth
+hw22iFHl7YlpOmedZvtMTfQffXeXnvI+rTKNxguyvDKvB7U4qQAAAAlwSFlzAAALEwAACxMBAJqc
+GAAAABFJREFUCJljnMoAA0wMNGcCAEQrAKk9oHKhAAAAAElFTkSuQmCC
+
+--5897e40a22c608e252cfab849e966112fcbd5a1c291208026b3ca2bfab8a--
+
+--fe785e0384e2607697cc2ecb17cce003003bb7ca9112104f3e8ce727edb5
+Content-Disposition: attachment; filename="attachment.png"
+Content-Transfer-Encoding: base64
+Content-Type: image/png; name="attachment.png"
+
+iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAAAAACoWZBhAAAFEmlUWHRYTUw6Y29tLmFkb2JlLnht
+cAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQi
+Pz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUg
+NS41LjAiPgogPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIy
+LXJkZi1zeW50YXgtbnMjIj4KICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgeG1s
+bnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIgogICAgeG1sbnM6cGhvdG9zaG9w
+PSJodHRwOi8vbnMuYWRvYmUuY29tL3Bob3Rvc2hvcC8xLjAvIgogICAgeG1sbnM6ZXhpZj0iaHR0
+cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iCiAgICB4bWxuczp0aWZmPSJodHRwOi8vbnMuYWRv
+YmUuY29tL3RpZmYvMS4wLyIKICAgIHhtbG5zOnhtcE1NPSJodHRwOi8vbnMuYWRvYmUuY29tL3hh
+cC8xLjAvbW0vIgogICAgeG1sbnM6c3RFdnQ9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9z
+VHlwZS9SZXNvdXJjZUV2ZW50IyIKICAgeG1wOkNyZWF0ZURhdGU9IjIwMjQtMDYtMjhUMTM6MjY6
+MDYrMDIwMCIKICAgeG1wOk1vZGlmeURhdGU9IjIwMjQtMDYtMjhUMTM6Mjc6MDgrMDI6MDAiCiAg
+IHhtcDpNZXRhZGF0YURhdGU9IjIwMjQtMDYtMjhUMTM6Mjc6MDgrMDI6MDAiCiAgIHBob3Rvc2hv
+cDpEYXRlQ3JlYXRlZD0iMjAyNC0wNi0yOFQxMzoyNjowNiswMjAwIgogICBwaG90b3Nob3A6Q29s
+b3JNb2RlPSIxIgogICBwaG90b3Nob3A6SUNDUHJvZmlsZT0iR3JleXNjYWxlIEQ1MCIKICAgZXhp
+ZjpQaXhlbFhEaW1lbnNpb249IjEwIgogICBleGlmOlBpeGVsWURpbWVuc2lvbj0iMTAiCiAgIGV4
+aWY6Q29sb3JTcGFjZT0iNjU1MzUiCiAgIHRpZmY6SW1hZ2VXaWR0aD0iMTAiCiAgIHRpZmY6SW1h
+Z2VMZW5ndGg9IjEwIgogICB0aWZmOlJlc29sdXRpb25Vbml0PSIyIgogICB0aWZmOlhSZXNvbHV0
+aW9uPSI3Mi8xIgogICB0aWZmOllSZXNvbHV0aW9uPSI3Mi8xIj4KICAgPHhtcE1NOkhpc3Rvcnk+
+CiAgICA8cmRmOlNlcT4KICAgICA8cmRmOmxpCiAgICAgIHN0RXZ0OmFjdGlvbj0icHJvZHVjZWQi
+CiAgICAgIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFmZmluaXR5IFBob3RvIDIgMi4zLjAiCiAgICAg
+IHN0RXZ0OndoZW49IjIwMjQtMDYtMjhUMTM6Mjc6MDgrMDI6MDAiLz4KICAgIDwvcmRmOlNlcT4K
+ICAgPC94bXBNTTpIaXN0b3J5PgogIDwvcmRmOkRlc2NyaXB0aW9uPgogPC9yZGY6UkRGPgo8L3g6
+eG1wbWV0YT4KPD94cGFja2V0IGVuZD0iciI/PpwIGG4AAADdaUNDUEdyZXlzY2FsZSBENTAAABiV
+dVC9CsJAGEul6KCDg4vSoQ+gIIjiKoou6qAVrLiUs/5gq8e1In0v30TwGRycnc0VcRD9IJdwfMmR
+A4xlIMLIrAPhIVaDSceduws7d0cWFvIow/JEJEfTvoO/87zB0Hyt6az/ez/HXPmRIF+IlpAqJj+I
+4TmW1EaburR3Jl3qIXUxDE7i7dWvFvzDbEquEBYGUPCRIIKAh4DaRg9N6H6/ffXUN8aRm4KnpFth
+hw22iFHl7YlpOmedZvtMTfQffXeXnvI+rTKNxguyvDKvB7U4qQAAAAlwSFlzAAALEwAACxMBAJqc
+GAAAABFJREFUCJljnMoAA0wMNGcCAEQrAKk9oHKhAAAAAElFTkSuQmCC
+
+--fe785e0384e2607697cc2ecb17cce003003bb7ca9112104f3e8ce727edb5--`
+)
+
+func TestEMLToMsgFromString(t *testing.T) {
+	tests := []struct {
+		name string
+		eml  string
+		enc  string
+		sub  string
+	}{
+		{
+			"Plain text no encoding", exampleMailPlainNoEnc, "8bit",
+			"Example mail // plain text without encoding",
+		},
+		{
+			"Plain text quoted-printable", exampleMailPlainQP, "quoted-printable",
+			"Example mail // plain text quoted-printable",
+		},
+		{
+			"Plain text base64", exampleMailPlainB64, "base64",
+			"Example mail // plain text base64",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			msg, err := EMLToMsgFromString(tt.eml)
+			if err != nil {
+				t.Errorf("failed to parse EML: %s", err)
+			}
+			if msg.Encoding() != tt.enc {
+				t.Errorf("EMLToMsgFromString failed: expected encoding: %s, but got: %s", tt.enc, msg.Encoding())
+			}
+			if subject := msg.GetGenHeader(HeaderSubject); len(subject) > 0 && !strings.EqualFold(subject[0], tt.sub) {
+				t.Errorf("EMLToMsgFromString failed: expected subject: %s, but got: %s",
+					tt.sub, subject[0])
+			}
+		})
+	}
+}
+
+func TestEMLToMsgFromFile(t *testing.T) {
+	tests := []struct {
+		name string
+		eml  string
+		enc  string
+		sub  string
+	}{
+		{
+			"Plain text no encoding", exampleMailPlainNoEnc, "8bit",
+			"Example mail // plain text without encoding",
+		},
+		{
+			"Plain text quoted-printable", exampleMailPlainQP, "quoted-printable",
+			"Example mail // plain text quoted-printable",
+		},
+		{
+			"Plain text base64", exampleMailPlainB64, "base64",
+			"Example mail // plain text base64",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tempDir, tempFile, err := stringToTempFile(tt.eml, tt.name)
+			defer func() {
+				if err = os.RemoveAll(tempDir); err != nil {
+					t.Error("failed to remove temp dir:", err)
+				}
+			}()
+			msg, err := EMLToMsgFromFile(tempFile)
+			if err != nil {
+				t.Errorf("failed to parse EML: %s", err)
+			}
+			if msg.Encoding() != tt.enc {
+				t.Errorf("EMLToMsgFromString failed: expected encoding: %s, but got: %s", tt.enc, msg.Encoding())
+			}
+			if subject := msg.GetGenHeader(HeaderSubject); len(subject) > 0 && !strings.EqualFold(subject[0], tt.sub) {
+				t.Errorf("EMLToMsgFromString failed: expected subject: %s, but got: %s",
+					tt.sub, subject[0])
+			}
+		})
+	}
+}
+
+func TestEMLToMsgFromReaderFailing(t *testing.T) {
+	mailbuf := bytes.NewBufferString(exampleMailPlainBrokenFrom)
+	_, err := EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with broken FROM was supposed to fail, but didn't")
+	}
+	mailbuf.Reset()
+	mailbuf.WriteString(exampleMailPlainBrokenHeader)
+	_, err = EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with broken header was supposed to fail, but didn't")
+	}
+	mailbuf.Reset()
+	mailbuf.WriteString(exampleMailPlainB64BrokenBody)
+	_, err = EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with broken body was supposed to fail, but didn't")
+	}
+	mailbuf.Reset()
+	mailbuf.WriteString(exampleMailPlainBrokenBody)
+	_, err = EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with broken body was supposed to fail, but didn't")
+	}
+	mailbuf.Reset()
+	mailbuf.WriteString(exampleMailPlainUnknownContentType)
+	_, err = EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with unknown content type was supposed to fail, but didn't")
+	}
+	mailbuf.Reset()
+	mailbuf.WriteString(exampleMailPlainNoContentType)
+	_, err = EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with no content type was supposed to fail, but didn't")
+	}
+	mailbuf.Reset()
+	mailbuf.WriteString(exampleMailPlainUnsupportedTransferEnc)
+	_, err = EMLToMsgFromReader(mailbuf)
+	if err == nil {
+		t.Error("EML from Reader with unsupported Transer-Encoding was supposed to fail, but didn't")
+	}
+}
+
+func TestEMLToMsgFromFileFailing(t *testing.T) {
+	tempDir, tempFile, err := stringToTempFile(exampleMailPlainBrokenFrom, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with broken FROM was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+	tempDir, tempFile, err = stringToTempFile(exampleMailPlainBrokenHeader, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with broken header was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+	tempDir, tempFile, err = stringToTempFile(exampleMailPlainB64BrokenBody, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with broken body was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+	tempDir, tempFile, err = stringToTempFile(exampleMailPlainBrokenBody, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with broken body was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+	tempDir, tempFile, err = stringToTempFile(exampleMailPlainUnknownContentType, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with unknown content type was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+	tempDir, tempFile, err = stringToTempFile(exampleMailPlainNoContentType, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with no content type was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+	tempDir, tempFile, err = stringToTempFile(exampleMailPlainUnsupportedTransferEnc, "testmail")
+	if err != nil {
+		t.Errorf("failed to write EML string to temp file: %s", err)
+	}
+	_, err = EMLToMsgFromFile(tempFile)
+	if err == nil {
+		t.Error("EML from Reader with unsupported Transer-Encoding was supposed to fail, but didn't")
+	}
+	if err = os.RemoveAll(tempDir); err != nil {
+		t.Error("failed to remove temp dir:", err)
+	}
+}
+
+func TestEMLToMsgFromStringBrokenDate(t *testing.T) {
+	_, err := EMLToMsgFromString(exampleMailPlainNoEncInvalidDate)
+	if err == nil {
+		t.Error("EML with invalid date was supposed to fail, but didn't")
+	}
+	now := time.Now()
+	m, err := EMLToMsgFromString(exampleMailPlainNoEncNoDate)
+	if err != nil {
+		t.Errorf("EML with no date parsing failed: %s", err)
+	}
+	da := m.GetGenHeader(HeaderDate)
+	if len(da) < 1 {
+		t.Error("EML with no date expected current date, but got nothing")
+		return
+	}
+	d := da[0]
+	if d != now.Format(time.RFC1123Z) {
+		t.Errorf("EML with no date expected: %s, got: %s", now.Format(time.RFC1123Z), d)
+	}
+}
+
+func TestEMLToMsgFromStringBrokenFrom(t *testing.T) {
+	_, err := EMLToMsgFromString(exampleMailPlainBrokenFrom)
+	if err == nil {
+		t.Error("EML with broken FROM was supposed to fail, but didn't")
+	}
+}
+
+func TestEMLToMsgFromStringBrokenTo(t *testing.T) {
+	_, err := EMLToMsgFromString(exampleMailPlainBrokenTo)
+	if err == nil {
+		t.Error("EML with broken TO was supposed to fail, but didn't")
+	}
+}
+
+func TestEMLToMsgFromStringNoBoundary(t *testing.T) {
+	_, err := EMLToMsgFromString(exampleMailPlainB64WithAttachmentNoBoundary)
+	if err == nil {
+		t.Error("EML with no boundary was supposed to fail, but didn't")
+	}
+}
+
+func TestEMLToMsgFromStringWithAttachment(t *testing.T) {
+	wantSubject := "Example mail // plain text base64 with attachment"
+	msg, err := EMLToMsgFromString(exampleMailPlainB64WithAttachment)
+	if err != nil {
+		t.Errorf("EML with attachment failed: %s", err)
+	}
+	if subject := msg.GetGenHeader(HeaderSubject); len(subject) > 0 && !strings.EqualFold(subject[0], wantSubject) {
+		t.Errorf("EMLToMsgFromString of EML with attachment failed: expected subject: %s, but got: %s",
+			wantSubject, subject[0])
+	}
+	if len(msg.attachments) != 1 {
+		t.Errorf("EMLToMsgFromString of EML with attachment failed: expected no. of attachments: %d, but got: %d",
+			1, len(msg.attachments))
+	}
+}
+
+func TestEMLToMsgFromStringWithEmbed(t *testing.T) {
+	wantSubject := "Example mail // plain text base64 with embed"
+	msg, err := EMLToMsgFromString(exampleMailPlainB64WithEmbed)
+	if err != nil {
+		t.Errorf("EML with embed failed: %s", err)
+	}
+	if subject := msg.GetGenHeader(HeaderSubject); len(subject) > 0 && !strings.EqualFold(subject[0], wantSubject) {
+		t.Errorf("EMLToMsgFromString of EML with embed failed: expected subject: %s, but got: %s",
+			wantSubject, subject[0])
+	}
+	if len(msg.embeds) != 1 {
+		t.Errorf("EMLToMsgFromString of EML with embed failed: expected no. of embeds: %d, but got: %d",
+			1, len(msg.embeds))
+	}
+	msg, err = EMLToMsgFromString(exampleMailPlainB64WithEmbedNoContentID)
+	if err != nil {
+		t.Errorf("EML with embed failed: %s", err)
+	}
+	if subject := msg.GetGenHeader(HeaderSubject); len(subject) > 0 && !strings.EqualFold(subject[0], wantSubject) {
+		t.Errorf("EMLToMsgFromString of EML with embed failed: expected subject: %s, but got: %s",
+			wantSubject, subject[0])
+	}
+	if len(msg.embeds) != 1 {
+		t.Errorf("EMLToMsgFromString of EML with embed failed: expected no. of embeds: %d, but got: %d",
+			1, len(msg.embeds))
+	}
+}
+
+func TestEMLToMsgFromStringMultipartMixedAlternativeRelated(t *testing.T) {
+	wantSubject := "Example mail // plain text base64 with attachment, embed and alternative part"
+	msg, err := EMLToMsgFromString(exampleMailMultipartMixedAlternativeRelated)
+	if err != nil {
+		t.Errorf("EML multipart mixed, related, alternative failed: %s", err)
+	}
+	if subject := msg.GetGenHeader(HeaderSubject); len(subject) > 0 && !strings.EqualFold(subject[0], wantSubject) {
+		t.Errorf("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected subject: %s,"+
+			" but got: %s", wantSubject, subject[0])
+	}
+	if len(msg.embeds) != 1 {
+		t.Errorf("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected no. of "+
+			"embeds: %d, but got: %d", 1, len(msg.embeds))
+	}
+	if len(msg.attachments) != 1 {
+		t.Errorf("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected no. of "+
+			"attachments: %d, but got: %d", 1, len(msg.attachments))
+	}
+	if len(msg.parts) != 3 {
+		t.Errorf("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected no. of "+
+			"parts: %d, but got: %d", 3, len(msg.parts))
+	}
+
+	var hasPlain, hasHTML, hasAlternative bool
+	for _, part := range msg.parts {
+		if strings.EqualFold(part.contentType.String(), TypeMultipartAlternative.String()) {
+			hasAlternative = true
+		}
+		if strings.EqualFold(part.contentType.String(), TypeTextPlain.String()) {
+			hasPlain = true
+		}
+		if strings.EqualFold(part.contentType.String(), TypeTextHTML.String()) {
+			hasHTML = true
+		}
+	}
+	if !hasPlain {
+		t.Error("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected PLAIN " +
+			"but got none")
+	}
+	if !hasHTML {
+		t.Error("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected HTML " +
+			"but got none")
+	}
+	if !hasAlternative {
+		t.Error("EMLToMsgFromString of EML multipart mixed, related, alternative failed: expected Alternative " +
+			"but got none")
+	}
+}
+
+// stringToTempFile is a helper method that will create a temporary file form a give data string
+func stringToTempFile(data, name string) (string, string, error) {
+	tempDir, err := os.MkdirTemp("", fmt.Sprintf("*-%s", name))
+	if err != nil {
+		return tempDir, "", fmt.Errorf("failed to create temp dir: %w", err)
+	}
+	filePath := fmt.Sprintf("%s/%s", tempDir, name)
+	err = os.WriteFile(filePath, []byte(data), 0o666)
+	if err != nil {
+		return tempDir, "", fmt.Errorf("failed to write data to temp file: %w", err)
+	}
+	return tempDir, filePath, nil
+}
--- a/encoding.go
+++ b/encoding.go
@ -132,17 +132,20 @@ const (

 // List of MIME versions
 const (
-	// Mime10 is the MIME Version 1.0
-	Mime10 MIMEVersion = "1.0"
+	// MIME10 is the MIME Version 1.0
+	MIME10 MIMEVersion = "1.0"
 )

 // List of common content types
 const (
-	TypeTextPlain      ContentType = "text/plain"
-	TypeTextHTML       ContentType = "text/html"
-	TypeAppOctetStream ContentType = "application/octet-stream"
-	TypePGPSignature   ContentType = "application/pgp-signature"
-	TypePGPEncrypted   ContentType = "application/pgp-encrypted"
+	TypeAppOctetStream       ContentType = "application/octet-stream"
+	TypeMultipartAlternative ContentType = "multipart/alternative"
+	TypeMultipartMixed       ContentType = "multipart/mixed"
+	TypeMultipartRelated     ContentType = "multipart/related"
+	TypePGPSignature         ContentType = "application/pgp-signature"
+	TypePGPEncrypted         ContentType = "application/pgp-encrypted"
+	TypeTextHTML             ContentType = "text/html"
+	TypeTextPlain            ContentType = "text/plain"
 )

 // List of MIMETypes
@ -152,12 +155,17 @@ const (
 	MIMERelated     MIMEType = "related"
 )

-// String is a standard method to convert an Encoding into a printable format
-func (e Encoding) String() string {
-	return string(e)
-}
-
 // String is a standard method to convert an Charset into a printable format
 func (c Charset) String() string {
 	return string(c)
 }
+
+// String is a standard method to convert an ContentType into a printable format
+func (c ContentType) String() string {
+	return string(c)
+}
+
+// String is a standard method to convert an Encoding into a printable format
+func (e Encoding) String() string {
+	return string(e)
+}
--- a/encoding_test.go
+++ b/encoding_test.go
@ -27,6 +27,50 @@ func TestEncoding_String(t *testing.T) {
 	}
 }

+// TestContentType_String tests the string method of the ContentType object
+func TestContentType_String(t *testing.T) {
+	tests := []struct {
+		name string
+		ct   ContentType
+		want string
+	}{
+		{"ContentType: text/plain", TypeTextPlain, "text/plain"},
+		{"ContentType: text/html", TypeTextHTML, "text/html"},
+		{
+			"ContentType: application/octet-stream", TypeAppOctetStream,
+			"application/octet-stream",
+		},
+		{
+			"ContentType: multipart/alternative", TypeMultipartAlternative,
+			"multipart/alternative",
+		},
+		{
+			"ContentType: multipart/mixed", TypeMultipartMixed,
+			"multipart/mixed",
+		},
+		{
+			"ContentType: multipart/related", TypeMultipartRelated,
+			"multipart/related",
+		},
+		{
+			"ContentType: application/pgp-signature", TypePGPSignature,
+			"application/pgp-signature",
+		},
+		{
+			"ContentType: application/pgp-encrypted", TypePGPEncrypted,
+			"application/pgp-encrypted",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if tt.ct.String() != tt.want {
+				t.Errorf("wrong string for Content-Type returned. Expected: %s, got: %s",
+					tt.want, tt.ct.String())
+			}
+		})
+	}
+}
+
 // TestCharset_String tests the string method of the Charset object
 func TestCharset_String(t *testing.T) {
 	tests := []struct {
--- a/file.go
+++ b/file.go
@ -22,6 +22,13 @@ type File struct {
 	Writer      func(w io.Writer) (int64, error)
 }

+// WithFileContentID sets the Content-ID header for the File
+func WithFileContentID(id string) FileOption {
+	return func(f *File) {
+		f.Header.Set(HeaderContentID.String(), id)
+	}
+}
+
 // WithFileName sets the filename of the File
 func WithFileName(name string) FileOption {
 	return func(f *File) {
--- a/file_test.go
+++ b/file_test.go
@ -56,6 +56,32 @@ func TestFile_WithFileDescription(t *testing.T) {
 	}
 }

+// TestFile_WithContentID tests the WithFileContentID option
+func TestFile_WithContentID(t *testing.T) {
+	tests := []struct {
+		name      string
+		contentid string
+	}{
+		{"File Content-ID: test", "test"},
+		{"File Content-ID: empty", ""},
+	}
+	for _, tt := range tests {
+		m := NewMsg()
+		t.Run(tt.name, func(t *testing.T) {
+			m.AttachFile("file.go", WithFileContentID(tt.contentid))
+			al := m.GetAttachments()
+			if len(al) <= 0 {
+				t.Errorf("AttachFile() failed. Attachment list is empty")
+			}
+			a := al[0]
+			if a.Header.Get(HeaderContentID.String()) != tt.contentid {
+				t.Errorf("WithFileContentID() failed. Expected: %s, got: %s", tt.contentid,
+					a.Header.Get(HeaderContentID.String()))
+			}
+		})
+	}
+}
+
 // TestFile_WithFileEncoding tests the WithFileEncoding option
 func TestFile_WithFileEncoding(t *testing.T) {
 	tests := []struct {
--- a/header.go
+++ b/header.go
@ -73,6 +73,9 @@ const (
 	// HeaderPriority represents the "Priority" field
 	HeaderPriority Header = "Priority"

+	// HeaderReferences is the "References" header field
+	HeaderReferences Header = "References"
+
 	// HeaderReplyTo is the "Reply-To" header field
 	HeaderReplyTo Header = "Reply-To"

--- a/header_test.go
+++ b/header_test.go
@ -87,6 +87,7 @@ func TestHeader_String(t *testing.T) {
 		{"Header: Organization", HeaderOrganization, "Organization"},
 		{"Header: Precedence", HeaderPrecedence, "Precedence"},
 		{"Header: Priority", HeaderPriority, "Priority"},
+		{"Header: HeaderReferences", HeaderReferences, "References"},
 		{"Header: Reply-To", HeaderReplyTo, "Reply-To"},
 		{"Header: Subject", HeaderSubject, "Subject"},
 		{"Header: User-Agent", HeaderUserAgent, "User-Agent"},
--- a/msg.go
+++ b/msg.go
@ -136,7 +136,7 @@ func NewMsg(opts ...MsgOption) *Msg {
 		encoding:      EncodingQP,
 		genHeader:     make(map[Header][]string),
 		preformHeader: make(map[Header]string),
-		mimever:       Mime10,
+		mimever:       MIME10,
 	}

 	// Override defaults with optionally provided MsgOption functions
--- a/msg_test.go
+++ b/msg_test.go
@ -137,7 +137,7 @@ func TestNewMsgWithMIMEVersion(t *testing.T) {
 		value MIMEVersion
 		want  MIMEVersion
 	}{
-		{"MIME version is 1.0", Mime10, "1.0"},
+		{"MIME version is 1.0", MIME10, "1.0"},
 	}

 	for _, tt := range tests {
--- a/msgwriter.go
+++ b/msgwriter.go
@ -89,11 +89,11 @@ func (mw *msgWriter) writeMsg(msg *Msg) {
 	}

 	if msg.hasMixed() {
-		mw.startMP("mixed", msg.boundary)
+		mw.startMP(MIMEMixed, msg.boundary)
 		mw.writeString(DoubleNewLine)
 	}
 	if msg.hasRelated() {
-		mw.startMP("related", msg.boundary)
+		mw.startMP(MIMERelated, msg.boundary)
 		mw.writeString(DoubleNewLine)
 	}
 	if msg.hasAlt() {
Author	SHA1	Message	Date
Winni Neessen	ffdea8337e	Merge pull request #249 from wneessen/feature/145_add-eml-parser-to-generate-msg-from-eml-files This PR introduces an EML parser to go-mail. It allows to read generic EML data from a file, a string or a reader into a go-mail Msg struct. It supports all types of message parts and encodings. It should be able to recognize Mulitpart messages as well as attachments and embeds (inline attachments). This PR closes #145	2024-06-28 14:11:30 +02:00
Winni Neessen	7e4bb00538	Add error handling for writing EML string to temp file Added conditional statements to handle potential failures when writing the EML string to the temporary files during testing. These updates ensure test failures due to write errors are accurately reflected in test results. Also, a minor fix is implemented on file permission in the os.WriteFile function.	2024-06-28 13:59:08 +02:00
Winni Neessen	d9290973be	Bump version to 0.4.2	2024-06-28 13:53:00 +02:00
Winni Neessen	2fa52e5341	Add EML file support to go-mail in README The README has been updated to show that go-mail now supports outputting a message as an EML file and parsing an EML file into a go-mail message. This addition enhances the flexibility and control over the email content and format.	2024-06-28 13:51:49 +02:00
Winni Neessen	8924e426d6	Add test for WithFileContentID option The change introduces a new unit test, TestFile_WithContentID, in file_test.go. This test aims to verify the correct function of the WithFileContentID option by using differing scenarios, with assertions for error control and validation of expected content.	2024-06-28 13:49:34 +02:00
Winni Neessen	4e7082a540	Rename WithContentID to WithFileContentID In the eml.go and file.go files, the function WithContentID has been renamed to WithFileContentID. This aligns more accurately with the function purpose, which is to set the content ID for a File object.	2024-06-28 13:49:21 +02:00
Winni Neessen	ca201b1548	Add tests for various email scenarios This commit introduces tests for different email scenarios including emails with no boundaries, emails with attachments, emails with embedded items, and multipart mixed emails. The tests ensure that the code correctly returns all expected parts of the email (e.g., embeds, attachments, parts) and that it correctly processes the email subject.	2024-06-28 13:45:22 +02:00
Winni Neessen	68d0fe9cd3	Remove debug print statement from eml.go The debug print statement that outputs the content type of the email has been removed from eml.go. This change improves code cleanliness and avoids unnecessary console output in production.	2024-06-28 13:33:57 +02:00
Winni Neessen	0bf3f73e9b	Update comment in eml.go for parsing multipart messages The comment in the eml.go file was extended to include the possibility of 'Multipart/alternative' parts. Previously, it only mentioned 'Multipart/related' parts. The actual code functionality remains unchanged, this is purely a clarification in the documentation.	2024-06-28 13:28:57 +02:00
Winni Neessen	fcc5209852	Add handling for multipart/alternative content type The EML parser now includes logic to manage 'multipart/alternative' content types. This adjustment is made within the section handling 'multipart/related' parts, allowing for better handling and parsing of varying content types.	2024-06-28 13:28:09 +02:00
Winni Neessen	84e6275cb2	Add base64 encoding support to email attachments The updated code adds base64 encoding support to email attachments and inline content in eml.go. It does this by introducing a new dataReader which uses a base64 decoder if the content transfer encoding is base64. With this update, attachments with base64 content will be correctly decoded when processed.	2024-06-28 11:54:30 +02:00
Winni Neessen	b709df4b2d	Add WithContentID function to file.go The newly added function, WithContentID, allows for setting the Content-ID header for the File. This provides enhanced handling and differentiation of files.	2024-06-28 11:54:06 +02:00
Winni Neessen	8b1208949f	Fix multipart header parsing in eml.go The commit modifies the parseMultiPartHeader function to handle optional fields accurately. The delimiter was changed from "; " to ";" and whitespace is being trimmed from the start of optional fields to ensure correct splitting and mapping.	2024-06-25 10:59:04 +02:00
Winni Neessen	faab5323fd	Fix erroneous header name in error message The error message previously referenced a constant 'HeaderTo' which might not always be the header being parsed. The commit replaces this with 'addrHeader', significantly improving the accuracy of error messages.	2024-06-25 09:47:12 +02:00
Winni Neessen	db9893f15a	More test coverage Refactored the way EML files are tested, the errors are now handled more efficiently. Temporary directory and file creation, as well as file writing, have been moved to a helper function named 'stringToTempFile'. Moreover, additional test cases were added to ensure proper parsing failure for various types of email-related errors.	2024-06-24 14:30:28 +02:00
Winni Neessen	0cec8a28f7	Refactor EML parsing into a single function The previous separate parsing of EML headers and body parts has been refactored into a single function, parseEML. This change simplifies the operations in the readEML and makes the code cleaner by reducing repetition.	2024-06-24 14:30:07 +02:00
Winni Neessen	9fa8644a9a	More test coverage New failing tests have been added to 'eml_test.go' to account for a variety of error situations, such as broken FROM, TO, headers, bodies, and unknown or unsupported content types. Improving the robustness of test coverage helps identify potential issues and ensure the resilience and correctness of the code.	2024-06-24 13:42:28 +02:00
Winni Neessen	70c9387003	Add error handling for unknown content types in eml.go The update adds a case to the switch clause in eml.go for properly handling unknown content types. An error will now be returned when the media type of the body to be parsed is not recognized, increasing the robustness of the system.	2024-06-24 13:41:48 +02:00
Winni Neessen	4c88dce2a8	Add test for EMLToMsgFromString with embedded content The new test ensures that the EMLToMsgFromString function properly handles an EML that contains embedded content. The expected subject content and number of embedded objects are checked to confirm correct parsing.	2024-06-22 14:24:52 +02:00
Winni Neessen	bb33c4a921	Add support for multipart/related EML parsing This update expands the EML parser to support multipart/related content types. It also includes relevant error handling and creates a specific routine for parsing multipart/related parts separately. Furthermore, adjustments were made to avoid processing headers unnecessarily when TypeMultipartMixed is used. The diff also shows some refactoring for clearer error messages and cleaner code.	2024-06-22 14:13:26 +02:00
Winni Neessen	52ef13a5d5	Refactor test cases and remove content print statement The content print statement in eml.go was removed to optimize code readability and performance. In addition, several assertions in the test cases of eml_test.go were corrected for string formatting errors and a new test case was added for handling emails with attachments. These changes aim to enhance the robustness of tests for email encoding and decoding operations.	2024-06-19 15:25:37 +02:00
Winni Neessen	e95799ad60	Refactor attachment and embed parsing in EML The EML parsing has been refactored to separate the handling of attachments and embeds into a new helper function. This improves the organization of the code, makes it easier to understand and helps to better manage error handling and resource closing.	2024-06-19 14:41:13 +02:00
Winni Neessen	85c07c22cc	Refactor multipart parsing in eml.go The code is refactored to improve multipart parsing in EML. The `parseEMLMultipartAlternative` function is updated to `parseEMLMultipart` for more general utilization. This involves iterating through the parts of a multipart message until content disposition is found and appended. A new function `parseMultiPartHeader` is introduced to parse multipart header and handle charset more sensibly.	2024-06-19 13:57:00 +02:00
Winni Neessen	29305675d6	Refactor EML encoding and content-type parsing to separate functions The commit includes extraction of blocks of code related to EML message encoding and content-type parsing into their own separate functions. By doing so, it improves code readability and maintainability.	2024-06-19 10:52:09 +02:00
Winni Neessen	04c41a1f10	Add EML message parsing tests Introduced a new test, `TestEMLToMsgFromFile`, to validate the functions responsible for EML message parsing. This complements the existing `EMLToMsgFromString` test, holding them accountable for subject and encoding accuracy. Also, a temporary directory is now created for testing File-related operations in isolation.	2024-06-19 10:42:29 +02:00
Winni Neessen	047d923b45	Merge branch 'refs/heads/main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-06-17 10:01:18 +02:00
Winni Neessen	481fc1d48c	Refactor variable names in eml.go for clarity Variable names in eml.go have been refactored for better readability and understanding. Shortened abbreviations have been expanded into meaningful names, and complex object names have been made simpler, making it easier to understand their role within the codebase. Cooperative variable names will improve maintainability and ease future development. This is a follow up to #179 which didn't consider this branch.	2024-05-27 10:59:38 +02:00
Winni Neessen	34f2141a26	Merge branch 'refs/heads/main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-05-27 09:56:03 +02:00
Winni Neessen	4ef24a5234	Revert after successful merge	2024-05-16 15:18:26 +02:00
Winni Neessen	2e548512c6	Merge branch 'refs/heads/main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-05-16 15:17:47 +02:00
Winni Neessen	ee3283b00b	Resolve merge conflict	2024-05-16 15:17:15 +02:00
Winni Neessen	4ec95adb30	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-02-22 17:48:54 +01:00
Winni Neessen	b957445489	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-02-15 12:14:45 +01:00
Winni Neessen	f5bbc558b2	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-02-10 15:12:25 +01:00
Winni Neessen	3facbde703	Add new content types and refactor message writer Introduced "multipart/mixed" and "multipart/related" content types in encoding.go and updated msgwriter.go to accommodate these. Adjustments made in related tests for these new types. Additionally, removed unnecessary print statements and improved multipart alternative parsing in eml.go.	2024-02-10 13:36:42 +01:00
Winni Neessen	59e85809f7	Refactor multipart encoding handling and improve content parsing Refactored the processing of multipart encoding to be robust and easily maintainable. The changes include setting 'QP' encoding as default when the Content-Transfer-Encoding header is empty, accounting for the removal of this header by the standard Go multipart package. Also, parser functions for content type and charset are now independently handling the headers, replacing the split-string approach, thus improving efficiency and code readability.	2024-02-10 13:22:38 +01:00
Winni Neessen	53566a93cd	Add content type, charset processing and refactor encoding process Extended the settings for content type and charset from headers. Also, refactored the handling of encoding types - 'QP' and 'B64' - within the mail header and body parsing sections. The process of handling encoding for plain type mail specifically is now encapsulated in a new function, parseEMLBodyPlain. These changes enhance code readability, maintainability, and error handling efficiency.	2024-02-09 15:56:39 +01:00
Winni Neessen	4202f705a0	Refactor variable naming and multipart parse function in eml.go The variable names "mbbuf", "mt", and "par" have been renamed to "bodybuf", "mediatype", and "params" respectively, for clarification. Moreover, the multipart parsing block within the parseEMLBodyParts function was extracted into its own function, parseEMLMultipartAlternative, for improved code structure and readability.	2024-02-09 12:34:11 +01:00
Winni Neessen	f759b1b5fb	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-02-08 17:04:06 +01:00
Winni Neessen	bda6b8c899	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-02-05 13:00:21 +01:00
Winni Neessen	8da2abcf01	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-01-31 11:35:32 +01:00
Winni Neessen	f7ba3a1d02	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-01-25 11:21:38 +01:00
Winni Neessen	60222c95e7	Add multipart message parsing in eml.go This commit introduces the ability to handle multipart messages within the eml.go file. It reads individual parts of multipart messages, sets the encoding and content for each part, and implements error handling for potential issues like a missing boundary tag or difficulties acquiring the next part of a multipart message.	2024-01-22 17:49:58 +01:00
Winni Neessen	0d9ba278fe	Update common content types in encoding.go The list of common content types in encoding.go has been revised. The type "multipart/alternative" has been added and the order of types has been adjusted for consistency with net/smtp upstream.	2024-01-22 17:48:49 +01:00
Winni Neessen	8b19e497a0	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2024-01-10 11:07:54 +01:00
Winni Neessen	a12d9c327f	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2023-12-07 13:21:30 +01:00
Winni Neessen	1e447b5f2c	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2023-11-10 18:23:52 +01:00
Winni Neessen	e9331e0b7c	Add time import and tests for invalid date in email Added `time` import in the eml_test.go and added two new test use-cases: `exampleMailPlainNoEncInvalidDate` and `exampleMailPlainNoEncNoDate`. The `exampleMailPlainNoEncInvalidDate` is used to check if the parser can correctly handle email with invalid date. Meanwhile, `exampleMailPlainNoEncNoDate` checks if the parser can correctly add the current date to an email that didn't specify a date. This will improve the parser's resilience and flexibility in handling various email scenarios.	2023-11-05 19:48:43 +01:00
Winni Neessen	8a1391b9df	Update test emails and enhance parser tests The test emails in the eml_test.go file have been updated with more diverse fields, including variations of encoding types. These changes help improve the robustness of our parser tests by evaluating its function with a wider range of email structures. Tests including quoted-printable and base64 encoded emails have been added.	2023-11-02 16:06:27 +01:00
Winni Neessen	9607d08469	Add EML parsing from string to tests A new test `TestEMLToMsgFromString` was added to "eml_test.go". This test asserts the proper functionality of `EMLToMsgFromString` method that allows us to parse EMLs directly from a string input. This test is a necessary part of ensuring the functionality and reliability of our EML parsing process.	2023-10-31 11:45:37 +01:00
Winni Neessen	f9140ce90e	Add parsing of EML from string and reader Added two new methods `EMLToMsgFromString` and `EMLToMsgFromReader` in "eml.go". They allow EML parsing directly from a given string and a reader object, increasing overall functionality and versatility of the EML parsing process. This will enable the users to parse EML documents more flexibly."	2023-10-31 11:45:09 +01:00
Winni Neessen	6bda5d1aaa	Merge branch 'main' into feature/145_add-eml-parser-to-generate-msg-from-eml-files	2023-10-20 14:23:24 +02:00
Winni Neessen	2bba7b902b	Updated error handling and encoding comparison in EML parsing This commit changes the usage of error value and improves the string comparison for encoding types in EML file parsing. It ensures file closure after read operations to avoid memory leaks. Error messages are made dynamic for improved error reporting. Comments on function has also been made more descriptive.	2023-10-17 10:41:42 +02:00
Winni Neessen	54ccb80925	Add base64 support in email parser Implemented base64 encoding support in the email parser. This addition allows the parser to read and decode base64 encoded emails.	2023-10-13 16:27:57 +02:00
Winni Neessen	a3b3deb467	#145 : Support for quoted-printable encoding in email parser Added support for quoted-printable encoding in email parser to increase its functionality. The change includes a case handling feature for 'EncodingQP' and related conversions to allow for proper message body reading and encoding setting. This improves the robustness and the scope of email content types that the parser can handle."	2023-10-13 16:04:07 +02:00
Winni Neessen	e7c717d0fc	"Rename Mime10 to MIME10 in codebase Renamed field 'Mime10' to 'MIME10' across multiple files for canonical representation and consistency with standard MIME naming format in the protocol."	2023-10-13 15:23:28 +02:00
Winni Neessen	07a3450103	Added SPDX license header	2023-10-13 15:08:53 +02:00
Winni Neessen	1a9141074a	Add References header field and improve string methods Added "References" header field to cover more potential use cases and enhance versatility. This field will allow applications to track series of related messages. Test for "References" field has also been added for validation. Also included are string methods for Content-type objects with relevant tests, ensuring accurate string conversion. Unnecessary duplicate method of string conversion for Charset has been removed to streamline the code and improve readability.	2023-10-13 15:06:54 +02:00
Winni Neessen	f60b689b03	Refactor EML file parsing and header extraction We can no parse simple mails (multipart is not working yet). The existing implementation was made more efficient by refactoring the EML file parsing and header extraction mechanism. Added 'strings' and 'bytes' packages to facilitate these changes. Previously, headers and body were parsed separately which was unnecessarily complex and increased the chance of errors. Now, with the new function 'readEML' and the helper function 'parseEMLBodyParts', we are able to parse headers and body together which not only simplifies the code but also increases its reliability. Specifically, 'bytes.Buffer' now helps us capture body while parsing, which removes need for separate handling. Additionally, certain headers like 'charset' and body types are also accounted for in the new implementation, enhancing the completeness of information extracted from EML files.	2023-10-13 15:06:28 +02:00
Winni Neessen	3d50370a4c	Extract and set charset from email content type The diff modifies how the email library handles the extraction of the mime media type from an email header. It uses the mime.ParseMediaType function to parse the content type header. The function gives back the media type as a string and a mapping of different associated parameters. This mapping was previously just printed, but now the charset parameter is also used for setting the charset of the email if it exists.	2023-09-27 11:29:58 +02:00
Winni Neessen	d733b6e17d	Making slight progress on EML parsing	2023-09-21 13:50:36 +02:00
Winni Neessen	d8d2a6e714	Add EML parsing functionality to mail package Added two new functions `EMLToMsg` and `readEML` to the `mail` package. `EMLToMsg` function opens and parses a .eml file and returns a pre-filled Msg pointer. `readEML` opens an EML file and uses net/mail to parse the header and body. These changes are made to provide support for EML file parsing, which is a common requirement in many email-based applications.	2023-09-15 13:16:14 +02:00