From 3a05f775b7bd23497612d694dba77d705bebfd40 Mon Sep 17 00:00:00 2001 From: zuna Date: Thu, 29 Oct 2026 13:54:01 +0800 Subject: [PATCH] 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 --- binding/binding_test.go | 47 +++++++++++++++++++ binding/form_mapping.go | 17 +++++-- binding/form_mapping_test.go | 90 +++++++++++++++++++++++++++++++++++- 3 files changed, 149 insertions(+), 5 deletions(-) diff --git a/binding/binding_test.go b/binding/binding_test.go index f90488cd..738e063a 100644 --- a/binding/binding_test.go +++ b/binding/binding_test.go @@ -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()) diff --git a/binding/form_mapping.go b/binding/form_mapping.go index 6982fd4f..d6c55a9b 100644 --- a/binding/form_mapping.go +++ b/binding/form_mapping.go @@ -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 } diff --git a/binding/form_mapping_test.go b/binding/form_mapping_test.go index c78f7398..01c9f4da 100644 --- a/binding/form_mapping_test.go +++ b/binding/form_mapping_test.go @@ -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 {