linx-server/upload.go

287 lines
6.8 KiB
Go
Raw Normal View History

2015-09-24 01:44:49 -04:00
package main
import (
2015-09-29 20:59:59 -04:00
"bytes"
"encoding/json"
2015-09-28 16:02:03 -04:00
"errors"
2015-09-24 01:44:49 -04:00
"fmt"
"io"
"net/http"
2015-10-01 20:58:08 -04:00
"net/url"
2015-09-24 01:44:49 -04:00
"os"
"path"
2015-10-01 20:58:08 -04:00
"path/filepath"
2015-09-24 01:44:49 -04:00
"regexp"
"strconv"
2015-09-24 01:44:49 -04:00
"strings"
2015-09-29 20:59:59 -04:00
"bitbucket.org/taruti/mimemagic"
"github.com/dchest/uniuri"
2015-09-24 01:44:49 -04:00
"github.com/zenazn/goji/web"
)
2015-09-27 22:17:12 -04:00
// Describes metadata directly from the user request
2015-09-24 01:44:49 -04:00
type UploadRequest struct {
src io.Reader
filename string
2015-09-29 19:00:16 -04:00
expiry int64 // Seconds until expiry, 0 = never
2015-09-24 01:44:49 -04:00
randomBarename bool
2015-09-27 22:17:12 -04:00
deletionKey string // Empty string if not defined
2015-09-24 01:44:49 -04:00
}
2015-09-27 22:17:12 -04:00
// Metadata associated with a file as it would actually be stored
2015-09-24 01:44:49 -04:00
type Upload struct {
2015-09-27 22:17:12 -04:00
Filename string // Final filename on disk
Size int64
2015-09-29 19:00:16 -04:00
Expiry int64 // Unix timestamp of expiry, 0=never
2015-09-27 22:17:12 -04:00
DeleteKey string // Deletion key, one generated if not provided
2015-09-24 01:44:49 -04:00
}
func uploadPostHandler(c web.C, w http.ResponseWriter, r *http.Request) {
upReq := UploadRequest{}
2015-09-27 22:17:12 -04:00
uploadHeaderProcess(r, &upReq)
2015-09-24 01:44:49 -04:00
2015-09-30 00:56:51 -04:00
contentType := r.Header.Get("Content-Type")
2015-09-30 23:37:00 -04:00
if strings.HasPrefix(contentType, "multipart/form-data") {
file, headers, err := r.FormFile("file")
if err != nil {
oopsHandler(c, w, r)
return
}
defer file.Close()
r.ParseForm()
if r.Form.Get("randomize") == "true" {
upReq.randomBarename = true
}
upReq.expiry = parseExpiry(r.Form.Get("expires"))
upReq.src = file
upReq.filename = headers.Filename
2015-09-30 00:56:51 -04:00
} else {
if r.FormValue("content") == "" {
oopsHandler(c, w, r)
return
}
extension := r.FormValue("extension")
if extension == "" {
extension = "txt"
}
upReq.src = strings.NewReader(r.FormValue("content"))
upReq.expiry = parseExpiry(r.FormValue("expires"))
upReq.filename = r.FormValue("filename") + "." + extension
}
2015-09-24 01:44:49 -04:00
upload, err := processUpload(upReq)
if err != nil {
oopsHandler(c, w, r)
2015-09-24 01:44:49 -04:00
return
}
if strings.EqualFold("application/json", r.Header.Get("Accept")) {
js := generateJSONresponse(upload)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.Write(js)
} else {
http.Redirect(w, r, "/"+upload.Filename, 301)
}
2015-09-24 01:44:49 -04:00
}
func uploadPutHandler(c web.C, w http.ResponseWriter, r *http.Request) {
upReq := UploadRequest{}
2015-09-27 22:17:12 -04:00
uploadHeaderProcess(r, &upReq)
2015-09-24 01:44:49 -04:00
defer r.Body.Close()
upReq.filename = c.URLParams["name"]
2015-09-24 01:44:49 -04:00
upReq.src = r.Body
upload, err := processUpload(upReq)
if err != nil {
oopsHandler(c, w, r)
2015-09-24 01:44:49 -04:00
return
}
if strings.EqualFold("application/json", r.Header.Get("Accept")) {
js := generateJSONresponse(upload)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.Write(js)
} else {
fmt.Fprintf(w, Config.siteURL+upload.Filename)
}
}
2015-10-01 20:58:08 -04:00
func uploadRemote(c web.C, w http.ResponseWriter, r *http.Request) {
if r.FormValue("url") == "" {
http.Redirect(w, r, "/", 301)
return
}
upReq := UploadRequest{}
grabUrl, _ := url.Parse(r.FormValue("url"))
resp, err := http.Get(grabUrl.String())
if err != nil {
oopsHandler(c, w, r)
return
}
upReq.filename = filepath.Base(grabUrl.Path)
upReq.src = resp.Body
upload, err := processUpload(upReq)
if err != nil {
oopsHandler(c, w, r)
return
}
if strings.EqualFold("application/json", r.Header.Get("Accept")) {
js := generateJSONresponse(upload)
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.Write(js)
} else {
http.Redirect(w, r, "/"+upload.Filename, 301)
}
}
func uploadHeaderProcess(r *http.Request, upReq *UploadRequest) {
// For legacy reasons
if r.Header.Get("X-Randomized-Filename") == "yes" {
upReq.randomBarename = true
} else if r.Header.Get("X-Randomized-Barename") == "yes" {
upReq.randomBarename = true
}
upReq.deletionKey = r.Header.Get("X-Delete-Key")
// Get seconds until expiry. Non-integer responses never expire.
expStr := r.Header.Get("X-File-Expiry")
upReq.expiry = parseExpiry(expStr)
2015-09-24 01:44:49 -04:00
}
func processUpload(upReq UploadRequest) (upload Upload, err error) {
2015-09-27 22:17:12 -04:00
// Determine the appropriate filename, then write to disk
2015-09-24 01:44:49 -04:00
barename, extension := barePlusExt(upReq.filename)
if upReq.randomBarename || len(barename) == 0 {
barename = generateBarename()
}
2015-10-01 11:03:41 -04:00
var header []byte
2015-09-24 01:44:49 -04:00
if len(extension) == 0 {
2015-10-01 11:03:41 -04:00
// Pull the first 512 bytes off for use in MIME detection
header = make([]byte, 512)
n, err := upReq.src.Read(header)
if n == 0 {
return upload, err
}
header = header[:n]
2015-09-29 20:59:59 -04:00
// Determine the type of file from header
mimetype := mimemagic.Match("", header)
// If the mime type is in our map, use that
// otherwise just use "ext"
if val, exists := mimeToExtension[mimetype]; exists {
extension = val
} else {
extension = "ext"
}
2015-09-24 01:44:49 -04:00
}
upload.Filename = strings.Join([]string{barename, extension}, ".")
_, err = os.Stat(path.Join(Config.filesDir, upload.Filename))
fileexists := err == nil
for fileexists {
counter, err := strconv.Atoi(string(barename[len(barename)-1]))
if err != nil {
barename = barename + "1"
} else {
barename = barename[:len(barename)-1] + strconv.Itoa(counter+1)
}
upload.Filename = strings.Join([]string{barename, extension}, ".")
_, err = os.Stat(path.Join(Config.filesDir, upload.Filename))
fileexists = err == nil
}
dst, err := os.Create(path.Join(Config.filesDir, upload.Filename))
2015-09-24 08:30:16 -04:00
if err != nil {
2015-09-24 01:44:49 -04:00
return
}
2015-09-24 08:30:16 -04:00
defer dst.Close()
2015-09-24 01:44:49 -04:00
2015-09-27 22:17:12 -04:00
// Get the rest of the metadata needed for storage
upload.Expiry = getFutureTimestamp(upReq.expiry)
// If no delete key specified, pick a random one.
if upReq.deletionKey == "" {
upload.DeleteKey = uniuri.NewLen(30)
2015-09-27 22:17:12 -04:00
} else {
upload.DeleteKey = upReq.deletionKey
}
metadataWrite(upload.Filename, &upload)
2015-10-01 11:03:41 -04:00
bytes, err := io.Copy(dst, io.MultiReader(bytes.NewReader(header), upReq.src))
2015-09-24 08:30:16 -04:00
if err != nil {
2015-09-24 01:44:49 -04:00
return
} else if bytes == 0 {
2015-09-28 16:02:03 -04:00
os.Remove(path.Join(Config.filesDir, upload.Filename))
os.Remove(path.Join(Config.metaDir, upload.Filename))
return upload, errors.New("Empty file")
2015-09-24 01:44:49 -04:00
}
upload.Size = bytes
return
}
func generateBarename() string {
return uniuri.NewLenChars(8, []byte("abcdefghijklmnopqrstuvwxyz0123456789"))
2015-09-24 01:44:49 -04:00
}
func generateJSONresponse(upload Upload) []byte {
js, _ := json.Marshal(map[string]string{
"url": Config.siteURL + upload.Filename,
"filename": upload.Filename,
"delete_key": upload.DeleteKey,
"expiry": strconv.FormatInt(int64(upload.Expiry), 10),
"size": strconv.FormatInt(upload.Size, 10),
})
return js
}
2015-09-25 09:04:06 -04:00
var barePlusRe = regexp.MustCompile(`[^A-Za-z0-9\-]`)
2015-09-24 01:44:49 -04:00
func barePlusExt(filename string) (barename, extension string) {
filename = strings.TrimSpace(filename)
filename = strings.ToLower(filename)
extension = path.Ext(filename)
barename = filename[:len(filename)-len(extension)]
2015-09-25 09:04:06 -04:00
extension = barePlusRe.ReplaceAllString(extension, "")
barename = barePlusRe.ReplaceAllString(barename, "")
2015-09-24 01:44:49 -04:00
return
}
2015-09-29 19:00:16 -04:00
func parseExpiry(expStr string) int64 {
if expStr == "" {
return 0
} else {
2015-09-29 19:00:16 -04:00
expiry, err := strconv.ParseInt(expStr, 10, 64)
if err != nil {
return 0
} else {
2015-09-29 19:00:16 -04:00
return int64(expiry)
}
}
}