On-the-fly .zst decompression, take 2

cmd/cmd.go

@@ -6,7 +6,7 @@ import (
 	"os"
 	"strings"
 
-	"github.com/dutchcoders/transfer.sh/server"
+	"git.kiska.pw/kiska/transfer.sh/server"
 	"github.com/fatih/color"
 	"github.com/minio/cli"
 	"google.golang.org/api/googleapi"

main.go

@@ -1,6 +1,6 @@
 package main
 
-import "github.com/dutchcoders/transfer.sh/cmd"
+import "git.kiska.pw/kiska/transfer.sh/cmd"
 
 func main() {
 	app := cmd.New()

manifest.json

@@ -1,6 +1,6 @@
 {
     "dependencies": {
-        "github.com/dutchcoders/transfer.sh-web": {
+        "github.com/kiska3/transfer.sh-web": {
             "branch": "master"
         }
     }

server/handlers.go

@@ -61,6 +61,8 @@ import (
 
 	"encoding/base64"
 	qrcode "github.com/skip2/go-qrcode"
+
+	"github.com/klauspost/compress/zstd"
 )
 
 var (
@@ -321,7 +323,7 @@ func (s *Server) postHandler(w http.ResponseWriter, r *http.Request) {
 
 			}
 
-			filename = url.QueryEscape(filename)
+			filename = url.PathEscape(filename)
 			relativeURL, _ := url.Parse(path.Join(token, filename))
 			fmt.Fprintln(w, getURL(r).ResolveReference(relativeURL).String())
 
@@ -480,7 +482,7 @@ func (s *Server) putHandler(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "text/plain")
 
-	filename = url.QueryEscape(filename)
+	filename = url.PathEscape(filename)
 	relativeURL, _ := url.Parse(path.Join(token, filename))
 	deleteUrl, _ := url.Parse(path.Join(token, filename, metadata.DeletionToken))
 
@@ -556,9 +558,10 @@ func (s *Server) CheckMetadata(token, filename string) error {
 	var metadata Metadata
 
 	r, _, _, err := s.storage.Get(token, fmt.Sprintf("%s.metadata", filename))
-	if s.storage.IsNotExist(err) {
-		return nil
-	} else if err != nil {
+	//if s.storage.IsNotExist(err) {
+		// return nil
+	//} else if err != nil {
+        if err != nil {
 		return err
 	}
 
@@ -837,23 +840,34 @@ func (s *Server) headHandler(w http.ResponseWriter, r *http.Request) {
 	filename := vars["filename"]
 
 	if err := s.CheckMetadata(token, filename); err != nil {
-		log.Printf("Error metadata: %s", err.Error())
-		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
-		return
+		if err2 := s.CheckMetadata(token, filename + ".zst"); err2 != nil {
+			log.Printf("Error metadata: %s", err.Error())
+			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			return
+		}
 	}
 
 	contentType, contentLength, err := s.storage.Head(token, filename)
 	if s.storage.IsNotExist(err) {
-		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
-		return
+		_, _, err := s.storage.Head(token, filename + ".zst")
+		if s.storage.IsNotExist(err) {
+			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			return
+		} else if err != nil {
+			log.Printf("%s", err.Error())
+			http.Error(w, "Could not retrieve file.", 500)
+			return
+		}
+		contentType = mime.TypeByExtension(filepath.Ext(filename))
 	} else if err != nil {
 		log.Printf("%s", err.Error())
 		http.Error(w, "Could not retrieve file.", 500)
 		return
+	} else {
+		w.Header().Set("Content-Length", strconv.FormatUint(contentLength, 10))
 	}
 
 	w.Header().Set("Content-Type", contentType)
-	w.Header().Set("Content-Length", strconv.FormatUint(contentLength, 10))
 	w.Header().Set("Connection", "close")
 }
 
@@ -865,19 +879,45 @@ func (s *Server) getHandler(w http.ResponseWriter, r *http.Request) {
 	filename := vars["filename"]
 
 	if err := s.CheckMetadata(token, filename); err != nil {
-		log.Printf("Error metadata: %s", err.Error())
-		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
-		return
+		if err2 := s.CheckMetadata(token, filename + ".zst"); err2 != nil {
+			log.Printf("Error metadata: %s and %s", err.Error(), err2.Error())
+			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			return
+		}
 	}
 
 	reader, contentType, contentLength, err := s.storage.Get(token, filename)
 	if s.storage.IsNotExist(err) {
-		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
-		return
+		reader, _, _, err = s.storage.Get(token, filename + ".zst")
+		if s.storage.IsNotExist(err) {
+			http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)
+			return
+		} else if err != nil {
+			log.Printf("Failed to get .zst from storage: %s", err.Error())
+			http.Error(w, "Could not retrieve file.", 500)
+			return
+		}
+		defer reader.Close()
+		if w.Header().Get("Range") != "" {
+			log.Printf("Range request with decompression")
+			http.Error(w, "Range requests with decompression are not supported", 400)
+			return
+		}
+		d, err := zstd.NewReader(reader)
+		if err != nil {
+			log.Printf("Failed to create zstd reader: %s", err.Error())
+			http.Error(w, "Could not retrieve file.", 500)
+			return
+		}
+		reader = d.IOReadCloser()
+		contentType = mime.TypeByExtension(filepath.Ext(filename))
+		w.Header().Set("Transfer-Encoding", "chunked")
 	} else if err != nil {
-		log.Printf("%s", err.Error())
+		log.Printf("Failed to get from storage: %s", err.Error())
 		http.Error(w, "Could not retrieve file.", 500)
 		return
+	} else {
+		w.Header().Set("Content-Length", strconv.FormatUint(contentLength, 10))
 	}
 
 	defer reader.Close()
@@ -891,7 +931,6 @@ func (s *Server) getHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.Header().Set("Content-Type", contentType)
-	w.Header().Set("Content-Length", strconv.FormatUint(contentLength, 10))
 	w.Header().Set("Content-Disposition", fmt.Sprintf("%s; filename=\"%s\"", disposition, filename))
 	w.Header().Set("Connection", "keep-alive")
 

server/server.go

@@ -341,7 +341,8 @@ func (s *Server) Run() {
 	r.HandleFunc("/{action:(?:download|get|inline)}/{token}/{filename}", s.headHandler).Methods("HEAD")
 
 	r.HandleFunc("/{token}/{filename}", s.previewHandler).MatcherFunc(func(r *http.Request, rm *mux.RouteMatch) (match bool) {
-		match = false
+	        return false
+         	match = false
 
 		// The file will show a preview page when opening the link in browser directly or
 		// from external link. If the referer url path and current path are the same it will be