podman

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
	"reflect"
10
	"sort"
11

12
	"google.golang.org/protobuf/encoding/protowire"
13
	"google.golang.org/protobuf/internal/encoding/messageset"
14
	"google.golang.org/protobuf/internal/order"
15
	"google.golang.org/protobuf/reflect/protoreflect"
16
	"google.golang.org/protobuf/runtime/protoiface"
17
)
18

19
// coderMessageInfo contains per-message information used by the fast-path functions.
20
// This is a different type from MessageInfo to keep MessageInfo as general-purpose as
21
// possible.
22
type coderMessageInfo struct {
23
	methods protoiface.Methods
24

25
	orderedCoderFields []*coderFieldInfo
26
	denseCoderFields   []*coderFieldInfo
27
	coderFields        map[protowire.Number]*coderFieldInfo
28
	sizecacheOffset    offset
29
	unknownOffset      offset
30
	unknownPtrKind     bool
31
	extensionOffset    offset
32
	needsInitCheck     bool
33
	isMessageSet       bool
34
	numRequiredFields  uint8
35
}
36

37
type coderFieldInfo struct {
38
	funcs      pointerCoderFuncs // fast-path per-field functions
39
	mi         *MessageInfo      // field's message
40
	ft         reflect.Type
41
	validation validationInfo           // information used by message validation
42
	num        protoreflect.FieldNumber // field number
43
	offset     offset                   // struct field offset
44
	wiretag    uint64                   // field tag (number + wire type)
45
	tagsize    int                      // size of the varint-encoded tag
46
	isPointer  bool                     // true if IsNil may be called on the struct field
47
	isRequired bool                     // true if field is required
48
}
49

50
func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
51
	mi.sizecacheOffset = invalidOffset
52
	mi.unknownOffset = invalidOffset
53
	mi.extensionOffset = invalidOffset
54

55
	if si.sizecacheOffset.IsValid() && si.sizecacheType == sizecacheType {
56
		mi.sizecacheOffset = si.sizecacheOffset
57
	}
58
	if si.unknownOffset.IsValid() && (si.unknownType == unknownFieldsAType || si.unknownType == unknownFieldsBType) {
59
		mi.unknownOffset = si.unknownOffset
60
		mi.unknownPtrKind = si.unknownType.Kind() == reflect.Ptr
61
	}
62
	if si.extensionOffset.IsValid() && si.extensionType == extensionFieldsType {
63
		mi.extensionOffset = si.extensionOffset
64
	}
65

66
	mi.coderFields = make(map[protowire.Number]*coderFieldInfo)
67
	fields := mi.Desc.Fields()
68
	preallocFields := make([]coderFieldInfo, fields.Len())
69
	for i := 0; i < fields.Len(); i++ {
70
		fd := fields.Get(i)
71

72
		fs := si.fieldsByNumber[fd.Number()]
73
		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()
74
		if isOneof {
75
			fs = si.oneofsByName[fd.ContainingOneof().Name()]
76
		}
77
		ft := fs.Type
78
		var wiretag uint64
79
		if !fd.IsPacked() {
80
			wiretag = protowire.EncodeTag(fd.Number(), wireTypes[fd.Kind()])
81
		} else {
82
			wiretag = protowire.EncodeTag(fd.Number(), protowire.BytesType)
83
		}
84
		var fieldOffset offset
85
		var funcs pointerCoderFuncs
86
		var childMessage *MessageInfo
87
		switch {
88
		case ft == nil:
89
			// This never occurs for generated message types.
90
			// It implies that a hand-crafted type has missing Go fields
91
			// for specific protobuf message fields.
92
			funcs = pointerCoderFuncs{
93
				size: func(p pointer, f *coderFieldInfo, opts marshalOptions) int {
94
					return 0
95
				},
96
				marshal: func(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
97
					return nil, nil
98
				},
99
				unmarshal: func(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (unmarshalOutput, error) {
100
					panic("missing Go struct field for " + string(fd.FullName()))
101
				},
102
				isInit: func(p pointer, f *coderFieldInfo) error {
103
					panic("missing Go struct field for " + string(fd.FullName()))
104
				},
105
				merge: func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) {
106
					panic("missing Go struct field for " + string(fd.FullName()))
107
				},
108
			}
109
		case isOneof:
110
			fieldOffset = offsetOf(fs, mi.Exporter)
111
		case fd.IsWeak():
112
			fieldOffset = si.weakOffset
113
			funcs = makeWeakMessageFieldCoder(fd)
114
		default:
115
			fieldOffset = offsetOf(fs, mi.Exporter)
116
			childMessage, funcs = fieldCoder(fd, ft)
117
		}
118
		cf := &preallocFields[i]
119
		*cf = coderFieldInfo{
120
			num:        fd.Number(),
121
			offset:     fieldOffset,
122
			wiretag:    wiretag,
123
			ft:         ft,
124
			tagsize:    protowire.SizeVarint(wiretag),
125
			funcs:      funcs,
126
			mi:         childMessage,
127
			validation: newFieldValidationInfo(mi, si, fd, ft),
128
			isPointer:  fd.Cardinality() == protoreflect.Repeated || fd.HasPresence(),
129
			isRequired: fd.Cardinality() == protoreflect.Required,
130
		}
131
		mi.orderedCoderFields = append(mi.orderedCoderFields, cf)
132
		mi.coderFields[cf.num] = cf
133
	}
134
	for i, oneofs := 0, mi.Desc.Oneofs(); i < oneofs.Len(); i++ {
135
		if od := oneofs.Get(i); !od.IsSynthetic() {
136
			mi.initOneofFieldCoders(od, si)
137
		}
138
	}
139
	if messageset.IsMessageSet(mi.Desc) {
140
		if !mi.extensionOffset.IsValid() {
141
			panic(fmt.Sprintf("%v: MessageSet with no extensions field", mi.Desc.FullName()))
142
		}
143
		if !mi.unknownOffset.IsValid() {
144
			panic(fmt.Sprintf("%v: MessageSet with no unknown field", mi.Desc.FullName()))
145
		}
146
		mi.isMessageSet = true
147
	}
148
	sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
149
		return mi.orderedCoderFields[i].num < mi.orderedCoderFields[j].num
150
	})
151

152
	var maxDense protoreflect.FieldNumber
153
	for _, cf := range mi.orderedCoderFields {
154
		if cf.num >= 16 && cf.num >= 2*maxDense {
155
			break
156
		}
157
		maxDense = cf.num
158
	}
159
	mi.denseCoderFields = make([]*coderFieldInfo, maxDense+1)
160
	for _, cf := range mi.orderedCoderFields {
161
		if int(cf.num) >= len(mi.denseCoderFields) {
162
			break
163
		}
164
		mi.denseCoderFields[cf.num] = cf
165
	}
166

167
	// To preserve compatibility with historic wire output, marshal oneofs last.
168
	if mi.Desc.Oneofs().Len() > 0 {
169
		sort.Slice(mi.orderedCoderFields, func(i, j int) bool {
170
			fi := fields.ByNumber(mi.orderedCoderFields[i].num)
171
			fj := fields.ByNumber(mi.orderedCoderFields[j].num)
172
			return order.LegacyFieldOrder(fi, fj)
173
		})
174
	}
175

176
	mi.needsInitCheck = needsInitCheck(mi.Desc)
177
	if mi.methods.Marshal == nil && mi.methods.Size == nil {
178
		mi.methods.Flags |= protoiface.SupportMarshalDeterministic
179
		mi.methods.Marshal = mi.marshal
180
		mi.methods.Size = mi.size
181
	}
182
	if mi.methods.Unmarshal == nil {
183
		mi.methods.Flags |= protoiface.SupportUnmarshalDiscardUnknown
184
		mi.methods.Unmarshal = mi.unmarshal
185
	}
186
	if mi.methods.CheckInitialized == nil {
187
		mi.methods.CheckInitialized = mi.checkInitialized
188
	}
189
	if mi.methods.Merge == nil {
190
		mi.methods.Merge = mi.merge
191
	}
192
}
193

194
// getUnknownBytes returns a *[]byte for the unknown fields.
195
// It is the caller's responsibility to check whether the pointer is nil.
196
// This function is specially designed to be inlineable.
197
func (mi *MessageInfo) getUnknownBytes(p pointer) *[]byte {
198
	if mi.unknownPtrKind {
199
		return *p.Apply(mi.unknownOffset).BytesPtr()
200
	} else {
201
		return p.Apply(mi.unknownOffset).Bytes()
202
	}
203
}
204

205
// mutableUnknownBytes returns a *[]byte for the unknown fields.
206
// The returned pointer is guaranteed to not be nil.
207
func (mi *MessageInfo) mutableUnknownBytes(p pointer) *[]byte {
208
	if mi.unknownPtrKind {
209
		bp := p.Apply(mi.unknownOffset).BytesPtr()
210
		if *bp == nil {
211
			*bp = new([]byte)
212
		}
213
		return *bp
214
	} else {
215
		return p.Apply(mi.unknownOffset).Bytes()
216
	}
217
}
218