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 {