fix(binding): stop infinite recursion on self-referencing structs

Form-style binding (form, query, multipart, header, uri) walked struct
fields recursively and allocated every nil pointer to a struct. For a
type that refers to itself, such as `Parent *Node`, each new level held
another nil pointer, so binding never ended and the process died with
an unrecoverable stack overflow, even on an empty request.

Track the struct types whose fields are being mapped on the current
path, and do not walk a type that is already on it. A recursive field
can still be set as a whole value from a matching key; otherwise it
stays nil. Non-recursive structs bind exactly as before at any depth.

Fixes #3937
This commit is contained in:
zuna 2026-10-29 13:54:01 +08:00
parent 0f09c3a9b4
commit 3a05f775b7
3 changed files with 149 additions and 5 deletions

View File

@ -855,6 +855,53 @@ func TestUriInnerBinding(t *testing.T) {
assert.Equal(t, expectedAge, tag.S.Age)
}
func TestBindingRecursiveStruct(t *testing.T) {
type node struct {
Name string `form:"name" header:"name" uri:"name"`
Parent *node
}
t.Run("query", func(t *testing.T) {
var obj node
req := requestWithBody(http.MethodGet, "/?name=root", "")
require.NoError(t, Query.Bind(req, &obj))
assert.Equal(t, "root", obj.Name)
assert.Nil(t, obj.Parent)
})
t.Run("form", func(t *testing.T) {
var obj node
req := requestWithBody(http.MethodPost, "/", "name=root")
req.Header.Set("Content-Type", MIMEPOSTForm)
require.NoError(t, Form.Bind(req, &obj))
assert.Equal(t, "root", obj.Name)
assert.Nil(t, obj.Parent)
})
t.Run("multipart", func(t *testing.T) {
var obj node
req := createFormMultipartRequest(t)
require.NoError(t, FormMultipart.Bind(req, &obj))
assert.Nil(t, obj.Parent)
})
t.Run("header", func(t *testing.T) {
var obj node
req := requestWithBody(http.MethodGet, "/", "")
req.Header.Set("name", "root")
require.NoError(t, Header.Bind(req, &obj))
assert.Equal(t, "root", obj.Name)
assert.Nil(t, obj.Parent)
})
t.Run("uri", func(t *testing.T) {
var obj node
require.NoError(t, Uri.BindUri(map[string][]string{"name": {"root"}}, &obj))
assert.Equal(t, "root", obj.Name)
assert.Nil(t, obj.Parent)
})
}
func testFormBindingEmbeddedStruct(t *testing.T, method, path, badPath, body, badBody string) {
b := Form
assert.Equal(t, "form", b.Name())

View File

@ -11,6 +11,7 @@ import (
"maps"
"mime/multipart"
"reflect"
"slices"
"strconv"
"strings"
"time"
@ -77,11 +78,15 @@ func (form formSource) TrySet(value reflect.Value, field reflect.StructField, ta
}
func mappingByPtr(ptr any, setter setter, tag string) error {
_, err := mapping(reflect.ValueOf(ptr), emptyField, setter, tag)
_, err := mapping(reflect.ValueOf(ptr), emptyField, setter, tag, nil)
return err
}
func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
// mapping sets value from setter, walking struct fields recursively.
// parents holds the struct types whose fields are being mapped on the
// current path; a struct type that is already there is not walked again,
// which stops self-referencing types from recursing forever.
func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string, parents []reflect.Type) (bool, error) {
if field.Tag.Get(tag) == "-" { // just ignoring this field
return false, nil
}
@ -95,7 +100,7 @@ func mapping(value reflect.Value, field reflect.StructField, setter setter, tag
isNew = true
vPtr = reflect.New(value.Type().Elem())
}
isSet, err := mapping(vPtr.Elem(), field, setter, tag)
isSet, err := mapping(vPtr.Elem(), field, setter, tag, parents)
if err != nil {
return false, err
}
@ -117,6 +122,10 @@ func mapping(value reflect.Value, field reflect.StructField, setter setter, tag
if vKind == reflect.Struct {
tValue := value.Type()
if slices.Contains(parents, tValue) {
return false, nil
}
parents = append(parents, tValue)
var isSet bool
for i := range value.NumField() {
@ -124,7 +133,7 @@ func mapping(value reflect.Value, field reflect.StructField, setter setter, tag
if sf.PkgPath != "" && !sf.Anonymous { // unexported
continue
}
ok, err := mapping(value.Field(i), sf, setter, tag)
ok, err := mapping(value.Field(i), sf, setter, tag, parents)
if err != nil {
return false, err
}

View File

@ -60,7 +60,7 @@ func TestMappingBaseTypes(t *testing.T) {
field := val.Elem().Type().Field(0)
_, err := mapping(val, emptyField, formSource{field.Name: {tt.form}}, "form")
_, err := mapping(val, emptyField, formSource{field.Name: {tt.form}}, "form", nil)
require.NoError(t, err, testName)
actual := val.Elem().Field(0).Interface()
@ -494,6 +494,94 @@ func TestMappingIgnoredCircularRef(t *testing.T) {
require.NoError(t, err)
}
type recursiveNode struct {
Name string `form:"name"`
Parent *recursiveNode
}
type cycleA struct {
B *cycleB
}
type cycleB struct {
X int `form:"x"`
A *cycleA
}
func TestMappingRecursiveStruct(t *testing.T) {
var s recursiveNode
err := mappingByPtr(&s, formSource{}, "form")
require.NoError(t, err)
assert.Nil(t, s.Parent)
}
func TestMappingRecursiveStructSetsFieldsOutsideCycle(t *testing.T) {
var s recursiveNode
err := mappingByPtr(&s, formSource{"name": {"root"}}, "form")
require.NoError(t, err)
assert.Equal(t, "root", s.Name)
assert.Nil(t, s.Parent)
}
func TestMappingRecursiveStructFieldAsWholeValue(t *testing.T) {
var s recursiveNode
err := mappingByPtr(&s, formSource{"Parent": {`{"Name": "p"}`}}, "form")
require.NoError(t, err)
require.NotNil(t, s.Parent)
assert.Equal(t, "p", s.Parent.Name)
}
func TestMappingMutuallyRecursiveStructs(t *testing.T) {
var s cycleA
err := mappingByPtr(&s, formSource{}, "form")
require.NoError(t, err)
assert.Nil(t, s.B)
err = mappingByPtr(&s, formSource{"x": {"1"}}, "form")
require.NoError(t, err)
require.NotNil(t, s.B)
assert.Equal(t, 1, s.B.X)
assert.Nil(t, s.B.A)
}
func TestMappingDeepNonRecursiveStruct(t *testing.T) {
type chainL6 struct {
Leaf string `form:"leaf"`
}
type chainL5 struct{ N *chainL6 }
type chainL4 struct{ N *chainL5 }
type chainL3 struct{ N *chainL4 }
type chainL2 struct{ N *chainL3 }
type chainL1 struct{ N *chainL2 }
var s chainL1
err := mappingByPtr(&s, formSource{"leaf": {"hello"}}, "form")
require.NoError(t, err)
require.NotNil(t, s.N)
require.NotNil(t, s.N.N)
require.NotNil(t, s.N.N.N)
require.NotNil(t, s.N.N.N.N)
require.NotNil(t, s.N.N.N.N.N)
assert.Equal(t, "hello", s.N.N.N.N.N.Leaf)
}
func TestMappingSameTypeSiblingFields(t *testing.T) {
type siblingT struct {
V int `form:"v"`
}
var s struct {
X *siblingT
Y *siblingT
}
err := mappingByPtr(&s, formSource{"v": {"1"}}, "form")
require.NoError(t, err)
require.NotNil(t, s.X)
require.NotNil(t, s.Y)
assert.Equal(t, 1, s.X.V)
assert.Equal(t, 1, s.Y.V)
}
type customUnmarshalParamHex int
func (f *customUnmarshalParamHex) UnmarshalParam(param string) error {