main.go

   1 /*
   2 uploader -- simplest form file uploader
   3 Copyright (C) 2018-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 General Public License as published by
   7 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 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         "bufio"
  22         "bytes"
  23         "encoding/base64"
  24         "encoding/hex"
  25         "flag"
  26         "fmt"
  27         "html/template"
  28         "io"
  29         "io/ioutil"
  30         "log"
  31         "mime"
  32         "net"
  33         "net/http"
  34         "os"
  35         "os/exec"
  36         "strconv"
  37         "strings"
  38         "sync"
  39         "time"
  40
  41         "go.cypherpunks.ru/recfile"
  42         "go.cypherpunks.ru/tai64n/v2"
  43         "golang.org/x/crypto/blake2b"
  44         "golang.org/x/net/netutil"
  45 )
  46
  47 const (
  48         WriteBufSize     = 1 << 20
  49         FileFieldName    = "file"
  50         CommentFieldName = "comment"
  51
  52         SendmailCmd = "/usr/sbin/sendmail"
  53 )
  54
  55 var (
  56         Index = template.Must(template.New("index").Parse(`<html>
  57 <head><title>Upload</title></head><body>
  58 Example command line usage:
  59 <pre>
  60 $ curl -F file=@somedata.tar.gpg [-F comment="optional comment"] http://.../upload/
  61 $ b2sum somedata.tar.gpg # to verify BLAKE2b-512 checksum
  62 </pre>
  63 <form enctype="multipart/form-data" action="/upload/" method="post">
  64 <label for="file">File to upload:</label><br/>
  65 <input name="file" type="file" name="{{.}}" /><br/>
  66 <label for="comment">Optional comment:</label></br>
  67 <textarea name="comment" cols="80" rows="25" name="comment"></textarea><br/>
  68 <input type="submit" />
  69 </form></body></html>`))
  70         NotifyFromAddr *string
  71         NotifyToAddr   *string
  72         Jobs           sync.WaitGroup
  73 )
  74
  75 func notify(tai, filename string, size int64, comment string) {
  76         defer Jobs.Done()
  77         if *NotifyToAddr == "" {
  78                 return
  79         }
  80         var rec bytes.Buffer
  81         w := recfile.NewWriter(&rec)
  82         w.WriteFields(
  83                 recfile.Field{Name: "TAI64N", Value: tai},
  84                 recfile.Field{Name: "Size", Value: strconv.FormatInt(size, 10)},
  85                 recfile.Field{Name: "Filename", Value: filename},
  86         )
  87         w.WriteFieldMultiline("Comment", strings.Split(comment, "\n"))
  88         cmd := exec.Command(SendmailCmd, *NotifyToAddr)
  89         cmd.Stdin = io.MultiReader(
  90                 strings.NewReader(fmt.Sprintf(
  91                         `From: %s
  92 To: %s
  93 Subject: %s
  94 MIME-Version: 1.0
  95 Content-Type: text/plain; charset=utf-8
  96 Content-Transfer-Encoding: base64
  97
  98 `,
  99                         *NotifyFromAddr,
 100                         *NotifyToAddr,
 101                         mime.BEncoding.Encode("UTF-8", fmt.Sprintf("%s (%d KiB)", filename, size/1024)),
 102                 )),
 103                 strings.NewReader(base64.StdEncoding.EncodeToString(rec.Bytes())),
 104         )
 105         cmd.Run()
 106 }
 107
 108 func upload(w http.ResponseWriter, r *http.Request) {
 109         log.Println(r.RemoteAddr, "connected")
 110         if r.Method == http.MethodGet {
 111                 if err := Index.Execute(w, FileFieldName); err != nil {
 112                         log.Println(r.RemoteAddr, err)
 113                 }
 114                 return
 115         }
 116         mr, err := r.MultipartReader()
 117         if err != nil {
 118                 log.Println(r.RemoteAddr, err)
 119                 return
 120         }
 121         p, err := mr.NextPart()
 122         if err != nil {
 123                 log.Println(r.RemoteAddr, err)
 124                 return
 125         }
 126         if p.FormName() != FileFieldName {
 127                 log.Println(r.RemoteAddr, "non file form field")
 128                 return
 129         }
 130         h, err := blake2b.New512(nil)
 131         if err != nil {
 132                 panic(err)
 133         }
 134         t := time.Now()
 135         ts := new(tai64n.TAI64N)
 136         ts.FromTime(t)
 137         tai := tai64n.Encode(ts[:])[1:]
 138         fnOrig := p.FileName()
 139         fd, err := os.OpenFile(tai+".part", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0666)
 140         if err != nil {
 141                 log.Println(r.RemoteAddr, tai, fnOrig, err)
 142                 return
 143         }
 144         fdBuf := bufio.NewWriterSize(fd, WriteBufSize)
 145         mw := io.MultiWriter(fdBuf, h)
 146         n, err := io.Copy(mw, p)
 147         if err != nil {
 148                 log.Println(r.RemoteAddr, tai, fnOrig, err)
 149                 fd.Close()
 150                 return
 151         }
 152         if n == 0 {
 153                 log.Println(r.RemoteAddr, tai, fnOrig, "empty")
 154                 os.Remove(tai + ".part")
 155                 fd.Close()
 156                 fmt.Fprintf(w, "Empty file")
 157                 return
 158         }
 159         if err = fdBuf.Flush(); err != nil {
 160                 log.Println(r.RemoteAddr, tai, fnOrig, err)
 161                 fd.Close()
 162                 return
 163         }
 164         if err = fd.Sync(); err != nil {
 165                 log.Println(r.RemoteAddr, tai, fnOrig, err)
 166                 fd.Close()
 167                 return
 168         }
 169         fd.Close()
 170         sum := hex.EncodeToString(h.Sum(nil))
 171         if err = os.Rename(tai+".part", tai); err != nil {
 172                 log.Println(r.RemoteAddr, tai, fnOrig, n, sum, err)
 173                 return
 174         }
 175         var rec bytes.Buffer
 176         wr := recfile.NewWriter(&rec)
 177         if _, err = wr.WriteFields(
 178                 recfile.Field{Name: "TAI64N", Value: tai},
 179                 recfile.Field{Name: "Size", Value: strconv.FormatInt(n, 10)},
 180                 recfile.Field{Name: "Checksum", Value: sum},
 181         ); err != nil {
 182                 log.Println(r.RemoteAddr, tai, fnOrig, n, sum, err)
 183                 return
 184         }
 185         io.Copy(w, &rec)
 186         log.Println(r.RemoteAddr, tai, fnOrig, n, sum)
 187
 188         rec.Reset()
 189         wr = recfile.NewWriter(&rec)
 190         if _, err = wr.WriteFields(
 191                 recfile.Field{Name: "Filename", Value: fnOrig},
 192         ); err != nil {
 193                 log.Println(r.RemoteAddr, tai, fnOrig, n, sum, err)
 194                 return
 195         }
 196
 197         var comment []byte
 198         p, err = mr.NextPart()
 199         if err != nil || p.FormName() != CommentFieldName {
 200                 goto Notify
 201         }
 202         comment, err = ioutil.ReadAll(p)
 203         if err != nil || len(comment) == 0 {
 204                 goto Notify
 205         }
 206         wr.WriteFieldMultiline("Comment", strings.Split(string(comment), "\n"))
 207
 208 Notify:
 209         Jobs.Add(1)
 210         go notify(tai, fnOrig, n, string(comment))
 211         ioutil.WriteFile(tai+".rec", rec.Bytes(), os.FileMode(0666))
 212 }
 213
 214 func main() {
 215         doUCSPI := flag.Bool("ucspi", false, "Work as UCSPI-TCP service")
 216         bind := flag.String("bind", "[::]:8086", "Address to bind to")
 217         conns := flag.Int("conns", 2, "Maximal number of connections")
 218         NotifyFromAddr = flag.String("notify-from", "uploader@example.com", "Address notifications are sent to")
 219         NotifyToAddr = flag.String("notify-to", "", "Address notifications are sent from")
 220         flag.Parse()
 221         log.SetFlags(log.Lshortfile)
 222         if !*doUCSPI {
 223                 log.SetOutput(os.Stdout)
 224         }
 225         if len(*NotifyFromAddr) == 0 && len(*NotifyToAddr) > 0 {
 226                 log.Fatalln("notify-from address can not be empty, if notify-to is set")
 227         }
 228         s := &http.Server{
 229                 ReadHeaderTimeout: 10 * time.Second,
 230                 MaxHeaderBytes:    10 * (1 << 10),
 231         }
 232         http.HandleFunc("/upload/", upload)
 233         if *doUCSPI {
 234                 s.SetKeepAlivesEnabled(false)
 235                 ln := &UCSPI{}
 236                 s.ConnState = connStater
 237                 err := s.Serve(ln)
 238                 if _, ok := err.(UCSPIAlreadyAccepted); !ok {
 239                         log.Fatalln(err)
 240                 }
 241                 Jobs.Wait()
 242         } else {
 243                 ln, err := net.Listen("tcp", *bind)
 244                 if err != nil {
 245                         log.Fatalln(err)
 246                 }
 247                 log.Println("listening", *bind)
 248                 ln = netutil.LimitListener(ln, *conns)
 249                 if err = s.Serve(ln); err != nil {
 250                         log.Fatalln(err)
 251                 }
 252         }
 253 }