feat(param): remove duplicated allowed hosts in restrict access

Author: marjune163

src/param/main.go

@@ -131,17 +131,25 @@ func (param *Param) normalize() (errs []error) {
 	}
 
 	// restrict access
-	param.RestrictAccessUrls, es = normalizePathValues(param.RestrictAccessUrls, true, util.NormalizeUrlPath, util.ExtractHostsFromUrls)
-	errs = append(errs, es...)
+	param.RestrictAccessUrls, es = normalizeAllPathValues(param.RestrictAccessUrls, true, util.NormalizeUrlPath, util.ExtractHostsFromUrls)
+	if len(es) == 0 {
+		dedupAllPathValues(param.RestrictAccessUrls)
+	} else {
+		errs = append(errs, es...)
+	}
 
-	param.RestrictAccessDirs, es = normalizePathValues(param.RestrictAccessDirs, true, util.NormalizeFsPath, util.ExtractHostsFromUrls)
-	errs = append(errs, es...)
+	param.RestrictAccessDirs, es = normalizeAllPathValues(param.RestrictAccessDirs, true, util.NormalizeFsPath, util.ExtractHostsFromUrls)
+	if len(es) == 0 {
+		dedupAllPathValues(param.RestrictAccessDirs)
+	} else {
+		errs = append(errs, es...)
+	}
 
 	// headers
-	param.HeadersUrls, es = normalizePathValues(param.HeadersUrls, false, util.NormalizeUrlPath, normalizeHeaders)
+	param.HeadersUrls, es = normalizeAllPathValues(param.HeadersUrls, false, util.NormalizeUrlPath, normalizeHeaders)
 	errs = append(errs, es...)
 
-	param.HeadersDirs, es = normalizePathValues(param.HeadersDirs, false, util.NormalizeFsPath, normalizeHeaders)
+	param.HeadersDirs, es = normalizeAllPathValues(param.HeadersDirs, false, util.NormalizeFsPath, normalizeHeaders)
 	errs = append(errs, es...)
 
 	// upload/mkdir/delete/archive/cors/auth urls/dirs

src/param/strUtil.go

@@ -78,7 +78,7 @@ func splitAllKeyValue(inputs []string) (results [][2]string) {
 	return
 }
 
-func normalizePathValues(
+func normalizeAllPathValues(
 	inputs [][]string,
 	keepEmptyValuesEntry bool,
 	normalizePath func(string) (string, error),
@@ -128,6 +128,35 @@ eachInput:
 	return
 }
 
+func dedupPathValues(inputs []string) []string {
+	if len(inputs) <= 2 { // path & single value
+		return inputs
+	}
+
+	values := inputs[1:]
+	endIndex := 1
+eachValue:
+	for i, length := 1, len(values); i < length; i++ {
+		for j := 0; j < endIndex; j++ {
+			if values[i] == values[j] {
+				continue eachValue
+			}
+		}
+		if endIndex != i {
+			values[endIndex] = values[i]
+		}
+		endIndex++
+	}
+
+	return inputs[:1+endIndex]
+}
+
+func dedupAllPathValues(inputs [][]string) {
+	for i, iLen := 0, len(inputs); i < iLen; i++ {
+		inputs[i] = dedupPathValues(inputs[i])
+	}
+}
+
 func normalizePathMaps(inputs [][2]string) (results [][2]string, errs []error) {
 	results = make([][2]string, 0, len(inputs))
 

src/param/strUtil_test.go

@@ -130,7 +130,7 @@ func TestSplitAllKeyValue(t *testing.T) {
 }
 
 func TestNormalizePathRestrictAccesses(t *testing.T) {
-	results, _ := normalizePathValues([][]string{
+	results, _ := normalizeAllPathValues([][]string{
 		{"/foo", "host1", "host2"},
 		{"/foo/", "host3", "host4"},
 		{"/bar"},
@@ -150,7 +150,7 @@ func TestNormalizePathRestrictAccesses(t *testing.T) {
 func TestNormalizePathHeadersMap(t *testing.T) {
 	var result [][]string
 
-	result, _ = normalizePathValues([][]string{
+	result, _ = normalizeAllPathValues([][]string{
 		{"/foo", "X-header1", "X-Value1"},
 		{"/foo/", "X-header2", "X-Value2"},
 		{"/bar", "X-header3", "X-Value3"},
@@ -217,6 +217,40 @@ func TestNormalizePathMaps(t *testing.T) {
 	}
 }
 
+func TestDedupPathValues(t *testing.T) {
+	var result []string
+
+	result = dedupPathValues(nil)
+	if !expectStrings(result) {
+		t.Error(result)
+	}
+
+	result = dedupPathValues([]string{})
+	if !expectStrings(result) {
+		t.Error(result)
+	}
+
+	result = dedupPathValues([]string{"/foo"})
+	if !expectStrings(result, "/foo") {
+		t.Error(result)
+	}
+
+	result = dedupPathValues([]string{"/foo", "wow"})
+	if !expectStrings(result, "/foo", "wow") {
+		t.Error(result)
+	}
+
+	result = dedupPathValues([]string{"/foo", "aa", "bb", "cc"})
+	if !expectStrings(result, "/foo", "aa", "bb", "cc") {
+		t.Error(result)
+	}
+
+	result = dedupPathValues([]string{"/foo", "xx", "yy", "xx", "zz", "zz", "/foo"})
+	if !expectStrings(result, "/foo", "xx", "yy", "zz", "/foo") {
+		t.Error(result)
+	}
+}
+
 func TestNormalizeFilenames(t *testing.T) {
 	files := []string{"", "abc/def.txt", "hello.txt"}
 	normalized := normalizeFilenames(files)