impl.newValidationInfo - Code Metrics - Inspection of "Adding vendor folder" - cdleo/go-sqldb - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Branch — main (436074)

by Christian

created 2022-06-16 19:46 UTC

impl.newValidationInfo F

↳ Parent: vendor/google.golang.org/protobuf/internal/impl/validate.go

Complexity

Conditions

Size

Total Lines	78
Code Lines	63

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	30
eloc	63
nop	2
dl	0
loc	78
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package impl

import (
	"fmt"
	"math"
	"math/bits"
	"reflect"
	"unicode/utf8"

	"google.golang.org/protobuf/encoding/protowire"
	"google.golang.org/protobuf/internal/encoding/messageset"
	"google.golang.org/protobuf/internal/flags"
	"google.golang.org/protobuf/internal/genid"
	"google.golang.org/protobuf/internal/strs"
	pref "google.golang.org/protobuf/reflect/protoreflect"
	preg "google.golang.org/protobuf/reflect/protoregistry"
	piface "google.golang.org/protobuf/runtime/protoiface"
)

// ValidationStatus is the result of validating the wire-format encoding of a message.
type ValidationStatus int

const (
	// ValidationUnknown indicates that unmarshaling the message might succeed or fail.
	// The validator was unable to render a judgement.
	//
	// The only causes of this status are an aberrant message type appearing somewhere
	// in the message or a failure in the extension resolver.
	ValidationUnknown ValidationStatus = iota + 1

	// ValidationInvalid indicates that unmarshaling the message will fail.
	ValidationInvalid

	// ValidationValid indicates that unmarshaling the message will succeed.
	ValidationValid
)

func (v ValidationStatus) String() string {
	switch v {
	case ValidationUnknown:
		return "ValidationUnknown"
	case ValidationInvalid:
		return "ValidationInvalid"
	case ValidationValid:
		return "ValidationValid"
	default:
		return fmt.Sprintf("ValidationStatus(%d)", int(v))
	}
}

// Validate determines whether the contents of the buffer are a valid wire encoding
// of the message type.
//
// This function is exposed for testing.
func Validate(mt pref.MessageType, in piface.UnmarshalInput) (out piface.UnmarshalOutput, _ ValidationStatus) {
	mi, ok := mt.(*MessageInfo)
	if !ok {
		return out, ValidationUnknown
	}
	if in.Resolver == nil {
		in.Resolver = preg.GlobalTypes
	}
	o, st := mi.validate(in.Buf, 0, unmarshalOptions{
		flags:    in.Flags,
		resolver: in.Resolver,
	})
	if o.initialized {
		out.Flags |= piface.UnmarshalInitialized
	}
	return out, st
}

type validationInfo struct {
	mi               *MessageInfo
	typ              validationType
	keyType, valType validationType

	// For non-required fields, requiredBit is 0.
	//
	// For required fields, requiredBit's nth bit is set, where n is a
	// unique index in the range [0, MessageInfo.numRequiredFields).
	//
	// If there are more than 64 required fields, requiredBit is 0.
	requiredBit uint64
}

type validationType uint8

const (
	validationTypeOther validationType = iota
	validationTypeMessage
	validationTypeGroup
	validationTypeMap
	validationTypeRepeatedVarint
	validationTypeRepeatedFixed32
	validationTypeRepeatedFixed64
	validationTypeVarint
	validationTypeFixed32
	validationTypeFixed64
	validationTypeBytes
	validationTypeUTF8String
	validationTypeMessageSetItem
)

func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
	var vi validationInfo
	switch {
	case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
		switch fd.Kind() {
		case pref.MessageKind:
			vi.typ = validationTypeMessage
			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
				vi.mi = getMessageInfo(ot.Field(0).Type)
			}
		case pref.GroupKind:
			vi.typ = validationTypeGroup
			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
				vi.mi = getMessageInfo(ot.Field(0).Type)
			}
		case pref.StringKind:
			if strs.EnforceUTF8(fd) {
				vi.typ = validationTypeUTF8String
			}
		}
	default:
		vi = newValidationInfo(fd, ft)
	}
	if fd.Cardinality() == pref.Required {
		// Avoid overflow. The required field check is done with a 64-bit mask, with
		// any message containing more than 64 required fields always reported as
		// potentially uninitialized, so it is not important to get a precise count
		// of the required fields past 64.
		if mi.numRequiredFields < math.MaxUint8 {
			mi.numRequiredFields++
			vi.requiredBit = 1 << (mi.numRequiredFields - 1)
		}
	}
	return vi
}

func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
	var vi validationInfo
	switch {
	case fd.IsList():
		switch fd.Kind() {
		case pref.MessageKind:
			vi.typ = validationTypeMessage
			if ft.Kind() == reflect.Slice {
				vi.mi = getMessageInfo(ft.Elem())
			}
		case pref.GroupKind:
			vi.typ = validationTypeGroup
			if ft.Kind() == reflect.Slice {
				vi.mi = getMessageInfo(ft.Elem())
			}
		case pref.StringKind:
			vi.typ = validationTypeBytes
			if strs.EnforceUTF8(fd) {
				vi.typ = validationTypeUTF8String
			}
		default:
			switch wireTypes[fd.Kind()] {
			case protowire.VarintType:
				vi.typ = validationTypeRepeatedVarint
			case protowire.Fixed32Type:
				vi.typ = validationTypeRepeatedFixed32
			case protowire.Fixed64Type:
				vi.typ = validationTypeRepeatedFixed64
			}
		}
	case fd.IsMap():
		vi.typ = validationTypeMap
		switch fd.MapKey().Kind() {
		case pref.StringKind:
			if strs.EnforceUTF8(fd) {
				vi.keyType = validationTypeUTF8String
			}
		}
		switch fd.MapValue().Kind() {
		case pref.MessageKind:
			vi.valType = validationTypeMessage
			if ft.Kind() == reflect.Map {
				vi.mi = getMessageInfo(ft.Elem())
			}
		case pref.StringKind:
			if strs.EnforceUTF8(fd) {
				vi.valType = validationTypeUTF8String
			}
		}
	default:
		switch fd.Kind() {
		case pref.MessageKind:
			vi.typ = validationTypeMessage
			if !fd.IsWeak() {
				vi.mi = getMessageInfo(ft)
			}
		case pref.GroupKind:
			vi.typ = validationTypeGroup
			vi.mi = getMessageInfo(ft)
		case pref.StringKind:
			vi.typ = validationTypeBytes
			if strs.EnforceUTF8(fd) {
				vi.typ = validationTypeUTF8String
			}
		default:
			switch wireTypes[fd.Kind()] {
			case protowire.VarintType:
				vi.typ = validationTypeVarint
			case protowire.Fixed32Type:
				vi.typ = validationTypeFixed32
			case protowire.Fixed64Type:
				vi.typ = validationTypeFixed64
			case protowire.BytesType:
				vi.typ = validationTypeBytes
			}
		}
	}
	return vi
}

func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
	mi.init()
	type validationState struct {
		typ              validationType
		keyType, valType validationType
		endGroup         protowire.Number
		mi               *MessageInfo
		tail             []byte
		requiredMask     uint64
	}

	// Pre-allocate some slots to avoid repeated slice reallocation.
	states := make([]validationState, 0, 16)
	states = append(states, validationState{
		typ: validationTypeMessage,
		mi:  mi,
	})
	if groupTag > 0 {
		states[0].typ = validationTypeGroup
		states[0].endGroup = groupTag
	}
	initialized := true
	start := len(b)
State:
	for len(states) > 0 {
		st := &states[len(states)-1]
		for len(b) > 0 {
			// Parse the tag (field number and wire type).
			var tag uint64
			if b[0] < 0x80 {
				tag = uint64(b[0])
				b = b[1:]
			} else if len(b) >= 2 && b[1] < 128 {
				tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
				b = b[2:]
			} else {
				var n int
				tag, n = protowire.ConsumeVarint(b)
				if n < 0 {
					return out, ValidationInvalid
				}
				b = b[n:]
			}
			var num protowire.Number
			if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
				return out, ValidationInvalid
			} else {
				num = protowire.Number(n)
			}
			wtyp := protowire.Type(tag & 7)

			if wtyp == protowire.EndGroupType {
				if st.endGroup == num {
					goto PopState
				}
				return out, ValidationInvalid
			}
			var vi validationInfo
			switch {
			case st.typ == validationTypeMap:
				switch num {
				case genid.MapEntry_Key_field_number:
					vi.typ = st.keyType
				case genid.MapEntry_Value_field_number:
					vi.typ = st.valType
					vi.mi = st.mi
					vi.requiredBit = 1
				}
			case flags.ProtoLegacy && st.mi.isMessageSet:
				switch num {
				case messageset.FieldItem:
					vi.typ = validationTypeMessageSetItem
				}
			default:
				var f *coderFieldInfo
				if int(num) < len(st.mi.denseCoderFields) {
					f = st.mi.denseCoderFields[num]
				} else {
					f = st.mi.coderFields[num]
				}
				if f != nil {
					vi = f.validation
					if vi.typ == validationTypeMessage && vi.mi == nil {
						// Probable weak field.
						//
						// TODO: Consider storing the results of this lookup somewhere
						// rather than recomputing it on every validation.
						fd := st.mi.Desc.Fields().ByNumber(num)
						if fd == nil || !fd.IsWeak() {
							break
						}
						messageName := fd.Message().FullName()
						messageType, err := preg.GlobalTypes.FindMessageByName(messageName)
						switch err {
						case nil:
							vi.mi, _ = messageType.(*MessageInfo)
						case preg.NotFound:
							vi.typ = validationTypeBytes
						default:
							return out, ValidationUnknown
						}
					}
					break
				}
				// Possible extension field.
				//
				// TODO: We should return ValidationUnknown when:
				//   1. The resolver is not frozen. (More extensions may be added to it.)
				//   2. The resolver returns preg.NotFound.
				// In this case, a type added to the resolver in the future could cause
				// unmarshaling to begin failing. Supporting this requires some way to
				// determine if the resolver is frozen.
				xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
				if err != nil && err != preg.NotFound {
					return out, ValidationUnknown
				}
				if err == nil {
					vi = getExtensionFieldInfo(xt).validation
				}
			}
			if vi.requiredBit != 0 {
				// Check that the field has a compatible wire type.
				// We only need to consider non-repeated field types,
				// since repeated fields (and maps) can never be required.
				ok := false
				switch vi.typ {
				case validationTypeVarint:
					ok = wtyp == protowire.VarintType
				case validationTypeFixed32:
					ok = wtyp == protowire.Fixed32Type
				case validationTypeFixed64:
					ok = wtyp == protowire.Fixed64Type
				case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
					ok = wtyp == protowire.BytesType
				case validationTypeGroup:
					ok = wtyp == protowire.StartGroupType
				}
				if ok {
					st.requiredMask |= vi.requiredBit
				}
			}

			switch wtyp {
			case protowire.VarintType:
				if len(b) >= 10 {
					switch {
					case b[0] < 0x80:
						b = b[1:]
					case b[1] < 0x80:
						b = b[2:]
					case b[2] < 0x80:
						b = b[3:]
					case b[3] < 0x80:
						b = b[4:]
					case b[4] < 0x80:
						b = b[5:]
					case b[5] < 0x80:
						b = b[6:]
					case b[6] < 0x80:
						b = b[7:]
					case b[7] < 0x80:
						b = b[8:]
					case b[8] < 0x80:
						b = b[9:]
					case b[9] < 0x80 && b[9] < 2:
						b = b[10:]
					default:
						return out, ValidationInvalid
					}
				} else {
					switch {
					case len(b) > 0 && b[0] < 0x80:
						b = b[1:]
					case len(b) > 1 && b[1] < 0x80:
						b = b[2:]
					case len(b) > 2 && b[2] < 0x80:
						b = b[3:]
					case len(b) > 3 && b[3] < 0x80:
						b = b[4:]
					case len(b) > 4 && b[4] < 0x80:
						b = b[5:]
					case len(b) > 5 && b[5] < 0x80:
						b = b[6:]
					case len(b) > 6 && b[6] < 0x80:
						b = b[7:]
					case len(b) > 7 && b[7] < 0x80:
						b = b[8:]
					case len(b) > 8 && b[8] < 0x80:
						b = b[9:]
					case len(b) > 9 && b[9] < 2:
						b = b[10:]
					default:
						return out, ValidationInvalid
					}
				}
				continue State
			case protowire.BytesType:
				var size uint64
				if len(b) >= 1 && b[0] < 0x80 {
					size = uint64(b[0])
					b = b[1:]
				} else if len(b) >= 2 && b[1] < 128 {
					size = uint64(b[0]&0x7f) + uint64(b[1])<<7
					b = b[2:]
				} else {
					var n int
					size, n = protowire.ConsumeVarint(b)
					if n < 0 {
						return out, ValidationInvalid
					}
					b = b[n:]
				}
				if size > uint64(len(b)) {
					return out, ValidationInvalid
				}
				v := b[:size]
				b = b[size:]
				switch vi.typ {
				case validationTypeMessage:
					if vi.mi == nil {
						return out, ValidationUnknown
					}
					vi.mi.init()
					fallthrough
				case validationTypeMap:
					if vi.mi != nil {
						vi.mi.init()
					}
					states = append(states, validationState{
						typ:     vi.typ,
						keyType: vi.keyType,
						valType: vi.valType,
						mi:      vi.mi,
						tail:    b,
					})
					b = v
					continue State
				case validationTypeRepeatedVarint:
					// Packed field.
					for len(v) > 0 {
						_, n := protowire.ConsumeVarint(v)
						if n < 0 {
							return out, ValidationInvalid
						}
						v = v[n:]
					}
				case validationTypeRepeatedFixed32:
					// Packed field.
					if len(v)%4 != 0 {
						return out, ValidationInvalid
					}
				case validationTypeRepeatedFixed64:
					// Packed field.
					if len(v)%8 != 0 {
						return out, ValidationInvalid
					}
				case validationTypeUTF8String:
					if !utf8.Valid(v) {
						return out, ValidationInvalid
					}
				}
			case protowire.Fixed32Type:
				if len(b) < 4 {
					return out, ValidationInvalid
				}
				b = b[4:]
			case protowire.Fixed64Type:
				if len(b) < 8 {
					return out, ValidationInvalid
				}
				b = b[8:]
			case protowire.StartGroupType:
				switch {
				case vi.typ == validationTypeGroup:
					if vi.mi == nil {
						return out, ValidationUnknown
					}
					vi.mi.init()
					states = append(states, validationState{
						typ:      validationTypeGroup,
						mi:       vi.mi,
						endGroup: num,
					})
					continue State
				case flags.ProtoLegacy && vi.typ == validationTypeMessageSetItem:
					typeid, v, n, err := messageset.ConsumeFieldValue(b, false)
					if err != nil {
						return out, ValidationInvalid
					}
					xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
					switch {
					case err == preg.NotFound:
						b = b[n:]
					case err != nil:
						return out, ValidationUnknown
					default:
						xvi := getExtensionFieldInfo(xt).validation
						if xvi.mi != nil {
							xvi.mi.init()
						}
						states = append(states, validationState{
							typ:  xvi.typ,
							mi:   xvi.mi,
							tail: b[n:],
						})
						b = v
						continue State
					}
				default:
					n := protowire.ConsumeFieldValue(num, wtyp, b)
					if n < 0 {
						return out, ValidationInvalid
					}
					b = b[n:]
				}
			default:
				return out, ValidationInvalid
			}
		}
		if st.endGroup != 0 {
			return out, ValidationInvalid
		}
		if len(b) != 0 {
			return out, ValidationInvalid
		}
		b = st.tail
	PopState:
		numRequiredFields := 0
		switch st.typ {
		case validationTypeMessage, validationTypeGroup:
			numRequiredFields = int(st.mi.numRequiredFields)
		case validationTypeMap:
			// If this is a map field with a message value that contains
			// required fields, require that the value be present.
			if st.mi != nil && st.mi.numRequiredFields > 0 {
				numRequiredFields = 1
			}
		}
		// If there are more than 64 required fields, this check will
		// always fail and we will report that the message is potentially
		// uninitialized.
		if numRequiredFields > 0 && bits.OnesCount64(st.requiredMask) != numRequiredFields {
			initialized = false
		}
		states = states[:len(states)-1]
	}
	out.n = start - len(b)
	if initialized {
		out.initialized = true
	}
	return out, ValidationValid
}


1			// Copyright 2019 The Go Authors. All rights reserved.
2			// Use of this source code is governed by a BSD-style
3			// license that can be found in the LICENSE file.
4
5			package impl
6
7			import (
8			"fmt"
9			"math"
10			"math/bits"
11			"reflect"
12			"unicode/utf8"
13
14			"google.golang.org/protobuf/encoding/protowire"
15			"google.golang.org/protobuf/internal/encoding/messageset"
16			"google.golang.org/protobuf/internal/flags"
17			"google.golang.org/protobuf/internal/genid"
18			"google.golang.org/protobuf/internal/strs"
19			pref "google.golang.org/protobuf/reflect/protoreflect"
20			preg "google.golang.org/protobuf/reflect/protoregistry"
21			piface "google.golang.org/protobuf/runtime/protoiface"
22			)
23
24			// ValidationStatus is the result of validating the wire-format encoding of a message.
25			type ValidationStatus int
26
27			const (
28			// ValidationUnknown indicates that unmarshaling the message might succeed or fail.
29			// The validator was unable to render a judgement.
30			//
31			// The only causes of this status are an aberrant message type appearing somewhere
32			// in the message or a failure in the extension resolver.
33			ValidationUnknown ValidationStatus = iota + 1
34
35			// ValidationInvalid indicates that unmarshaling the message will fail.
36			ValidationInvalid
37
38			// ValidationValid indicates that unmarshaling the message will succeed.
39			ValidationValid
40			)
41
42			func (v ValidationStatus) String() string {
43			switch v {
44			case ValidationUnknown:
45			return "ValidationUnknown"
46			case ValidationInvalid:
47			return "ValidationInvalid"
48			case ValidationValid:
49			return "ValidationValid"
50			default:
51			return fmt.Sprintf("ValidationStatus(%d)", int(v))
52			}
53			}
54
55			// Validate determines whether the contents of the buffer are a valid wire encoding
56			// of the message type.
57			//
58			// This function is exposed for testing.
59			func Validate(mt pref.MessageType, in piface.UnmarshalInput) (out piface.UnmarshalOutput, _ ValidationStatus) {
60			mi, ok := mt.(*MessageInfo)
61			if !ok {
62			return out, ValidationUnknown
63			}
64			if in.Resolver == nil {
65			in.Resolver = preg.GlobalTypes
66			}
67			o, st := mi.validate(in.Buf, 0, unmarshalOptions{
68			flags: in.Flags,
69			resolver: in.Resolver,
70			})
71			if o.initialized {
72			out.Flags \|= piface.UnmarshalInitialized
73			}
74			return out, st
75			}
76
77			type validationInfo struct {
78			mi *MessageInfo
79			typ validationType
80			keyType, valType validationType
81
82			// For non-required fields, requiredBit is 0.
83			//
84			// For required fields, requiredBit's nth bit is set, where n is a
85			// unique index in the range [0, MessageInfo.numRequiredFields).
86			//
87			// If there are more than 64 required fields, requiredBit is 0.
88			requiredBit uint64
89			}
90
91			type validationType uint8
92
93			const (
94			validationTypeOther validationType = iota
95			validationTypeMessage
96			validationTypeGroup
97			validationTypeMap
98			validationTypeRepeatedVarint
99			validationTypeRepeatedFixed32
100			validationTypeRepeatedFixed64
101			validationTypeVarint
102			validationTypeFixed32
103			validationTypeFixed64
104			validationTypeBytes
105			validationTypeUTF8String
106			validationTypeMessageSetItem
107			)
108
109			func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
110			var vi validationInfo
111			switch {
112			case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
113			switch fd.Kind() {
114			case pref.MessageKind:
115			vi.typ = validationTypeMessage
116			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
117			vi.mi = getMessageInfo(ot.Field(0).Type)
118			}
119			case pref.GroupKind:
120			vi.typ = validationTypeGroup
121			if ot, ok := si.oneofWrappersByNumber[fd.Number()]; ok {
122			vi.mi = getMessageInfo(ot.Field(0).Type)
123			}
124			case pref.StringKind:
125			if strs.EnforceUTF8(fd) {
126			vi.typ = validationTypeUTF8String
127			}
128			}
129			default:
130			vi = newValidationInfo(fd, ft)
131			}
132			if fd.Cardinality() == pref.Required {
133			// Avoid overflow. The required field check is done with a 64-bit mask, with
134			// any message containing more than 64 required fields always reported as
135			// potentially uninitialized, so it is not important to get a precise count
136			// of the required fields past 64.
137			if mi.numRequiredFields < math.MaxUint8 {
138			mi.numRequiredFields++
139			vi.requiredBit = 1 << (mi.numRequiredFields - 1)
140			}
141			}
142			return vi
143			}
144
145			func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
146			var vi validationInfo
147			switch {
148			case fd.IsList():
149			switch fd.Kind() {
150			case pref.MessageKind:
151			vi.typ = validationTypeMessage
152			if ft.Kind() == reflect.Slice {
153			vi.mi = getMessageInfo(ft.Elem())
154			}
155			case pref.GroupKind:
156			vi.typ = validationTypeGroup
157			if ft.Kind() == reflect.Slice {
158			vi.mi = getMessageInfo(ft.Elem())
159			}
160			case pref.StringKind:
161			vi.typ = validationTypeBytes
162			if strs.EnforceUTF8(fd) {
163			vi.typ = validationTypeUTF8String
164			}
165			default:
166			switch wireTypes[fd.Kind()] {
167			case protowire.VarintType:
168			vi.typ = validationTypeRepeatedVarint
169			case protowire.Fixed32Type:
170			vi.typ = validationTypeRepeatedFixed32
171			case protowire.Fixed64Type:
172			vi.typ = validationTypeRepeatedFixed64
173			}
174			}
175			case fd.IsMap():
176			vi.typ = validationTypeMap
177			switch fd.MapKey().Kind() {
178			case pref.StringKind:
179			if strs.EnforceUTF8(fd) {
180			vi.keyType = validationTypeUTF8String
181			}
182			}
183			switch fd.MapValue().Kind() {
184			case pref.MessageKind:
185			vi.valType = validationTypeMessage
186			if ft.Kind() == reflect.Map {
187			vi.mi = getMessageInfo(ft.Elem())
188			}
189			case pref.StringKind:
190			if strs.EnforceUTF8(fd) {
191			vi.valType = validationTypeUTF8String
192			}
193			}
194			default:
195			switch fd.Kind() {
196			case pref.MessageKind:
197			vi.typ = validationTypeMessage
198			if !fd.IsWeak() {
199			vi.mi = getMessageInfo(ft)
200			}
201			case pref.GroupKind:
202			vi.typ = validationTypeGroup
203			vi.mi = getMessageInfo(ft)
204			case pref.StringKind:
205			vi.typ = validationTypeBytes
206			if strs.EnforceUTF8(fd) {
207			vi.typ = validationTypeUTF8String
208			}
209			default:
210			switch wireTypes[fd.Kind()] {
211			case protowire.VarintType:
212			vi.typ = validationTypeVarint
213			case protowire.Fixed32Type:
214			vi.typ = validationTypeFixed32
215			case protowire.Fixed64Type:
216			vi.typ = validationTypeFixed64
217			case protowire.BytesType:
218			vi.typ = validationTypeBytes
219			}
220			}
221			}
222			return vi
223			}
224
225			func (mi *MessageInfo) validate(b []byte, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, result ValidationStatus) {
226			mi.init()
227			type validationState struct {
228			typ validationType
229			keyType, valType validationType
230			endGroup protowire.Number
231			mi *MessageInfo
232			tail []byte
233			requiredMask uint64
234			}
235
236			// Pre-allocate some slots to avoid repeated slice reallocation.
237			states := make([]validationState, 0, 16)
238			states = append(states, validationState{
239			typ: validationTypeMessage,
240			mi: mi,
241			})
242			if groupTag > 0 {
243			states[0].typ = validationTypeGroup
244			states[0].endGroup = groupTag
245			}
246			initialized := true
247			start := len(b)
248			State:
249			for len(states) > 0 {
250			st := &states[len(states)-1]
251			for len(b) > 0 {
252			// Parse the tag (field number and wire type).
253			var tag uint64
254			if b[0] < 0x80 {
255			tag = uint64(b[0])
256			b = b[1:]
257			} else if len(b) >= 2 && b[1] < 128 {
258			tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
259			b = b[2:]
260			} else {
261			var n int
262			tag, n = protowire.ConsumeVarint(b)
263			if n < 0 {
264			return out, ValidationInvalid
265			}
266			b = b[n:]
267			}
268			var num protowire.Number
269			if n := tag >> 3; n < uint64(protowire.MinValidNumber) \|\| n > uint64(protowire.MaxValidNumber) {
270			return out, ValidationInvalid
271			} else {
272			num = protowire.Number(n)
273			}
274			wtyp := protowire.Type(tag & 7)
275
276			if wtyp == protowire.EndGroupType {
277			if st.endGroup == num {
278			goto PopState
279			}
280			return out, ValidationInvalid
281			}
282			var vi validationInfo
283			switch {
284			case st.typ == validationTypeMap:
285			switch num {
286			case genid.MapEntry_Key_field_number:
287			vi.typ = st.keyType
288			case genid.MapEntry_Value_field_number:
289			vi.typ = st.valType
290			vi.mi = st.mi
291			vi.requiredBit = 1
292			}
293			case flags.ProtoLegacy && st.mi.isMessageSet:
294			switch num {
295			case messageset.FieldItem:
296			vi.typ = validationTypeMessageSetItem
297			}
298			default:
299			var f *coderFieldInfo
300			if int(num) < len(st.mi.denseCoderFields) {
301			f = st.mi.denseCoderFields[num]
302			} else {
303			f = st.mi.coderFields[num]
304			}
305			if f != nil {
306			vi = f.validation
307			if vi.typ == validationTypeMessage && vi.mi == nil {
308			// Probable weak field.
309			//
310			// TODO: Consider storing the results of this lookup somewhere
311			// rather than recomputing it on every validation.
312			fd := st.mi.Desc.Fields().ByNumber(num)
313			if fd == nil \|\| !fd.IsWeak() {
314			break
315			}
316			messageName := fd.Message().FullName()
317			messageType, err := preg.GlobalTypes.FindMessageByName(messageName)
318			switch err {
319			case nil:
320			vi.mi, _ = messageType.(*MessageInfo)
321			case preg.NotFound:
322			vi.typ = validationTypeBytes
323			default:
324			return out, ValidationUnknown
325			}
326			}
327			break
328			}
329			// Possible extension field.
330			//
331			// TODO: We should return ValidationUnknown when:
332			// 1. The resolver is not frozen. (More extensions may be added to it.)
333			// 2. The resolver returns preg.NotFound.
334			// In this case, a type added to the resolver in the future could cause
335			// unmarshaling to begin failing. Supporting this requires some way to
336			// determine if the resolver is frozen.
337			xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), num)
338			if err != nil && err != preg.NotFound {
339			return out, ValidationUnknown
340			}
341			if err == nil {
342			vi = getExtensionFieldInfo(xt).validation
343			}
344			}
345			if vi.requiredBit != 0 {
346			// Check that the field has a compatible wire type.
347			// We only need to consider non-repeated field types,
348			// since repeated fields (and maps) can never be required.
349			ok := false
350			switch vi.typ {
351			case validationTypeVarint:
352			ok = wtyp == protowire.VarintType
353			case validationTypeFixed32:
354			ok = wtyp == protowire.Fixed32Type
355			case validationTypeFixed64:
356			ok = wtyp == protowire.Fixed64Type
357			case validationTypeBytes, validationTypeUTF8String, validationTypeMessage:
358			ok = wtyp == protowire.BytesType
359			case validationTypeGroup:
360			ok = wtyp == protowire.StartGroupType
361			}
362			if ok {
363			st.requiredMask \|= vi.requiredBit
364			}
365			}
366
367			switch wtyp {
368			case protowire.VarintType:
369			if len(b) >= 10 {
370			switch {
371			case b[0] < 0x80:
372			b = b[1:]
373			case b[1] < 0x80:
374			b = b[2:]
375			case b[2] < 0x80:
376			b = b[3:]
377			case b[3] < 0x80:
378			b = b[4:]
379			case b[4] < 0x80:
380			b = b[5:]
381			case b[5] < 0x80:
382			b = b[6:]
383			case b[6] < 0x80:
384			b = b[7:]
385			case b[7] < 0x80:
386			b = b[8:]
387			case b[8] < 0x80:
388			b = b[9:]
389			case b[9] < 0x80 && b[9] < 2:
390			b = b[10:]
391			default:
392			return out, ValidationInvalid
393			}
394			} else {
395			switch {
396			case len(b) > 0 && b[0] < 0x80:
397			b = b[1:]
398			case len(b) > 1 && b[1] < 0x80:
399			b = b[2:]
400			case len(b) > 2 && b[2] < 0x80:
401			b = b[3:]
402			case len(b) > 3 && b[3] < 0x80:
403			b = b[4:]
404			case len(b) > 4 && b[4] < 0x80:
405			b = b[5:]
406			case len(b) > 5 && b[5] < 0x80:
407			b = b[6:]
408			case len(b) > 6 && b[6] < 0x80:
409			b = b[7:]
410			case len(b) > 7 && b[7] < 0x80:
411			b = b[8:]
412			case len(b) > 8 && b[8] < 0x80:
413			b = b[9:]
414			case len(b) > 9 && b[9] < 2:
415			b = b[10:]
416			default:
417			return out, ValidationInvalid
418			}
419			}
420			continue State
421			case protowire.BytesType:
422			var size uint64
423			if len(b) >= 1 && b[0] < 0x80 {
424			size = uint64(b[0])
425			b = b[1:]
426			} else if len(b) >= 2 && b[1] < 128 {
427			size = uint64(b[0]&0x7f) + uint64(b[1])<<7
428			b = b[2:]
429			} else {
430			var n int
431			size, n = protowire.ConsumeVarint(b)
432			if n < 0 {
433			return out, ValidationInvalid
434			}
435			b = b[n:]
436			}
437			if size > uint64(len(b)) {
438			return out, ValidationInvalid
439			}
440			v := b[:size]
441			b = b[size:]
442			switch vi.typ {
443			case validationTypeMessage:
444			if vi.mi == nil {
445			return out, ValidationUnknown
446			}
447			vi.mi.init()
448			fallthrough
449			case validationTypeMap:
450			if vi.mi != nil {
451			vi.mi.init()
452			}
453			states = append(states, validationState{
454			typ: vi.typ,
455			keyType: vi.keyType,
456			valType: vi.valType,
457			mi: vi.mi,
458			tail: b,
459			})
460			b = v
461			continue State
462			case validationTypeRepeatedVarint:
463			// Packed field.
464			for len(v) > 0 {
465			_, n := protowire.ConsumeVarint(v)
466			if n < 0 {
467			return out, ValidationInvalid
468			}
469			v = v[n:]
470			}
471			case validationTypeRepeatedFixed32:
472			// Packed field.
473			if len(v)%4 != 0 {
474			return out, ValidationInvalid
475			}
476			case validationTypeRepeatedFixed64:
477			// Packed field.
478			if len(v)%8 != 0 {
479			return out, ValidationInvalid
480			}
481			case validationTypeUTF8String:
482			if !utf8.Valid(v) {
483			return out, ValidationInvalid
484			}
485			}
486			case protowire.Fixed32Type:
487			if len(b) < 4 {
488			return out, ValidationInvalid
489			}
490			b = b[4:]
491			case protowire.Fixed64Type:
492			if len(b) < 8 {
493			return out, ValidationInvalid
494			}
495			b = b[8:]
496			case protowire.StartGroupType:
497			switch {
498			case vi.typ == validationTypeGroup:
499			if vi.mi == nil {
500			return out, ValidationUnknown
501			}
502			vi.mi.init()
503			states = append(states, validationState{
504			typ: validationTypeGroup,
505			mi: vi.mi,
506			endGroup: num,
507			})
508			continue State
509			case flags.ProtoLegacy && vi.typ == validationTypeMessageSetItem:
510			typeid, v, n, err := messageset.ConsumeFieldValue(b, false)
511			if err != nil {
512			return out, ValidationInvalid
513			}
514			xt, err := opts.resolver.FindExtensionByNumber(st.mi.Desc.FullName(), typeid)
515			switch {
516			case err == preg.NotFound:
517			b = b[n:]
518			case err != nil:
519			return out, ValidationUnknown
520			default:
521			xvi := getExtensionFieldInfo(xt).validation
522			if xvi.mi != nil {
523			xvi.mi.init()
524			}
525			states = append(states, validationState{
526			typ: xvi.typ,
527			mi: xvi.mi,
528			tail: b[n:],
529			})
530			b = v
531			continue State
532			}
533			default:
534			n := protowire.ConsumeFieldValue(num, wtyp, b)
535			if n < 0 {
536			return out, ValidationInvalid
537			}
538			b = b[n:]
539			}
540			default:
541			return out, ValidationInvalid
542			}
543			}
544			if st.endGroup != 0 {
545			return out, ValidationInvalid
546			}
547			if len(b) != 0 {
548			return out, ValidationInvalid
549			}
550			b = st.tail
551			PopState:
552			numRequiredFields := 0
553			switch st.typ {
554			case validationTypeMessage, validationTypeGroup:
555			numRequiredFields = int(st.mi.numRequiredFields)
556			case validationTypeMap:
557			// If this is a map field with a message value that contains
558			// required fields, require that the value be present.
559			if st.mi != nil && st.mi.numRequiredFields > 0 {
560			numRequiredFields = 1
561			}
562			}
563			// If there are more than 64 required fields, this check will
564			// always fail and we will report that the message is potentially
565			// uninitialized.
566			if numRequiredFields > 0 && bits.OnesCount64(st.requiredMask) != numRequiredFields {
567			initialized = false
568			}
569			states = states[:len(states)-1]
570			}
571			out.n = start - len(b)
572			if initialized {
573			out.initialized = true
574			}
575			return out, ValidationValid
576			}
577

cdleo / go-sqldb

Branch — main (436074)

impl.newValidationInfo F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like