feat: add url prefix

Serve files under a subdirectory of url. This may be useful if the
server is behind a reverse proxy and received the request without
proxying path stripped.

Add cmdline option `--prefix` to specify the url prefix.

Add cmdline option `--base` to specify the case-insensitive url
prefix.

Author: marjune163

README.md

@@ -111,6 +111,13 @@ ghfs [options]
     Use virtual empty directory as root directory.
     Useful to share alias directories only.
 
+--prefix <path> ...
+    Serve files under a specific sub url path.
+    Could be useful if server is behind a reverse proxy and
+    received the request without proxying path stripped.
+--base <path> ...
+    Similar to --prefix, but the path is case-insensitive.
+
 --default-sort <sortBy>
     Default sort rule for files and directories.
     Available sort key:

README.zh-CN.md

@@ -110,6 +110,12 @@ ghfs [选项]
     使用空的虚拟目录作为根目录。
     在仅需挂载别名的情况下较实用。
 
+--prefix <path> ...
+    在指定的URL子路径下提供服务。
+    如果服务器在反向代理之后，且收到的请求并未去除代理路径前缀，可能较有用。
+--base <path> ...
+    与--prefix类似，但路径不区分大小写。
+
 --default-sort <排序规则>
     指定文件和目录的默认排序规则。
     可用的排序key：

src/param/cli.go

@@ -26,6 +26,12 @@ func init() {
 	err = options.AddFlags("emptyroot", []string{"-R", "--empty-root"}, "GHFS_EMPTY_ROOT", "use virtual empty root directory")
 	serverErrHandler.CheckFatal(err)
 
+	err = options.AddFlagValues("prefixurls", "--prefix", "", nil, "serve files under URL path instead of /")
+	serverErrHandler.CheckFatal(err)
+
+	err = options.AddFlagValues("baseurls", "--base", "", nil, "serve files under case-insensitive URL path instead of /")
+	serverErrHandler.CheckFatal(err)
+
 	opt = goNixArgParser.NewFlagValueOption("defaultsort", "--default-sort", "GHFS_DEFAULT_SORT", "/n", "default sort for files and directories")
 	opt.Description = "Available sort key:\n- `n` sort by name ascending\n- `N` sort by name descending\n- `e` sort by type(suffix) ascending\n- `E` sort by type(suffix) descending\n- `s` sort by size ascending\n- `S` sort by size descending\n- `t` sort by modify time ascending\n- `T` sort by modify time descending\n- `_` no sort\nDirectory sort:\n- `/<key>` directories before files\n- `<key>/` directories after files\n- `<key>` directories mixed with files\n"
 	err = options.Add(opt)
@@ -266,6 +272,14 @@ func doParseCli() []*Param {
 		root, _ = util.NormalizeFsPath(root)
 		param.Root = root
 
+		// normalize url prefixes
+		prefixurls, _ := result.GetStrings("prefixurls")
+		param.PrefixUrls = normalizeUrlPaths(prefixurls)
+
+		// normalize url bases
+		baseurls, _ := result.GetStrings("baseurls")
+		param.BaseUrls = normalizeUrlPaths(baseurls)
+
 		// dir indexes
 		dirIndexes, _ := result.GetStrings("dirindexes")
 		param.DirIndexes = normalizeFilenames(dirIndexes)

src/param/main.go

@@ -15,6 +15,9 @@ type Param struct {
 	Root      string
 	EmptyRoot bool
 
+	PrefixUrls []string
+	BaseUrls   []string
+
 	DefaultSort   string
 	DirIndexes    []string
 	Aliases       map[string]string

src/serverHandler/handler.go

@@ -11,6 +11,8 @@ import (
 	"strings"
 )
 
+var defaultHandler = http.NotFoundHandler()
+
 var createFileServer func(root string) http.Handler
 
 type handler struct {

src/serverHandler/multiplexer.go

@@ -10,8 +10,6 @@ import (
 	"net/http"
 )
 
-var defaultHandler = http.NotFoundHandler()
-
 type aliasHandler struct {
 	alias   alias
 	handler http.Handler

src/serverHandler/pathTransformer.go

@@ -0,0 +1,63 @@
+package serverHandler
+
+import (
+	"../util"
+	"net/http"
+)
+
+type pathTransformer struct {
+	prefixesAccurate []string
+	prefixesNoCase   []string
+	nextHandler      http.Handler
+}
+
+func stripUrlPrefix(urlPathDir, urlPath, prefix string) string {
+	if len(urlPath) == len(prefix) {
+		return "/"
+	} else if len(prefix) <= 1 {
+		return urlPathDir
+	} else {
+		return urlPathDir[len(prefix):]
+	}
+}
+
+func (transformer pathTransformer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	urlPath := util.CleanUrlPath(r.URL.Path)
+	var urlPathDir string
+	if len(urlPath) > 1 && r.URL.Path[len(r.URL.Path)-1] == '/' {
+		urlPathDir = urlPath + "/"
+	} else {
+		urlPathDir = urlPath
+	}
+	r.URL.RawPath = urlPathDir
+
+	if len(transformer.prefixesAccurate) == 0 && len(transformer.prefixesNoCase) == 0 {
+		r.URL.Path = urlPathDir
+		transformer.nextHandler.ServeHTTP(w, r)
+		return
+	}
+
+	for _, prefix := range transformer.prefixesAccurate {
+		if !util.HasUrlPrefixDir(urlPath, prefix) {
+			continue
+		}
+		r.URL.Path = stripUrlPrefix(urlPathDir, urlPath, prefix)
+		transformer.nextHandler.ServeHTTP(w, r)
+		return
+	}
+
+	for _, prefix := range transformer.prefixesNoCase {
+		if !util.HasUrlPrefixDirNoCase(urlPath, prefix) {
+			continue
+		}
+		r.URL.Path = stripUrlPrefix(urlPathDir, urlPath, prefix)
+		transformer.nextHandler.ServeHTTP(w, r)
+		return
+	}
+
+	defaultHandler.ServeHTTP(w, r)
+}
+
+func NewPathTransformer(prefixesAccurate, prefixesNoCase []string, handler http.Handler) http.Handler {
+	return pathTransformer{prefixesAccurate, prefixesNoCase, handler}
+}

src/serverHandler/pathTransformer_test.go

@@ -0,0 +1,47 @@
+package serverHandler
+
+import "testing"
+
+func TestStripUrlPrefix(t *testing.T) {
+	var result string
+
+	result = stripUrlPrefix("/", "/", "/")
+	if result != "/" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo", "/foo", "/")
+	if result != "/foo" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo/bar", "/foo/bar", "/")
+	if result != "/foo/bar" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo/bar/", "/foo/bar", "/")
+	if result != "/foo/bar/" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo", "/foo", "/foo")
+	if result != "/" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo/", "/foo", "/foo")
+	if result != "/" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo/bar", "/foo/bar", "/foo")
+	if result != "/bar" {
+		t.Error(result)
+	}
+
+	result = stripUrlPrefix("/foo/bar/", "/foo/bar", "/foo")
+	if result != "/bar/" {
+		t.Error(result)
+	}
+}

src/serverHandler/responseData.go

@@ -49,10 +49,11 @@ type responseData struct {
 	errors []error
 	Status int
 
-	IsRoot        bool
-	Path          string
-	Paths         []pathEntry
-	RootRelPath   string
+	IsRoot      bool
+	Path        string
+	Paths       []pathEntry
+	RootRelPath string
+
 	File          *os.File
 	Item          os.FileInfo
 	ItemName      string
@@ -71,34 +72,34 @@ func isSlash(c rune) bool {
 	return c == '/'
 }
 
-func getPathEntries(path string, tailSlash bool) []pathEntry {
+func getPathEntries(currDirRelPath, path string, tailSlash bool) []pathEntry {
 	restPaths := strings.FieldsFunc(path, isSlash)
-	paths := make([]string, 1, len(restPaths)+1)
+	paths := make([]string, len(restPaths)+1)
 	paths[0] = "/"
-	paths = append(paths, restPaths...)
+	copy(paths[1:], restPaths)
 
-	displayPathsCount := len(paths)
+	pathFrags := len(paths)
 
-	pathsCount := displayPathsCount
+	pathDepth := pathFrags
 	if !tailSlash {
-		pathsCount--
+		pathDepth--
 	}
 
-	pathEntries := make([]pathEntry, displayPathsCount)
-	for i := 0; i < displayPathsCount; i++ {
-		var rPath string
-		switch {
-		case i < pathsCount-1:
-			rPath = strings.Repeat("../", pathsCount-1-i)
-		case i == pathsCount-1:
-			rPath = "./"
-		default:
-			rPath = "./" + strings.Join(paths[pathsCount:], "/") + "/"
+	pathEntries := make([]pathEntry, pathFrags)
+	for n := 1; n <= pathFrags; n++ {
+		var relPath string
+		if n < pathDepth {
+			relPath = strings.Repeat("../", pathDepth-n)
+		} else if n == pathDepth {
+			relPath = currDirRelPath
+		} else /*if n == pathDepth+1*/ {
+			relPath = currDirRelPath + paths[pathDepth] + "/"
 		}
 
+		i := n - 1
 		pathEntries[i] = pathEntry{
 			Name: paths[i],
-			Path: rPath,
+			Path: relPath,
 		}
 	}
 
@@ -191,11 +192,19 @@ func (h *handler) mergeAlias(
 	return subItems, aliasSubItems, errs
 }
 
-func getSubItemPrefix(rawRequestPath string, tailSlash bool) string {
-	if tailSlash {
+func getCurrDirRelPath(reqPath, rawReqPath string) string {
+	if len(reqPath) == 1 && len(rawReqPath) > 1 && rawReqPath[len(rawReqPath)-1] != '/' {
+		return "./" + path.Base(rawReqPath) + "/"
+	} else {
 		return "./"
+	}
+}
+
+func getSubItemPrefix(currDirRelPath, rawRequestPath string, tailSlash bool) string {
+	if tailSlash {
+		return currDirRelPath
 	} else {
-		return "./" + path.Base(rawRequestPath) + "/"
+		return currDirRelPath + path.Base(rawRequestPath) + "/"
 	}
 }
 
@@ -266,13 +275,9 @@ func (h *handler) statIndexFile(rawReqPath, baseDir string, baseItem os.FileInfo
 func (h *handler) getResponseData(r *http.Request) *responseData {
 	var errs []error
 
-	requestUri := r.URL.Path
-	if len(requestUri) == 0 {
-		requestUri = "/"
-	}
-	tailSlash := requestUri[len(requestUri)-1] == '/'
+	rawReqPath := r.URL.Path
+	tailSlash := rawReqPath[len(rawReqPath)-1] == '/'
 
-	rawReqPath := util.CleanUrlPath(requestUri)
 	reqPath := util.CleanUrlPath(rawReqPath[len(h.urlPrefix):]) // strip url prefix path
 	reqFsPath, _ := util.NormalizeFsPath(h.root + reqPath)
 
@@ -311,12 +316,13 @@ func (h *handler) getResponseData(r *http.Request) *responseData {
 	status := http.StatusOK
 	isRoot := rawReqPath == "/"
 
-	pathEntries := getPathEntries(rawReqPath, tailSlash)
+	currDirRelPath := getCurrDirRelPath(rawReqPath, r.URL.RawPath)
+	pathEntries := getPathEntries(currDirRelPath, rawReqPath, tailSlash)
 	var rootRelPath string
 	if len(pathEntries) > 0 {
 		rootRelPath = pathEntries[0].Path
 	} else {
-		rootRelPath = "./"
+		rootRelPath = currDirRelPath
 	}
 
 	file, item, _statErr := stat(reqFsPath, authSuccess && !h.emptyRoot)
@@ -356,11 +362,11 @@ func (h *handler) getResponseData(r *http.Request) *responseData {
 	subItems = h.FilterItems(subItems)
 	rawSortBy, sortState := sortInfos(subItems, rawQuery, h.defaultSort)
 
-	if h.emptyRoot && status == http.StatusOK && r.RequestURI != "/" {
+	if h.emptyRoot && status == http.StatusOK && len(rawReqPath) > 1 {
 		status = http.StatusNotFound
 	}
 
-	subItemPrefix := getSubItemPrefix(rawReqPath, tailSlash)
+	subItemPrefix := getSubItemPrefix(currDirRelPath, rawReqPath, tailSlash)
 
 	canUpload := h.getCanUpload(item, rawReqPath, reqFsPath)
 	canMkdir := h.getCanMkdir(item, rawReqPath, reqFsPath)
@@ -400,10 +406,11 @@ func (h *handler) getResponseData(r *http.Request) *responseData {
 		errors: errs,
 		Status: status,
 
-		IsRoot:        isRoot,
-		Path:          rawReqPath,
-		Paths:         pathEntries,
-		RootRelPath:   rootRelPath,
+		IsRoot:      isRoot,
+		Path:        rawReqPath,
+		Paths:       pathEntries,
+		RootRelPath: rootRelPath,
+
 		File:          file,
 		Item:          item,
 		ItemName:      itemName,

src/serverHandler/responseData_test.go

@@ -5,7 +5,15 @@ import "testing"
 func TestGetPathEntries(t *testing.T) {
 	var result []pathEntry
 
-	result = getPathEntries("/a/b/c", false)
+	result = getPathEntries("./", "/", true)
+	if len(result) != 1 {
+		t.Error(len(result))
+	}
+	if result[0].Path != "./" || result[0].Name != "/" {
+		t.Error(result[0])
+	}
+
+	result = getPathEntries("./", "/a/b/c", false)
 	if len(result) != 4 {
 		t.Error(len(result))
 	}
@@ -22,7 +30,7 @@ func TestGetPathEntries(t *testing.T) {
 		t.Error(result[3])
 	}
 
-	result = getPathEntries("/a/b/c", true)
+	result = getPathEntries("./", "/a/b/c", true)
 	if len(result) != 4 {
 		t.Error(len(result))
 	}
@@ -38,4 +46,12 @@ func TestGetPathEntries(t *testing.T) {
 	if result[3].Path != "./" || result[3].Name != "c" {
 		t.Error(result[3])
 	}
+
+	result = getPathEntries("./foo", "/", true)
+	if len(result) != 1 {
+		t.Error(len(result))
+	}
+	if result[0].Path != "./foo" || result[0].Name != "/" {
+		t.Error(result[0])
+	}
 }