refactor(serverHandler): parse URL query by url.Query()

For getting query values, previous solution is parsing raw query string
manually to save memory.

It's not so convenient when query parameter combinations increase.
Changed to parsing by standard library method `url.Query`.

BREAKING CHANGE

`?simpledownload` is no more supported. Use `?simple&download` instead.

Before:

```
GET /path?simpledownload
```

After:

```
GET /path?simple&download
```

Author: marjune163

src/serverHandler/aliasHandler.go

@@ -100,15 +100,16 @@ func (h *aliasHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	if session.authSuccess {
 		if session.requestAuth {
-			h.redirectWithoutRequestAuth(w, r, session, data)
+			returnUrl := h.extractNoAuthUrl(r, session, data)
+			http.Redirect(w, r, returnUrl, http.StatusFound)
 			return
 		}
 
 		if session.redirectAction == addSlashSuffix {
-			redirect(w, r, session.prefixReqPath+"/", h.autoDirSlash)
+			redirectWithQuery(w, r, session.prefixReqPath+"/", h.autoDirSlash)
 			return
 		} else if session.redirectAction == removeSlashSuffix {
-			redirect(w, r, session.prefixReqPath[:len(session.prefixReqPath)-1], h.autoDirSlash)
+			redirectWithQuery(w, r, session.prefixReqPath[:len(session.prefixReqPath)-1], h.autoDirSlash)
 			return
 		}
 

src/serverHandler/auth.go

@@ -4,13 +4,12 @@ import (
 	"errors"
 	"net/http"
 	"net/url"
-	"strings"
 )
 
 const authQueryParam = "auth"
 
-func (h *aliasHandler) needAuth(rawQuery, vhostReqPath, reqFsPath string) (needAuth, requestAuth bool) {
-	if strings.HasPrefix(rawQuery, authQueryParam) {
+func (h *aliasHandler) needAuth(queryPrefix, vhostReqPath, reqFsPath string) (needAuth, requestAuth bool) {
+	if queryPrefix == authQueryParam {
 		return true, true
 	}
 
@@ -55,25 +54,26 @@ func (h *aliasHandler) verifyAuth(r *http.Request, vhostReqPath, reqFsPath strin
 	return
 }
 
-func (h *aliasHandler) redirectWithoutRequestAuth(w http.ResponseWriter, r *http.Request, session *sessionContext, data *responseData) {
-	var returnUrl string
-	index := strings.Index(r.URL.RawQuery, authQueryParam+"=")
-	if index >= 0 {
-		returnUrl = r.URL.RawQuery[index+len(authQueryParam)+1:]
-		index = strings.LastIndexByte(returnUrl, '&')
-		if index >= 0 {
-			returnUrl = returnUrl[:index]
+func (h *aliasHandler) extractNoAuthUrl(r *http.Request, session *sessionContext, data *responseData) string {
+	if session.query.Has(authQueryParam) {
+		returnUrl := session.query.Get(authQueryParam)
+
+		if len(returnUrl) > 0 {
+			url, err := url.QueryUnescape(returnUrl)
+			if err == nil {
+				returnUrl = url
+			}
 		}
-		url, err := url.QueryUnescape(returnUrl)
-		if err == nil {
-			returnUrl = url
+
+		if len(returnUrl) > 0 {
+			return returnUrl
 		}
-	} else {
-		returnUrl = r.Header.Get("Referer")
 	}
-	if len(returnUrl) == 0 {
-		returnUrl = session.prefixReqPath + data.Context.QueryString()
+
+	referrer := r.Header.Get("Referer")
+	if len(referrer) > 0 {
+		return referrer
 	}
 
-	http.Redirect(w, r, returnUrl, http.StatusFound)
+	return session.prefixReqPath + data.Context.QueryString()
 }

src/serverHandler/pathContext.go

@@ -8,16 +8,14 @@ type pathContext struct {
 }
 
 func (ctx pathContext) QueryString() string {
-	// ?simpledownload&sort=x/&
-	buffer := make([]byte, 1, 24)
+	// ?simple&download&sort=x/&
+	buffer := make([]byte, 1, 25)
 	buffer[0] = '?' // 1 byte
 
-	switch {
-	case ctx.simple && ctx.download:
-		buffer = append(buffer, []byte("simpledownload&")...) // 15 bytes
-	case ctx.simple:
+	if ctx.simple {
 		buffer = append(buffer, []byte("simple&")...) // 7 bytes
-	case ctx.download:
+	}
+	if ctx.download {
 		buffer = append(buffer, []byte("download&")...) // 9 bytes
 	}
 

src/serverHandler/pathContext_test.go

@@ -53,7 +53,7 @@ func TestPathContext(t *testing.T) {
 	}
 
 	result = (&pathContext{simple: true, download: true}).QueryString()
-	if result != "?simpledownload" {
+	if result != "?simple&download" {
 		t.Error(result)
 	}
 
@@ -77,7 +77,7 @@ func TestPathContext(t *testing.T) {
 
 	sort = "/n"
 	result = (&pathContext{simple: true, download: true, sort: &sort}).QueryString()
-	if result != "?simpledownload&sort=/n" {
+	if result != "?simple&download&sort=/n" {
 		t.Error(result)
 	}
 }

src/serverHandler/redirect.go

@@ -2,7 +2,7 @@ package serverHandler
 
 import "net/http"
 
-func redirect(w http.ResponseWriter, r *http.Request, path string, code int) {
+func redirectWithQuery(w http.ResponseWriter, r *http.Request, path string, code int) {
 	target := path
 	if len(r.URL.RawQuery) > 0 {
 		target += "?" + r.URL.RawQuery

src/serverHandler/sessionData.go

@@ -6,6 +6,7 @@ import (
 	"mjpclab.dev/ghfs/src/i18n"
 	"mjpclab.dev/ghfs/src/util"
 	"net/http"
+	"net/url"
 	"os"
 	"path"
 	"path/filepath"
@@ -81,6 +82,8 @@ type sessionContext struct {
 
 	file *os.File
 
+	query url.Values
+
 	errors []error
 }
 
@@ -355,11 +358,15 @@ func (h *aliasHandler) getSessionData(r *http.Request) (session *sessionContext,
 	reqPath := util.CleanUrlPath(vhostReqPath[len(h.url):])
 	fsPath := filepath.Clean(h.dir + reqPath)
 
-	rawQuery := r.URL.RawQuery
+	query := r.URL.Query()
+	queryPrefix := r.URL.RawQuery
+	if querySepIndex := strings.IndexByte(queryPrefix, '&'); querySepIndex >= 0 {
+		queryPrefix = queryPrefix[:querySepIndex]
+	}
 
 	status := http.StatusOK
 
-	needAuth, requestAuth := h.needAuth(rawQuery, vhostReqPath, fsPath)
+	needAuth, requestAuth := h.needAuth(queryPrefix, vhostReqPath, fsPath)
 	authUserId, authUserName, _authErr := h.verifyAuth(r, vhostReqPath, fsPath)
 	authSuccess := !needAuth || _authErr == nil
 	if !authSuccess {
@@ -369,47 +376,39 @@ func (h *aliasHandler) getSessionData(r *http.Request) (session *sessionContext,
 
 	headers := h.getHeaders(vhostReqPath, fsPath, authSuccess)
 
-	isSimple := false
-	isDownload := false
 	isUpload := false
 	isMkdir := false
 	isDelete := false
 	isMutate := false
-	switch {
-	case strings.HasPrefix(rawQuery, "simpledownload"):
-		isSimple = true
-		isDownload = true
-	case strings.HasPrefix(rawQuery, "simple"):
-		isSimple = true
-	case strings.HasPrefix(rawQuery, "download"):
-		isDownload = true
-	case strings.HasPrefix(rawQuery, "upload") && r.Method == http.MethodPost:
+	switch queryPrefix {
+	case "upload":
 		isUpload = true
 		isMutate = true
-	case strings.HasPrefix(rawQuery, "mkdir"):
+	case "mkdir":
 		isMkdir = true
 		isMutate = true
-	case strings.HasPrefix(r.URL.RawQuery, "delete"):
+	case "delete":
 		isDelete = true
 		isMutate = true
 	}
 
 	isArchive := false
 	var arFmt archiveFormat
-	if len(rawQuery) == 3 || (len(rawQuery) > 3 && rawQuery[3] == '&') {
-		switch rawQuery[:3] {
-		case "tar":
-			isArchive = true
-			arFmt = tarFmt
-		case "tgz":
-			isArchive = true
-			arFmt = tgzFmt
-		case "zip":
-			isArchive = true
-			arFmt = zipFmt
-		}
+	switch queryPrefix {
+	case "tar":
+		isArchive = true
+		arFmt = tarFmt
+	case "tgz":
+		isArchive = true
+		arFmt = tgzFmt
+	case "zip":
+		isArchive = true
+		arFmt = zipFmt
 	}
 
+	isSimple := query.Has("simple")
+	isDownload := query.Has("download")
+
 	accepts := acceptHeaders.ParseAccepts(r.Header.Get("Accept"))
 	acceptIndex, _, _ := accepts.GetPreferredValue(acceptContentTypes)
 	wantJson := acceptIndex == acceptJsonIndex
@@ -489,7 +488,7 @@ func (h *aliasHandler) getSessionData(r *http.Request) (session *sessionContext,
 	}
 
 	subItems = h.FilterItems(subItems)
-	rawSortBy, sortState := sortInfos(subItems, rawQuery, h.defaultSort)
+	rawSortBy, sortState := sortInfos(subItems, query.Get("sort"), h.defaultSort)
 
 	if h.emptyRoot && status == http.StatusOK && len(vhostReqPath) > 1 {
 		status = http.StatusNotFound
@@ -535,6 +534,8 @@ func (h *aliasHandler) getSessionData(r *http.Request) (session *sessionContext,
 
 		file: file,
 
+		query: query,
+
 		errors: errs,
 	}
 	data = &responseData{

src/serverHandler/sort.go

@@ -5,7 +5,6 @@ import (
 	"mjpclab.dev/ghfs/src/util"
 	"os"
 	"sort"
-	"strings"
 )
 
 // compare dir func
@@ -358,22 +357,10 @@ func sortInfoOriginal(items []os.FileInfo, compareDir fnCompareDir) {
 
 // sort
 
-func sortInfos(items []os.FileInfo, rawQuery string, defaultSortBy string) (rawSortBy *string, sortInfo SortState) {
-	const sortPrefix = "sort="
-	var sortBy string
-
-	// extract sort string
-	iSortBy := strings.Index(rawQuery, sortPrefix)
-	if iSortBy < 0 {
+func sortInfos(items []os.FileInfo, sortBy string, defaultSortBy string) (rawSortBy *string, sortInfo SortState) {
+	if len(sortBy) == 0 {
 		sortBy = defaultSortBy
 	} else {
-		if len(rawQuery) > iSortBy+len(sortPrefix) {
-			sortBy = rawQuery[iSortBy+len(sortPrefix):]
-			iAmp := strings.IndexByte(sortBy, '&')
-			if iAmp >= 0 {
-				sortBy = sortBy[:iAmp]
-			}
-		}
 		rawSortBy = &sortBy
 	}
 

src/serverHandler/sort_test.go

@@ -43,91 +43,91 @@ func TestSort(t *testing.T) {
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=/n", "")
+	sortInfos(infos, "/n", "")
 	ok = expectItems(infos, dir1, dir2, dir3, file1, file2, file3)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=/N", "")
+	sortInfos(infos, "/N", "")
 	ok = expectItems(infos, dir3, dir2, dir1, file3, file2, file1)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=n/", "")
+	sortInfos(infos, "n/", "")
 	ok = expectItems(infos, file1, file2, file3, dir1, dir2, dir3)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=N/", "")
+	sortInfos(infos, "N/", "")
 	ok = expectItems(infos, file3, file2, file1, dir3, dir2, dir1)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=n", "")
+	sortInfos(infos, "n", "")
 	ok = expectItems(infos, dir1, file1, dir2, file2, dir3, file3)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=N", "")
+	sortInfos(infos, "N", "")
 	ok = expectItems(infos, file3, dir3, file2, dir2, file1, dir1)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=e", "")
+	sortInfos(infos, "e", "")
 	ok = expectItems(infos, dir1, dir2, dir3, file2, file1, file3)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=E", "")
+	sortInfos(infos, "E", "")
 	ok = expectItems(infos, file3, file1, file2, dir3, dir2, dir1)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=s", "")
+	sortInfos(infos, "s", "")
 	ok = expectItems(infos, dir1, file1, file2, dir3, file3, dir2)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=S", "")
+	sortInfos(infos, "S", "")
 	ok = expectItems(infos, dir2, file3, dir3, file2, file1, dir1)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=t", "")
+	sortInfos(infos, "t", "")
 	ok = expectItems(infos, dir1, file1, dir2, dir3, file2, file3)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=T", "")
+	sortInfos(infos, "T", "")
 	ok = expectItems(infos, file3, file2, dir3, dir2, file1, dir1)
 	if !ok {
 		t.Errorf("%+v\n", infos)
 	}
 
 	copy(infos, originInfos)
-	sortInfos(infos, "?sort=/", "")
+	sortInfos(infos, "/", "")
 	ok = expectItems(infos, dir3, dir1, dir2, file2, file3, file1)
 	if !ok {
 		t.Errorf("%+v\n", infos)