cmd/sgblog-comment-add/mail.go

   1 /*
   2 SGBlog -- Git-backed CGI/UCSPI blogging/phlogging/gemlogging engine
   3 Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU Affero General Public License as
   7 published by the Free Software Foundation, version 3 of the License.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU Affero General Public License
  15 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 package main
  19
  20 import (
  21         "bytes"
  22         "encoding/base64"
  23         "errors"
  24         "fmt"
  25         "io"
  26         "mime"
  27         "mime/multipart"
  28         "mime/quotedprintable"
  29         "net/mail"
  30         "strings"
  31 )
  32
  33 const (
  34         CT  = "Content-Type"
  35         CTE = "Content-Transfer-Encoding"
  36         TP  = "text/plain"
  37 )
  38
  39 func processTP(ct, cte string, body io.Reader) (io.Reader, error) {
  40         _, params, err := mime.ParseMediaType(ct)
  41         if err != nil {
  42                 return nil, err
  43         }
  44         if c := strings.ToLower(params["charset"]); !(c == "" ||
  45                 c == "utf-8" ||
  46                 c == "iso-8859-1" ||
  47                 c == "us-ascii") {
  48                 return nil, errors.New("only utf-8/iso-8859-1/us-ascii charsets supported")
  49         }
  50         switch cte {
  51         case "quoted-printable":
  52                 return quotedprintable.NewReader(body), nil
  53         case "base64":
  54                 return base64.NewDecoder(base64.StdEncoding, body), nil
  55         }
  56         return body, nil
  57 }
  58
  59 func parseEmail(msg *mail.Message) (subj string, body io.Reader, err error) {
  60         subj = msg.Header.Get("Subject")
  61         if subj == "" {
  62                 err = errors.New("no Subject")
  63                 return
  64         }
  65         subj, err = new(mime.WordDecoder).DecodeHeader(subj)
  66         if err != nil {
  67                 return
  68         }
  69         ct := msg.Header.Get(CT)
  70         if ct == "" {
  71                 ct = "text/plain"
  72         }
  73         if strings.HasPrefix(ct, TP) {
  74                 body, err = processTP(ct, msg.Header.Get(CTE), msg.Body)
  75                 return
  76         }
  77         ct, params, err := mime.ParseMediaType(ct)
  78         if err != nil {
  79                 err = fmt.Errorf("can not ParseMediaType: %w", err)
  80                 return
  81         }
  82         if ct != "multipart/signed" {
  83                 err = errors.New("only text/plain and multipart/signed+text/plain Content-Type supported")
  84                 return
  85         }
  86         boundary := params["boundary"]
  87         if len(boundary) == 0 {
  88                 err = errors.New("no boundary string")
  89                 return
  90         }
  91         data, err := io.ReadAll(msg.Body)
  92         if err != nil {
  93                 return
  94         }
  95         boundaryIdx := bytes.Index(data, []byte("--"+boundary))
  96         if boundaryIdx == -1 {
  97                 err = errors.New("no boundary found")
  98                 return
  99         }
 100         mpr := multipart.NewReader(bytes.NewReader(data[boundaryIdx:]), boundary)
 101         var part *multipart.Part
 102         for {
 103                 part, err = mpr.NextPart()
 104                 if err != nil {
 105                         if err == io.EOF {
 106                                 break
 107                         }
 108                         return
 109                 }
 110                 ct = part.Header.Get(CT)
 111                 if strings.HasPrefix(ct, TP) {
 112                         body, err = processTP(ct, part.Header.Get(CTE), part)
 113                         return
 114                 }
 115                 if strings.HasPrefix(ct, "multipart/mixed") {
 116                         _, params, err = mime.ParseMediaType(ct)
 117                         if err != nil {
 118                                 err = fmt.Errorf("can not ParseMediaType: %w", err)
 119                                 return
 120                         }
 121                         boundary = params["boundary"]
 122                         if len(boundary) == 0 {
 123                                 err = errors.New("no boundary string")
 124                                 return
 125                         }
 126                         mpr := multipart.NewReader(part, boundary)
 127                         for {
 128                                 part, err = mpr.NextPart()
 129                                 if err != nil {
 130                                         if err == io.EOF {
 131                                                 break
 132                                         }
 133                                         return
 134                                 }
 135                                 ct = part.Header.Get(CT)
 136                                 if strings.HasPrefix(ct, TP) {
 137                                         body, err = processTP(ct, part.Header.Get(CTE), part)
 138                                         return
 139                                 }
 140                         }
 141                 }
 142         }
 143         err = errors.New("no text/plain part found")
 144         return
 145 }