main.go

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