cmd/sgblog-comment-add/mail.go

   1 /*
   2 SGBlog -- Git-backed CGI/inetd blogging/phlogging engine
   3 Copyright (C) 2020-2021 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         "io"
  25         "io/ioutil"
  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 ct != "multipart/signed" {
  79                 err = errors.New("only text/plain and multipart/signed+text/plain Content-Type supported")
  80                 return
  81         }
  82         boundary := params["boundary"]
  83         if len(boundary) == 0 {
  84                 err = errors.New("no boundary string")
  85                 return
  86         }
  87         data, err := ioutil.ReadAll(msg.Body)
  88         if err != nil {
  89                 return
  90         }
  91         boundaryIdx := bytes.Index(data, []byte("--"+boundary))
  92         if boundaryIdx == -1 {
  93                 err = errors.New("no boundary found")
  94                 return
  95         }
  96         mpr := multipart.NewReader(bytes.NewReader(data[boundaryIdx:]), boundary)
  97         var part *multipart.Part
  98         for {
  99                 part, err = mpr.NextPart()
 100                 if err != nil {
 101                         if err == io.EOF {
 102                                 break
 103                         }
 104                         return
 105                 }
 106                 ct = part.Header.Get(CT)
 107                 if strings.HasPrefix(ct, TP) {
 108                         body, err = processTP(ct, part.Header.Get(CTE), part)
 109                         return
 110                 }
 111                 if strings.HasPrefix(ct, "multipart/mixed") {
 112                         ct, params, err = mime.ParseMediaType(ct)
 113                         boundary = params["boundary"]
 114                         if len(boundary) == 0 {
 115                                 err = errors.New("no boundary string")
 116                                 return
 117                         }
 118                         mpr := multipart.NewReader(part, boundary)
 119                         for {
 120                                 part, err = mpr.NextPart()
 121                                 if err != nil {
 122                                         if err == io.EOF {
 123                                                 break
 124                                         }
 125                                         return
 126                                 }
 127                                 ct = part.Header.Get(CT)
 128                                 if strings.HasPrefix(ct, TP) {
 129                                         body, err = processTP(ct, part.Header.Get(CTE), part)
 130                                         return
 131                                 }
 132                         }
 133                 }
 134         }
 135         err = errors.New("no text/plain part found")
 136         return
 137 }