main.go

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