package http import ( "crypto/sha256" "dwelling-upload/pkg/utils" "dwelling-upload/web" "encoding/base64" "encoding/hex" "fmt" "io" "log" "net/http" "net/url" "os" "path" "strings" "time" "git.arav.su/Arav/httpr" ) type UploadHandlers struct { logFile *log.Logger uploadDir string uploadDirSize *int64 hashSalt string keepForHours int limitStorage int64 limitFileSize int64 } func NewUploadHandlers(lFile *log.Logger, uploadDir string, uploadDirSize *int64, hashSalt string, keepForHours int, limStorage, limFileSz int64) *UploadHandlers { return &UploadHandlers{ logFile: lFile, uploadDir: uploadDir, uploadDirSize: uploadDirSize, hashSalt: hashSalt, keepForHours: keepForHours, limitStorage: limStorage, limitFileSize: limFileSz} } func (h *UploadHandlers) Index(w http.ResponseWriter, r *http.Request) { var storCapacity int64 = h.limitStorage << 20 var fMaxSize int64 = h.limitFileSize << 20 _, _, availStr := utils.ConvertFileSize(storCapacity - *h.uploadDirSize) _, _, fMaxSzStr := utils.ConvertFileSize(fMaxSize) web.Index(utils.MainSite(r.Host), h.keepForHours, fMaxSzStr, availStr, w) } func (h *UploadHandlers) Upload(w http.ResponseWriter, r *http.Request) { var fMaxSizeBytes int64 = h.limitFileSize << 20 var storCapacity int64 = h.limitStorage << 20 r.Body = http.MaxBytesReader(w, r.Body, fMaxSizeBytes) if err := r.ParseMultipartForm(fMaxSizeBytes); err != nil { log.Println("failed to parse upload form:", err) Error(w, r, "Failed to parse upload form.", http.StatusExpectationFailed) return } f, fHandler, err := r.FormFile("file") if err != nil { log.Println("failed to open incoming file:", err) Error(w, r, "Error reading an incoming file.", http.StatusInternalServerError) return } defer os.Remove(fHandler.Filename) defer f.Close() var leftSpace int64 = storCapacity - *h.uploadDirSize if leftSpace < fHandler.Size { log.Println("not enough space left in storage, only", leftSpace>>20, "MiB left") Error(w, r, "Not enough space left, sorry.", http.StatusInternalServerError) return } s256 := sha256.New() if _, err := io.Copy(s256, f); err != nil { log.Println("failed to compute a SHA-256 hash:", err) Error(w, r, "A hash for the file cannot be computed.", http.StatusInternalServerError) return } fHash := hex.EncodeToString(s256.Sum(nil)) s256.Write([]byte(h.hashSalt)) fSaltedHash := base64.RawURLEncoding.EncodeToString(s256.Sum(nil)) f.Seek(0, io.SeekStart) fPath := path.Join(h.uploadDir, fSaltedHash) _, err = os.Stat(fPath) if os.IsNotExist(err) { fDst, err := os.Create(fPath) if err != nil { log.Println("failed to open file for writing", err) Error(w, r, "File cannot be written.", http.StatusInternalServerError) return } defer fDst.Close() // We initialy set a dst file size to occupy space equal to uploaded's size. // This is called a sparse file, if you need to know. // It allows us to have a relatively small buffer size for inotify watcher. // And it really affects that. I tested it. fDst.Seek(fHandler.Size-1, io.SeekStart) fDst.Write([]byte{0}) fDst.Seek(0, io.SeekStart) if _, err = io.Copy(fDst, f); err != nil { log.Println("failed to copy uploaded file to destination:", err) Error(w, r, "Failed to copy uploaded file to the storage.", http.StatusInternalServerError) return } typ, _ := utils.NetworkType(r.Host) ip := r.Header.Get("X-Real-IP") if typ != "www" && typ != "ygg" { ip = "" } h.logFile.Printf("| up | %s | %s | %s | SHA256 %s | %s | %d | %s", ip, typ, fHandler.Filename, fHash, fSaltedHash, fHandler.Size, r.UserAgent()) w.WriteHeader(http.StatusCreated) } else { os.Chtimes(fPath, time.Now(), time.Now()) w.WriteHeader(http.StatusFound) } downloadURL := path.Join("/", fSaltedHash, fHandler.Filename) downloadURLParsed, _ := url.Parse(downloadURL) _, scheme := utils.NetworkType(r.Host) site := scheme + "://" + r.Host if strings.Contains(r.UserAgent(), "curl") || strings.Contains(r.UserAgent(), "Wget") { fmt.Fprintln(w, site+downloadURLParsed.String(), "will be kept for", h.keepForHours) } else { web.Uploaded(utils.MainSite(r.Host), site, downloadURLParsed.String(), h.keepForHours, w) } } func (h *UploadHandlers) Download(w http.ResponseWriter, r *http.Request) { saltedHash := httpr.Param(r, "hash") path := path.Join(h.uploadDir, saltedHash) stat, err := os.Stat(path) if os.IsNotExist(err) { Error(w, r, "", http.StatusNotFound) return } name := httpr.Param(r, "name") w.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", name)) fd, err := os.Open(path) if err != nil { log.Println("failed to open file to read:", err) Error(w, r, "Failed to open file to read.", http.StatusInternalServerError) return } defer fd.Close() typ, _ := utils.NetworkType(r.Host) ip := r.Header.Get("X-Real-IP") if typ != "www" && typ != "ygg" { ip = "" } h.logFile.Printf("| dw | %s | %s | %s | %s | %s", ip, typ, name, saltedHash, r.UserAgent()) http.ServeContent(w, r, path, stat.ModTime(), fd) } func (h *UploadHandlers) Delete(w http.ResponseWriter, r *http.Request) { var saltedHash string if r.Method == "DELETE" { saltedHash = httpr.Param(r, "hash") } else { r.ParseForm() saltedHash = r.FormValue("hash") } path := path.Join(h.uploadDir, saltedHash) if _, err := os.Stat(path); os.IsNotExist(err) { Error(w, r, "", http.StatusNotFound) return } if err := os.Remove(path); err != nil { log.Println("failed to remove a file:", err) Error(w, r, "Failed to remove a file.", http.StatusInternalServerError) return } typ, _ := utils.NetworkType(r.Host) ip := r.Header.Get("X-Real-IP") if typ != "www" && typ != "ygg" { ip = "" } h.logFile.Printf("| dt | %s | %s | %s | %s", ip, typ, saltedHash, r.UserAgent()) if strings.Contains(r.UserAgent(), "curl") || strings.Contains(r.UserAgent(), "Wget") { fmt.Fprintln(w, "File was successfully deleted.") } else { web.Deleted(utils.MainSite(r.Host), w) } } func Error(w http.ResponseWriter, r *http.Request, reason string, code int) { if strings.Contains(r.UserAgent(), "curl") || strings.Contains(r.UserAgent(), "Wget") { http.Error(w, reason, code) return } w.WriteHeader(code) web.ErrorXXX(utils.MainSite(r.Host), code, reason, w) } func RobotsTxt(w http.ResponseWriter, r *http.Request) { data, _ := web.AssetsGetFile("robots.txt") w.Write(data) } func Favicon(w http.ResponseWriter, r *http.Request) { data, _ := web.AssetsGetFile("img/favicon.svg") w.Write(data) }