encoding/json: detect cyclic maps and slices

The documentation says:

JSON cannot represent cyclic data structures and Marshal does not
handle them. Passing cyclic structures to Marshal will result in
an error.

However, passing cyclic maps or slices still results in an infinite
recursion.

Cycle detection is now added into mapEncoder and sliceEncoder.

	name                                 old time/op    new time/op     delta
	CodeEncoder-16                          933µs ± 0%     1324µs ± 0%   ~     (p=1.000 n=1+1)
	CodeMarshal-16                          940µs ± 0%     1436µs ± 0%   ~     (p=1.000 n=1+1)

	name                                 old speed      new speed       delta
	CodeEncoder-16                       2.08GB/s ± 0%   1.47GB/s ± 0%   ~     (p=1.000 n=1+1)
	CodeMarshal-16                       2.06GB/s ± 0%   1.35GB/s ± 0%   ~     (p=1.000 n=1+1)

	name                                 old alloc/op   new alloc/op    delta
	CodeEncoder-16                          7.00B ± 0%  94933.00B ± 0%   ~     (p=1.000 n=1+1)
	CodeMarshal-16                         1.98MB ± 0%     2.04MB ± 0%   ~     (p=1.000 n=1+1)

	name                                 old allocs/op  new allocs/op   delta
	CodeEncoder-16                           0.00        11816.00 ± 0%   ~     (p=1.000 n=1+1)
	CodeMarshal-16                           1.00 ± 0%   11816.00 ± 0%   ~     (p=1.000 n=1+1)

Fixes #40745.

Author: lujjjh

src/encoding/json/encode.go

@@ -779,6 +779,16 @@ func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 		e.WriteString("null")
 		return
 	}
+	if e.ptrLevel++; e.ptrLevel > startDetectingCyclesAfter {
+		// We're a large number of nested ptrEncoder.encode calls deep;
+		// start checking if we've run into a pointer cycle.
+		ptr := v.Pointer()
+		if _, ok := e.ptrSeen[ptr]; ok {
+			e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
+		}
+		e.ptrSeen[ptr] = struct{}{}
+		defer delete(e.ptrSeen, ptr)
+	}
 	e.WriteByte('{')
 
 	// Extract and sort the keys.
@@ -801,6 +811,7 @@ func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 		me.elemEnc(e, v.MapIndex(kv.v), opts)
 	}
 	e.WriteByte('}')
+	e.ptrLevel--
 }
 
 func newMapEncoder(t reflect.Type) encoderFunc {
@@ -857,7 +868,18 @@ func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
 		e.WriteString("null")
 		return
 	}
+	if e.ptrLevel++; e.ptrLevel > startDetectingCyclesAfter {
+		// We're a large number of nested ptrEncoder.encode calls deep;
+		// start checking if we've run into a pointer cycle.
+		ptr := v.Pointer()
+		if _, ok := e.ptrSeen[ptr]; ok {
+			e.error(&UnsupportedValueError{v, fmt.Sprintf("encountered a cycle via %s", v.Type())})
+		}
+		e.ptrSeen[ptr] = struct{}{}
+		defer delete(e.ptrSeen, ptr)
+	}
 	se.arrayEnc(e, v, opts)
+	e.ptrLevel--
 }
 
 func newSliceEncoder(t reflect.Type) encoderFunc {

src/encoding/json/encode_test.go

@@ -183,7 +183,11 @@ type PointerCycleIndirect struct {
 	Ptrs []interface{}
 }
 
-var pointerCycleIndirect = &PointerCycleIndirect{}
+var (
+	pointerCycleIndirect = &PointerCycleIndirect{}
+	mapCycle             = make(map[string]interface{})
+	sliceCycle           = []interface{}{nil}
+)
 
 func init() {
 	ptr := &SamePointerNoCycle{}
@@ -192,6 +196,9 @@ func init() {
 
 	pointerCycle.Ptr = pointerCycle
 	pointerCycleIndirect.Ptrs = []interface{}{pointerCycleIndirect}
+
+	mapCycle["x"] = mapCycle
+	sliceCycle[0] = sliceCycle
 }
 
 func TestSamePointerNoCycle(t *testing.T) {
@@ -206,6 +213,8 @@ var unsupportedValues = []interface{}{
 	math.Inf(1),
 	pointerCycle,
 	pointerCycleIndirect,
+	mapCycle,
+	sliceCycle,
 }
 
 func TestUnsupportedValues(t *testing.T) {