From ea9fab99e01d55a5e4f8daacc0d11ccffaee0a15 Mon Sep 17 00:00:00 2001 From: HazyLab Date: Sat, 10 Oct 2026 06:18:54 +0200 Subject: [PATCH] fix(tree): grow skippedNodes when pooled capacity is stale (#4852) getValue resliced the backtrack stack to index+1 on the assumption that its capacity equals Engine.maxSections. The pool captures that capacity at allocation. Routes registered afterwards raise maxSections without resizing the pooled slice. The next request that needs one more frame panics inside the router, before Recovery. append grows the slice when the captured capacity is short and preserves the existing backtrack behaviour when it is already sufficient. The reset at entry stays: getValue still runs once per method tree on the same stack. Co-authored-by: hazyhaar Co-authored-by: Bo-Yi Wu --- routes_test.go | 24 ++++++++++++++++++++++++ tree.go | 15 +++++++-------- 2 files changed, 31 insertions(+), 8 deletions(-) diff --git a/routes_test.go b/routes_test.go index 3306233f..a032a2b7 100644 --- a/routes_test.go +++ b/routes_test.go @@ -847,6 +847,30 @@ func TestEngineHandleMethodNotAllowedCornerCase(t *testing.T) { assert.Equal(t, http.StatusNotFound, w.Code) } +func TestLateRouteRegistrationSkippedNodes(t *testing.T) { + router := New() + router.HandleMethodNotAllowed = true + router.GET("/a", func(c *Context) { c.Status(http.StatusOK) }) + + w := PerformRequest(router, http.MethodGet, "/a") + if w.Code != http.StatusOK { + t.Fatalf("warmup status = %d, want 200", w.Code) + } + + h := func(c *Context) {} + router.GET("/x/y/z/w", h) + router.GET("/x/y/:id/w", h) + router.GET("/x/:id/z/w", h) + router.GET("/:id/y/z/w", h) + + req := httptest.NewRequest(http.MethodPost, "/x/y/z/w/extra", nil) + w = httptest.NewRecorder() + router.ServeHTTP(w, req) + if w.Code != http.StatusNotFound { + t.Fatalf("status = %d, want 404", w.Code) + } +} + // TestIssue4818_skippedNodesOverflow_Panic reproduces the panic from issue #4818: // with HandleMethodNotAllowed enabled, getValue is called once per method tree // reusing the same c.skippedNodes stack without resetting it, so residue diff --git a/tree.go b/tree.go index 6efe2e0e..6842d225 100644 --- a/tree.go +++ b/tree.go @@ -420,10 +420,11 @@ func (n *node) getValue(path string, params *Params, skippedNodes *[]skippedNode // Reset the skipped-nodes stack on entry. getValue is called once per // method tree (e.g. in the HandleMethodNotAllowed loop) reusing the same - // pooled Context stack, and the walk below grows it via a raw reslice that - // cannot exceed engine.maxSections. Without this reset the residue from a - // previous tree leaks into the next call and can panic with "slice bounds - // out of range" once the accumulated length passes the capacity. + // pooled Context stack. Without this reset the residue from a previous + // tree leaks into the next call. The walk grows the stack with append: + // a context allocated before addRoute raised maxSections must still be + // able to record one more backtrack frame. A raw reslice of the capacity + // captured at pool allocation panics with "slice bounds out of range". *skippedNodes = (*skippedNodes)[:0] walk: // Outer loop for walking the tree @@ -439,9 +440,7 @@ walk: // Outer loop for walking the tree if c == idxc { // strings.HasPrefix(n.children[len(n.children)-1].path, ":") == n.wildChild if n.wildChild { - index := len(*skippedNodes) - *skippedNodes = (*skippedNodes)[:index+1] - (*skippedNodes)[index] = skippedNode{ + *skippedNodes = append(*skippedNodes, skippedNode{ path: prefix + path, node: &node{ path: n.path, @@ -453,7 +452,7 @@ walk: // Outer loop for walking the tree fullPath: n.fullPath, }, paramsCount: globalParamsCount, - } + }) } n = n.children[i]