golang/mikael/madonctl: comparison vendor/google.golang.org/protobuf/encoding/protowire/wire.go

equal deleted inserted replaced

-:db4911b0c721
+:445e01aede7e
 // Number represents the field number.
 type Number int32
 const (
-	MinValidNumber      Number = 1
+	MinValidNumber        Number = 1
-	FirstReservedNumber Number = 19000
+	FirstReservedNumber   Number = 19000
-	LastReservedNumber  Number = 19999
+	LastReservedNumber    Number = 19999
-	MaxValidNumber      Number = 1<<29 - 1
+	MaxValidNumber        Number = 1<<29 - 1
+	DefaultRecursionLimit        = 10000
 )
 // IsValid reports whether the field number is semantically valid.
 //
 // Note that while numbers within the reserved range are semantically invalid,
 	errCodeTruncated
 	errCodeFieldNumber
 	errCodeOverflow
 	errCodeReserved
 	errCodeEndGroup
+	errCodeRecursionDepth
 )
 var (
 	errFieldNumber = errors.New("invalid field number")
 	errOverflow    = errors.New("variable length integer overflow")
 // This returns a negative length upon an error (see ParseError).
 //
 // When parsing a group, the length includes the end group marker and
 // the end group is verified to match the starting field number.
 func ConsumeFieldValue(num Number, typ Type, b []byte) (n int) {
+	return consumeFieldValueD(num, typ, b, DefaultRecursionLimit)
+}
+func consumeFieldValueD(num Number, typ Type, b []byte, depth int) (n int) {
 	switch typ {
 	case VarintType:
 		_, n = ConsumeVarint(b)
 		return n
 	case Fixed32Type:
 		return n
 	case BytesType:
 		_, n = ConsumeBytes(b)
 		return n
 	case StartGroupType:
+		if depth < 0 {
+			return errCodeRecursionDepth
+		}
 		n0 := len(b)
 		for {
 			num2, typ2, n := ConsumeTag(b)
 			if n < 0 {
 				return n // forward error code
 					return errCodeEndGroup
 				}
 				return n0 - len(b)
 			}
-			n = ConsumeFieldValue(num2, typ2, b)
+			n = consumeFieldValueD(num2, typ2, b, depth-1)
 			if n < 0 {
 				return n // forward error code
 			}
 			b = b[n:]
 		}
 func EncodeTag(num Number, typ Type) uint64 {
 	return uint64(num)<<3 | uint64(typ&7)
 }
 // DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.
+//
 //	Input:  {…,  5,  3,  1,  0,  2,  4,  6, …}
 //	Output: {…, -3, -2, -1,  0, +1, +2, +3, …}
 func DecodeZigZag(x uint64) int64 {
 	return int64(x>>1) ^ int64(x)<<63>>63
 }
 // EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.
+//
 //	Input:  {…, -3, -2, -1,  0, +1, +2, +3, …}
 //	Output: {…,  5,  3,  1,  0,  2,  4,  6, …}
 func EncodeZigZag(x int64) uint64 {
 	return uint64(x<<1) ^ uint64(x>>63)
 }
 // DecodeBool decodes a uint64 as a bool.
+//
 //	Input:  {    0,    1,    2, …}
 //	Output: {false, true, true, …}
 func DecodeBool(x uint64) bool {
 	return x != 0
 }
 // EncodeBool encodes a bool as a uint64.
+//
 //	Input:  {false, true}
 //	Output: {    0,    1}
 func EncodeBool(x bool) uint64 {
 	if x {
 		return 1

changeset 260	445e01aede7e
parent 256	6d9efbef00a9