src/uploader/main.go

   1 /*
   2 uploader -- simplest form file uploader
   3 Copyright (C) 2018-2019 Sergey Matveev <stargrave@stargrave.org>
   4 */
   5
   6 package main
   7
   8 import (
   9         "bufio"
  10         "encoding/base64"
  11         "encoding/hex"
  12         "flag"
  13         "fmt"
  14         "html/template"
  15         "io"
  16         "io/ioutil"
  17         "log"
  18         "mime"
  19         "net"
  20         "net/http"
  21         "os"
  22         "os/exec"
  23         "strings"
  24         "time"
  25
  26         "golang.org/x/crypto/blake2b"
  27         "golang.org/x/net/netutil"
  28 )
  29
  30 const (
  31         WriteBufSize     = 1 << 20
  32         FileFieldName    = "fileupload"
  33         CommentFieldName = "comment"
  34
  35         SendmailCmd = "/usr/sbin/sendmail"
  36 )
  37
  38 var (
  39         Index = template.Must(template.New("index").Parse(`<html>
  40 <head><title>Upload</title></head><body>
  41 <form enctype="multipart/form-data" action="/upload/" method="post">
  42 <input type="file" name="{{.}}" /><br/>
  43 <label for="comment">Optional comment:</label>
  44 <textarea name="comment" cols="80" rows="25" name="comment"></textarea><br/>
  45 <input type="submit" />
  46 </form></body></html>`))
  47         NotifyFromAddr *string
  48         NotifyToAddr   *string
  49 )
  50
  51 func notify(timestamp string, size int64, comment string) {
  52         if *NotifyToAddr == "" {
  53                 return
  54         }
  55         cmd := exec.Command(SendmailCmd, *NotifyToAddr)
  56         cmd.Stdin = io.MultiReader(
  57                 strings.NewReader(fmt.Sprintf(
  58                         `From: %s
  59 To: %s
  60 Subject: %s
  61 MIME-Version: 1.0
  62 Content-Type: text/plain; charset=utf-8
  63 Content-Transfer-Encoding: base64
  64
  65 `,
  66                         *NotifyFromAddr,
  67                         *NotifyToAddr,
  68                         mime.BEncoding.Encode("UTF-8", fmt.Sprintf(
  69                                 "%s (%d KiB)", timestamp, size/1024,
  70                         )),
  71                 )),
  72                 strings.NewReader(base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf(
  73                         "Timestamp: %s\nSize: %d bytes\nComment: %s\n",
  74                         timestamp,
  75                         size,
  76                         comment,
  77                 )))),
  78         )
  79         cmd.Run()
  80 }
  81
  82 func upload(w http.ResponseWriter, r *http.Request) {
  83         log.Println(r.RemoteAddr, "connected")
  84         if r.Method == http.MethodGet {
  85                 if err := Index.Execute(w, FileFieldName); err != nil {
  86                         log.Println(r.RemoteAddr, err)
  87                 }
  88                 return
  89         }
  90         mr, err := r.MultipartReader()
  91         if err != nil {
  92                 log.Println(r.RemoteAddr, err)
  93                 return
  94         }
  95         p, err := mr.NextPart()
  96         if err != nil {
  97                 log.Println(r.RemoteAddr, err)
  98                 return
  99         }
 100         if p.FormName() != FileFieldName {
 101                 log.Println(r.RemoteAddr, "non file form field")
 102                 return
 103         }
 104         h, err := blake2b.New256(nil)
 105         if err != nil {
 106                 panic(err)
 107         }
 108         fn := time.Now().Format(time.RFC3339Nano)
 109         fd, err := os.OpenFile(fn+".part", os.O_WRONLY|os.O_CREATE, 0600)
 110         if err != nil {
 111                 log.Println(r.RemoteAddr, fn, p.FileName(), err)
 112                 return
 113         }
 114         fdBuf := bufio.NewWriterSize(fd, WriteBufSize)
 115         mw := io.MultiWriter(fdBuf, h)
 116         n, err := io.Copy(mw, p)
 117         if err != nil {
 118                 log.Println(r.RemoteAddr, fn, p.FileName(), err)
 119                 fd.Close()
 120                 return
 121         }
 122         if n == 0 {
 123                 log.Println(r.RemoteAddr, fn, p.FileName(), "empty")
 124                 os.Remove(fn + ".part")
 125                 fd.Close()
 126                 fmt.Fprintf(w, "Empty file")
 127                 return
 128         }
 129         if err = fdBuf.Flush(); err != nil {
 130                 log.Println(r.RemoteAddr, fn, p.FileName(), err)
 131                 fd.Close()
 132                 return
 133         }
 134         fd.Close()
 135         sum := hex.EncodeToString(h.Sum(nil))
 136         if err = os.Rename(fn+".part", fn); err != nil {
 137                 log.Println(r.RemoteAddr, fn, p.FileName(), n, sum, err)
 138                 return
 139         }
 140         fmt.Fprintf(w, "Timestamp: %s\nBytes: %d\nBLAKE2b: %s\n", fn, n, sum)
 141         log.Println(r.RemoteAddr, fn, p.FileName(), n, sum)
 142         p, err = mr.NextPart()
 143         if err != nil || p.FormName() != CommentFieldName {
 144                 go notify(fn, n, "")
 145                 return
 146         }
 147         comment, err := ioutil.ReadAll(p)
 148         if err != nil || len(comment) == 0 {
 149                 go notify(fn, n, "")
 150                 return
 151         }
 152         ioutil.WriteFile(fn+".txt", comment, os.FileMode(0600))
 153         go notify(fn, n, string(comment))
 154 }
 155
 156 func main() {
 157         bind := flag.String("bind", "[::]:8086", "Address to bind to")
 158         conns := flag.Int("conns", 2, "Maximal number of connections")
 159         NotifyFromAddr = flag.String("notify-from", "uploader@example.com", "Address notifications are send to")
 160         NotifyToAddr = flag.String("notify-to", "", "Address notifications are send from")
 161         flag.Parse()
 162         if len(*NotifyFromAddr) == 0 && len(*NotifyToAddr) > 0 {
 163                 log.Fatalln("notify-from address can not be empty, if notify-to is set")
 164         }
 165         ln, err := net.Listen("tcp", *bind)
 166         if err != nil {
 167                 log.Fatalln(err)
 168         }
 169         log.Println("listening", *bind)
 170         ln = netutil.LimitListener(ln, *conns)
 171         s := &http.Server{
 172                 ReadHeaderTimeout: 10 * time.Second,
 173                 MaxHeaderBytes:    10 * (1 << 10),
 174         }
 175         http.HandleFunc("/upload/", upload)
 176         s.Serve(ln)
 177 }