GODT-948 Embedded messages

pkg/message/body.go

@@ -57,19 +57,23 @@ func WriteAttachmentBody(w io.Writer, kr *crypto.KeyRing, m *pmapi.Message, att
 		att.Name += ".gpg"
 		att.MIMEType = "application/pgp-encrypted" //nolint
 	} else if err != nil && err != openpgperrors.ErrSignatureExpired {
-		err = fmt.Errorf("cannot decrypt attachment: %v", err)
-		return
+		return fmt.Errorf("cannot decrypt attachment: %v", err)
+	}
+
+	// Don't encode message/rfc822 attachments; they should be embedded and preserved.
+	if att.MIMEType == rfc822Message {
+		if n, err := io.Copy(w, dr); err != nil {
+			return fmt.Errorf("cannot write attached message: %v (wrote %v bytes)", err, n)
+		}
+		return nil
 	}
 
 	// Encode it.
 	ww := textwrapper.NewRFC822(w)
 	bw := base64.NewEncoder(base64.StdEncoding, ww)
 
-	var n int64
-	if n, err = io.Copy(bw, dr); err != nil {
-		err = fmt.Errorf("cannot write attachment: %v (wrote %v bytes)", err, n)
+	if n, err := io.Copy(bw, dr); err != nil {
+		return fmt.Errorf("cannot write attachment: %v (wrote %v bytes)", err, n)
 	}
-
-	_ = bw.Close()
-	return
+	return bw.Close()
 }

pkg/message/build.go

@@ -124,7 +124,7 @@ func (bld *Builder) writeRelatedPart(p io.Writer, inlines []*pmapi.Attachment) e
 			return err
 		}
 
-		h := GetAttachmentHeader(inline)
+		h := GetAttachmentHeader(inline, false)
 		if p, err = related.CreatePart(h); err != nil {
 			return err
 		}
@@ -194,7 +194,7 @@ func (bld *Builder) BuildMessage() (structure *BodyStructure, message []byte, er
 				return nil, nil, err
 			}
 
-			attachmentHeader := GetAttachmentHeader(att)
+			attachmentHeader := GetAttachmentHeader(att, false)
 			if partWriter, err = mw.CreatePart(attachmentHeader); err != nil {
 				return nil, nil, err
 			}
@@ -311,16 +311,11 @@ func BuildEncrypted(m *pmapi.Message, readers []io.Reader, kr *crypto.KeyRing) (
 	for i := 0; i < len(m.Attachments); i++ {
 		att := m.Attachments[i]
 		r := readers[i]
-		h := GetAttachmentHeader(att)
+		h := GetAttachmentHeader(att, false)
 		p, err := mw.CreatePart(h)
 		if err != nil {
 			return nil, err
 		}
-		// Create line wrapper writer.
-		ww := textwrapper.NewRFC822(p)
-
-		// Create base64 writer.
-		bw := base64.NewEncoder(base64.StdEncoding, ww)
 
 		data, err := ioutil.ReadAll(r)
 		if err != nil {
@@ -332,6 +327,9 @@ func BuildEncrypted(m *pmapi.Message, readers []io.Reader, kr *crypto.KeyRing) (
 		if err != nil {
 			return nil, err
 		}
+
+		ww := textwrapper.NewRFC822(p)
+		bw := base64.NewEncoder(base64.StdEncoding, ww)
 		if _, err := bw.Write(pgpMessage.GetBinary()); err != nil {
 			return nil, err
 		}

pkg/message/header.go

@@ -107,12 +107,17 @@ func GetRelatedHeader(m *pmapi.Message) textproto.MIMEHeader {
 	return h
 }
 
-func GetAttachmentHeader(att *pmapi.Attachment) textproto.MIMEHeader {
+func GetAttachmentHeader(att *pmapi.Attachment, buildForIMAP bool) textproto.MIMEHeader {
 	mediaType := att.MIMEType
 	if mediaType == "application/pgp-encrypted" {
 		mediaType = "application/octet-stream"
 	}
 
+	transferEncoding := "base64"
+	if mediaType == rfc822Message && buildForIMAP {
+		transferEncoding = "8bit"
+	}
+
 	encodedName := pmmime.EncodeHeader(att.Name)
 	disposition := "attachment" //nolint[goconst]
 	if strings.Contains(att.Header.Get("Content-Disposition"), "inline") {
@@ -121,7 +126,9 @@ func GetAttachmentHeader(att *pmapi.Attachment) textproto.MIMEHeader {
 
 	h := make(textproto.MIMEHeader)
 	h.Set("Content-Type", mime.FormatMediaType(mediaType, map[string]string{"name": encodedName}))
-	h.Set("Content-Transfer-Encoding", "base64")
+	if transferEncoding != "" {
+		h.Set("Content-Transfer-Encoding", transferEncoding)
+	}
 	h.Set("Content-Disposition", mime.FormatMediaType(disposition, map[string]string{"filename": encodedName}))
 
 	// Forward some original header lines.

pkg/message/message.go

@@ -26,6 +26,10 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const (
+	rfc822Message = "message/rfc822"
+)
+
 var log = logrus.WithField("pkg", "pkg/message") //nolint[gochecknoglobals]
 
 func GetBoundary(m *pmapi.Message) string {

pkg/message/section.go

@@ -201,7 +201,7 @@ func (bs *BodyStructure) parseAllChildSections(r io.Reader, currentPath []int, s
 	mediaType, params, _ := pmmime.ParseMediaType(info.Header.Get("Content-Type"))
 
 	// If multipart, call getAllParts, else read to count lines.
-	if (strings.HasPrefix(mediaType, "multipart/") || mediaType == "message/rfc822") && params["boundary"] != "" {
+	if (strings.HasPrefix(mediaType, "multipart/") || mediaType == rfc822Message) && params["boundary"] != "" {
 		newPath := append(currentPath, 1)
 
 		var br *boundaryReader