perf(path): replace regex with custom functions in redirectTrailingSlash

Author: ddevsr

gin.go

@@ -11,7 +11,6 @@ import (
 	"net/http"
 	"os"
 	"path"
-	"regexp"
 	"strings"
 	"sync"
 
@@ -48,11 +47,6 @@ var defaultTrustedCIDRs = []*net.IPNet{
 	},
 }
 
-var (
-	regSafePrefix         = regexp.MustCompile("[^a-zA-Z0-9/-]+")
-	regRemoveRepeatedChar = regexp.MustCompile("/{2,}")
-)
-
 // HandlerFunc defines the handler used by gin middleware as return value.
 type HandlerFunc func(*Context)
 
@@ -782,12 +776,23 @@ func serveError(c *Context, code int, defaultMessage []byte) {
 	c.writermem.WriteHeaderNow()
 }
 
+// sanitizePathChars removes unsafe characters from path strings,
+// keeping only ASCII letters, ASCII numbers, forward slashes, and hyphens.
+func sanitizePathChars(s string) string {
+	return strings.Map(func(r rune) rune {
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '/' || r == '-' {
+			return r
+		}
+		return -1
+	}, s)
+}
+
 func redirectTrailingSlash(c *Context) {
 	req := c.Request
 	p := req.URL.Path
 	if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." {
-		prefix = regSafePrefix.ReplaceAllString(prefix, "")
-		prefix = regRemoveRepeatedChar.ReplaceAllString(prefix, "/")
+		prefix = sanitizePathChars(prefix)
+		prefix = removeRepeatedChar(prefix, '/')
 
 		p = prefix + "/" + req.URL.Path
 	}

path.go

@@ -5,6 +5,8 @@
 
 package gin
 
+const stackBufSize = 128
+
 // cleanPath is the URL version of path.Clean, it returns a canonical URL path
 // for p, eliminating . and .. elements.
 //
@@ -36,8 +38,6 @@ func cleanPath(p string) string {
 		return "/" + p
 	}
 
-	const stackBufSize = 128
-
 	// Reasonably sized buffer on stack to avoid allocations in the common case.
 	// If a larger buffer is required, it gets allocated dynamically.
 	buf := make([]byte, 0, stackBufSize)
@@ -165,3 +165,55 @@ func bufApp(buf *[]byte, s string, w int, c byte) {
 	}
 	b[w] = c
 }
+
+// removeRepeatedChar removes multiple consecutive 'char's from a string.
+// if s == "/a//b///c////" && char == '/', it returns "/a/b/c/"
+func removeRepeatedChar(s string, char byte) string {
+	// Check if there are any consecutive chars
+	hasRepeatedChar := false
+	for i := 1; i < len(s); i++ {
+		if s[i] == char && s[i-1] == char {
+			hasRepeatedChar = true
+			break
+		}
+	}
+	if !hasRepeatedChar {
+		return s
+	}
+
+	// Reasonably sized buffer on stack to avoid allocations in the common case.
+	buf := make([]byte, 0, stackBufSize)
+
+	// Invariants:
+	//      reading from s; r is index of next byte to process.
+	//      writing to buf; w is index of next byte to write.
+	r := 0
+	w := 0
+
+	for n := len(s); r < n; {
+		if s[r] == char {
+			// Write the first char
+			bufApp(&buf, s, w, char)
+			w++
+			r++
+
+			// Skip all consecutive chars
+			for r < n && s[r] == char {
+				r++
+			}
+		} else {
+			// Copy non-char character
+			bufApp(&buf, s, w, s[r])
+			w++
+			r++
+		}
+	}
+
+	// If the original string was not modified (or only shortened at the end),
+	// return the respective substring of the original string.
+	// Otherwise, return a new string from the buffer.
+	if len(buf) == 0 {
+		return s[:w]
+	}
+	return string(buf[:w])
+}

path_test.go

@@ -6,6 +6,7 @@
 package gin
 
 import (
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -70,6 +71,44 @@ var cleanTests = []cleanPathTest{
 	{"abc/../../././../def", "/def"},
 }
 
+var regRemoveRepeatedChar = regexp.MustCompile("/{2,}")
+
+func removeRepeatedSlashRegexp(s string) string {
+	return regRemoveRepeatedChar.ReplaceAllString(s, "/")
+}
+
+func removeRepeatedSlashLoopReplace(s string) string {
+	for strings.Contains(s, "//") {
+		s = strings.ReplaceAll(s, "//", "/")
+	}
+	return s
+}
+
+func removeRepeatedSlashStringBuilder(s string) string {
+	if !strings.Contains(s, "//") {
+		return s
+	}
+
+	var sb strings.Builder
+	sb.Grow(len(s) - 1)
+	prevChar := rune(0)
+
+	for _, r := range s {
+		if r == '/' && prevChar == '/' {
+			continue
+		}
+		sb.WriteRune(r)
+		prevChar = r
+	}
+
+	return sb.String()
+}
+
+// removeRepeatedSlash removes multiple consecutive slashes from a string.
+func removeRepeatedSlash(s string) string {
+	return removeRepeatedChar(s, '/')
+}
+
 func TestPathClean(t *testing.T) {
 	for _, test := range cleanTests {
 		assert.Equal(t, test.result, cleanPath(test.path))
@@ -144,3 +183,104 @@ func BenchmarkPathCleanLong(b *testing.B) {
 		}
 	}
 }
+
+func TestRemoveRepeatedChar(t *testing.T) {
+	testCases := []struct {
+		name string
+		str  string
+		char byte
+		want string
+	}{
+		{
+			name: "empty",
+			str:  "",
+			char: 'a',
+			want: "",
+		},
+		{
+			name: "noSlash",
+			str:  "abc",
+			char: ',',
+			want: "abc",
+		},
+		{
+			name: "withSlash",
+			str:  "/a/b/c/",
+			char: '/',
+			want: "/a/b/c/",
+		},
+		{
+			name: "withRepeatedSlashes",
+			str:  "/a//b///c////",
+			char: '/',
+			want: "/a/b/c/",
+		},
+		{
+			name: "threeSlashes",
+			str:  "///",
+			char: '/',
+			want: "/",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			res := removeRepeatedChar(tc.str, tc.char)
+			assert.Equal(t, tc.want, res)
+		})
+	}
+}
+
+func benchmarkRemoveRepeatedSlash(b *testing.B, prefix string) {
+	testCases := []struct {
+		name string
+		fn   func(string) string
+	}{
+		{
+			name: "regexp",
+			fn:   removeRepeatedSlashRegexp,
+		},
+		{
+			name: "loopReplace",
+			fn:   removeRepeatedSlashLoopReplace,
+		},
+		{
+			name: "stringBuilder",
+			fn:   removeRepeatedSlashStringBuilder,
+		},
+		{
+			name: "buff",
+			fn:   removeRepeatedSlash,
+		},
+	}
+
+	for _, tc := range testCases {
+		b.Run(prefix+" "+tc.name, func(b *testing.B) {
+			b.ResetTimer()
+			b.ReportAllocs()
+			for b.Loop() {
+				tc.fn(prefix)
+			}
+		})
+	}
+}
+
+func BenchmarkRemoveRepeatedSlash_MultipleSlashes(b *testing.B) {
+	prefix := "/somePrefix/more//text///more////"
+	benchmarkRemoveRepeatedSlash(b, prefix)
+}
+
+func BenchmarkRemoveRepeatedSlash_TwoSlashes(b *testing.B) {
+	prefix := "/somePrefix/more//"
+	benchmarkRemoveRepeatedSlash(b, prefix)
+}
+
+func BenchmarkRemoveNoRepeatedSlash(b *testing.B) {
+	prefix := "/somePrefix/more/text/"
+	benchmarkRemoveRepeatedSlash(b, prefix)
+}
+
+func BenchmarkRemoveNoSlash(b *testing.B) {
+	prefix := "/somePrefixmoretext"
+	benchmarkRemoveRepeatedSlash(b, prefix)
+}