feat(param): normalize file system path from arguments

Author: marjune163

src/param/cli.go

@@ -7,7 +7,6 @@ import (
 	"../version"
 	"fmt"
 	"os"
-	"path/filepath"
 	"strings"
 )
 
@@ -267,6 +266,8 @@ func doParseCli() []*Param {
 	}
 
 	// init param data
+	var err error
+	var errs []error
 	for _, result := range results {
 		param := &Param{}
 
@@ -289,7 +290,8 @@ func doParseCli() []*Param {
 
 		// root
 		root, _ := result.GetString("root")
-		root, _ = util.NormalizeFsPath(root)
+		root, err = util.NormalizeFsPath(root)
+		serverErrHandler.CheckFatal(err)
 		param.Root = root
 
 		// normalize url prefixes
@@ -314,37 +316,39 @@ func doParseCli() []*Param {
 
 		// restrict access urls
 		restrictAccessUrls, _ := result.GetStrings("restrictaccessurls")
-		param.RestrictAccessUrls = normalizePathRestrictAccesses(restrictAccessUrls, util.CleanUrlPath)
+		param.RestrictAccessUrls, errs = normalizePathRestrictAccesses(restrictAccessUrls, util.NormalizeUrlPath)
+		serverErrHandler.CheckFatal(errs...)
 
 		// restrict access dirs
 		restrictAccessDirs, _ := result.GetStrings("restrictaccessdirs")
-		param.RestrictAccessDirs = normalizePathRestrictAccesses(restrictAccessDirs, filepath.Clean)
+		param.RestrictAccessDirs, errs = normalizePathRestrictAccesses(restrictAccessDirs, util.NormalizeFsPath)
+		serverErrHandler.CheckFatal(errs...)
 
 		// global headers
 		globalHeaders, _ := result.GetStrings("globalheaders")
 		param.GlobalHeaders = entriesToHeaders(globalHeaders)
 
 		// headers urls
 		arrHeadersUrls, _ := result.GetStrings("headersurls")
-		param.HeadersUrls = normalizePathHeadersMap(arrHeadersUrls, util.CleanUrlPath)
+		param.HeadersUrls, errs = normalizePathHeadersMap(arrHeadersUrls, util.NormalizeUrlPath)
+		serverErrHandler.CheckFatal(errs...)
 
 		// headers dirs
 		arrHeadersDirs, _ := result.GetStrings("headersdirs")
-		param.HeadersDirs = normalizePathHeadersMap(arrHeadersDirs, filepath.Clean)
+		param.HeadersDirs, errs = normalizePathHeadersMap(arrHeadersDirs, util.NormalizeFsPath)
+		serverErrHandler.CheckFatal(errs...)
 
 		// certificate
 		certFiles, _ := result.GetStrings("certs")
 		keyFiles, _ := result.GetStrings("keys")
 		certs, errs := LoadCertificates(certFiles, keyFiles)
-		if len(errs) > 0 {
-			serverErrHandler.CheckFatal(errs...)
-		} else {
-			param.Certificates = certs
-		}
+		serverErrHandler.CheckFatal(errs...)
+		param.Certificates = certs
 
 		// normalize aliases
 		arrAlias, _ := result.GetStrings("aliases")
-		param.Aliases = normalizePathMaps(arrAlias)
+		param.Aliases, errs = normalizePathMaps(arrAlias)
+		serverErrHandler.CheckFatal(errs...)
 
 		// normalize upload urls
 		arrUploadUrls, _ := result.GetStrings("uploadurls")

src/param/strUtil.go

@@ -53,16 +53,22 @@ func splitKeyValue(input string) (sep rune, sepLen int, k, v string, ok bool) {
 	return sep, sepLen, k, v, true
 }
 
-func normalizePathRestrictAccesses(inputs []string, normalizePath func(string) string) map[string][]string {
-	maps := make(map[string][]string, len(inputs))
+func normalizePathRestrictAccesses(
+	inputs []string,
+	normalizePath func(string) (string, error),
+) (maps map[string][]string, errs []error) {
+	maps = make(map[string][]string, len(inputs))
 
 	for i := range inputs {
 		reqPath, hosts, ok := splitKeyValues(inputs[i])
 		if !ok {
 			continue
 		}
 
-		normalizedPath := normalizePath(reqPath)
+		normalizedPath, err := normalizePath(reqPath)
+		if err != nil {
+			errs = append(errs, err)
+		}
 		normalizedHosts := util.ExtractHostsFromUrls(hosts)
 
 		for existingPath := range maps {
@@ -75,11 +81,14 @@ func normalizePathRestrictAccesses(inputs []string, normalizePath func(string) s
 		maps[normalizedPath] = append(maps[normalizedPath], normalizedHosts...)
 	}
 
-	return maps
+	return
 }
 
-func normalizePathHeadersMap(inputs []string, normalizePath func(string) string) map[string][][2]string {
-	maps := make(map[string][][2]string, len(inputs))
+func normalizePathHeadersMap(
+	inputs []string,
+	normalizePath func(string) (string, error),
+) (maps map[string][][2]string, errs []error) {
+	maps = make(map[string][][2]string, len(inputs))
 
 	for _, input := range inputs {
 		sep, sepLen, reqPath, header, ok := splitKeyValue(input)
@@ -91,7 +100,10 @@ func normalizePathHeadersMap(inputs []string, normalizePath func(string) string)
 			continue
 		}
 
-		normalizedPath := normalizePath(reqPath)
+		normalizedPath, err := normalizePath(reqPath)
+		if err != nil {
+			errs = append(errs, err)
+		}
 		headerName := header[:sepIndex]
 		headerValue := header[sepIndex+1:]
 
@@ -105,11 +117,12 @@ func normalizePathHeadersMap(inputs []string, normalizePath func(string) string)
 		maps[normalizedPath] = append(maps[normalizedPath], [2]string{headerName, headerValue})
 	}
 
-	return maps
+	return
 }
 
-func normalizePathMaps(inputs []string) map[string]string {
-	maps := make(map[string]string, len(inputs))
+func normalizePathMaps(inputs []string) (maps map[string]string, errs []error) {
+	maps = make(map[string]string, len(inputs))
+	var err error
 
 	for _, input := range inputs {
 		_, _, urlPath, fsPath, ok := splitKeyValue(input)
@@ -118,7 +131,10 @@ func normalizePathMaps(inputs []string) map[string]string {
 		}
 
 		urlPath = util.CleanUrlPath(urlPath)
-		fsPath = filepath.Clean(fsPath)
+		fsPath, err = util.NormalizeFsPath(fsPath)
+		if err != nil {
+			errs = append(errs, err)
+		}
 
 		for existingUrl := range maps {
 			if util.IsPathEqual(existingUrl, urlPath) {
@@ -130,7 +146,7 @@ func normalizePathMaps(inputs []string) map[string]string {
 		maps[urlPath] = fsPath
 	}
 
-	return maps
+	return
 }
 
 func normalizeUrlPaths(inputs []string) []string {

src/param/strUtil_test.go

@@ -1,7 +1,8 @@
 package param
 
 import (
-	"path"
+	"../util"
+	"path/filepath"
 	"testing"
 )
 
@@ -116,11 +117,11 @@ func TestSplitKeyValue(t *testing.T) {
 }
 
 func TestNormalizePathRestrictAccesses(t *testing.T) {
-	results := normalizePathRestrictAccesses([]string{
+	results, _ := normalizePathRestrictAccesses([]string{
 		":/foo:host1:host2",
 		":/foo/:host3:host4",
 		":/bar",
-	}, path.Clean)
+	}, util.NormalizeUrlPath)
 
 	if len(results) != 2 {
 		t.Error()
@@ -136,15 +137,15 @@ func TestNormalizePathRestrictAccesses(t *testing.T) {
 func TestNormalizePathHeadersMap(t *testing.T) {
 	var result map[string][][2]string
 
-	result = normalizePathHeadersMap([]string{
+	result, _ = normalizePathHeadersMap([]string{
 		":/foo:X-header1:X-Value1",
 		":/foo/:X-header2:X-Value2",
 		":/bar:X-header3:X-Value3",
 		":baz",
 		":baz:",
 		":baz:X-Not-Valid",
 		":baz:X-Not-Valid:",
-	}, path.Clean)
+	}, util.NormalizeUrlPath)
 
 	if len(result) != 2 {
 		t.Error(result)
@@ -170,20 +171,23 @@ func TestNormalizePathHeadersMap(t *testing.T) {
 
 func TestNormalizePathMaps(t *testing.T) {
 	var maps map[string]string
+	var fsPath string
 
-	maps = normalizePathMaps([]string{":/data/lib://usr/lib"})
-	if maps["/data/lib"] != "/usr/lib" {
+	maps, _ = normalizePathMaps([]string{":/data/lib://usr/lib"})
+	fsPath, _ = filepath.Abs("/usr/lib")
+	if maps["/data/lib"] != fsPath {
 		t.Error(maps)
 	}
 
-	maps = normalizePathMaps([]string{":/data/lib://usr/lib", "@foo@bar/baz"})
+	maps, _ = normalizePathMaps([]string{":/data/lib://usr/lib", "@foo@bar/baz"})
 	if len(maps) != 2 {
 		t.Error(maps)
 	}
 	if maps["/data/lib"] != "/usr/lib" {
 		t.Error(maps)
 	}
-	if maps["/foo"] != "bar/baz" {
+	fsPath, _ = filepath.Abs("bar/baz")
+	if maps["/foo"] != fsPath {
 		t.Error(maps)
 	}
 }

src/util/path.go

@@ -92,3 +92,8 @@ func hasPrefixDirNoCase(absPath, prefix string, separator byte) bool {
 
 	return false
 }
+
+func NormalizeUrlPath(input string) (string, error) { // keep same func signature as `NormalizeFsPath`
+	result := CleanUrlPath(input)
+	return result, nil
+}