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
	"math/bits"
9

10
	"google.golang.org/protobuf/encoding/protowire"
11
	"google.golang.org/protobuf/internal/errors"
12
	"google.golang.org/protobuf/internal/flags"
13
	"google.golang.org/protobuf/proto"
14
	"google.golang.org/protobuf/reflect/protoreflect"
15
	"google.golang.org/protobuf/reflect/protoregistry"
16
	"google.golang.org/protobuf/runtime/protoiface"
17
)
18

19
var errDecode = errors.New("cannot parse invalid wire-format data")
20
var errRecursionDepth = errors.New("exceeded maximum recursion depth")
21

22
type unmarshalOptions struct {
23
	flags    protoiface.UnmarshalInputFlags
24
	resolver interface {
25
		FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
26
		FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
27
	}
28
	depth int
29
}
30

31
func (o unmarshalOptions) Options() proto.UnmarshalOptions {
32
	return proto.UnmarshalOptions{
33
		Merge:          true,
34
		AllowPartial:   true,
35
		DiscardUnknown: o.DiscardUnknown(),
36
		Resolver:       o.resolver,
37
	}
38
}
39

40
func (o unmarshalOptions) DiscardUnknown() bool {
41
	return o.flags&protoiface.UnmarshalDiscardUnknown != 0
42
}
43

44
func (o unmarshalOptions) IsDefault() bool {
45
	return o.flags == 0 && o.resolver == protoregistry.GlobalTypes
46
}
47

48
var lazyUnmarshalOptions = unmarshalOptions{
49
	resolver: protoregistry.GlobalTypes,
50
	depth:    protowire.DefaultRecursionLimit,
51
}
52

53
type unmarshalOutput struct {
54
	n           int // number of bytes consumed
55
	initialized bool
56
}
57

58
// unmarshal is protoreflect.Methods.Unmarshal.
59
func (mi *MessageInfo) unmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
60
	var p pointer
61
	if ms, ok := in.Message.(*messageState); ok {
62
		p = ms.pointer()
63
	} else {
64
		p = in.Message.(*messageReflectWrapper).pointer()
65
	}
66
	out, err := mi.unmarshalPointer(in.Buf, p, 0, unmarshalOptions{
67
		flags:    in.Flags,
68
		resolver: in.Resolver,
69
		depth:    in.Depth,
70
	})
71
	var flags protoiface.UnmarshalOutputFlags
72
	if out.initialized {
73
		flags |= protoiface.UnmarshalInitialized
74
	}
75
	return protoiface.UnmarshalOutput{
76
		Flags: flags,
77
	}, err
78
}
79

80
// errUnknown is returned during unmarshaling to indicate a parse error that
81
// should result in a field being placed in the unknown fields section (for example,
82
// when the wire type doesn't match) as opposed to the entire unmarshal operation
83
// failing (for example, when a field extends past the available input).
84
//
85
// This is a sentinel error which should never be visible to the user.
86
var errUnknown = errors.New("unknown")
87

88
func (mi *MessageInfo) unmarshalPointer(b []byte, p pointer, groupTag protowire.Number, opts unmarshalOptions) (out unmarshalOutput, err error) {
89
	mi.init()
90
	opts.depth--
91
	if opts.depth < 0 {
92
		return out, errRecursionDepth
93
	}
94
	if flags.ProtoLegacy && mi.isMessageSet {
95
		return unmarshalMessageSet(mi, b, p, opts)
96
	}
97
	initialized := true
98
	var requiredMask uint64
99
	var exts *map[int32]ExtensionField
100
	start := len(b)
101
	for len(b) > 0 {
102
		// Parse the tag (field number and wire type).
103
		var tag uint64
104
		if b[0] < 0x80 {
105
			tag = uint64(b[0])
106
			b = b[1:]
107
		} else if len(b) >= 2 && b[1] < 128 {
108
			tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
109
			b = b[2:]
110
		} else {
111
			var n int
112
			tag, n = protowire.ConsumeVarint(b)
113
			if n < 0 {
114
				return out, errDecode
115
			}
116
			b = b[n:]
117
		}
118
		var num protowire.Number
119
		if n := tag >> 3; n < uint64(protowire.MinValidNumber) || n > uint64(protowire.MaxValidNumber) {
120
			return out, errDecode
121
		} else {
122
			num = protowire.Number(n)
123
		}
124
		wtyp := protowire.Type(tag & 7)
125

126
		if wtyp == protowire.EndGroupType {
127
			if num != groupTag {
128
				return out, errDecode
129
			}
130
			groupTag = 0
131
			break
132
		}
133

134
		var f *coderFieldInfo
135
		if int(num) < len(mi.denseCoderFields) {
136
			f = mi.denseCoderFields[num]
137
		} else {
138
			f = mi.coderFields[num]
139
		}
140
		var n int
141
		err := errUnknown
142
		switch {
143
		case f != nil:
144
			if f.funcs.unmarshal == nil {
145
				break
146
			}
147
			var o unmarshalOutput
148
			o, err = f.funcs.unmarshal(b, p.Apply(f.offset), wtyp, f, opts)
149
			n = o.n
150
			if err != nil {
151
				break
152
			}
153
			requiredMask |= f.validation.requiredBit
154
			if f.funcs.isInit != nil && !o.initialized {
155
				initialized = false
156
			}
157
		default:
158
			// Possible extension.
159
			if exts == nil && mi.extensionOffset.IsValid() {
160
				exts = p.Apply(mi.extensionOffset).Extensions()
161
				if *exts == nil {
162
					*exts = make(map[int32]ExtensionField)
163
				}
164
			}
165
			if exts == nil {
166
				break
167
			}
168
			var o unmarshalOutput
169
			o, err = mi.unmarshalExtension(b, num, wtyp, *exts, opts)
170
			if err != nil {
171
				break
172
			}
173
			n = o.n
174
			if !o.initialized {
175
				initialized = false
176
			}
177
		}
178
		if err != nil {
179
			if err != errUnknown {
180
				return out, err
181
			}
182
			n = protowire.ConsumeFieldValue(num, wtyp, b)
183
			if n < 0 {
184
				return out, errDecode
185
			}
186
			if !opts.DiscardUnknown() && mi.unknownOffset.IsValid() {
187
				u := mi.mutableUnknownBytes(p)
188
				*u = protowire.AppendTag(*u, num, wtyp)
189
				*u = append(*u, b[:n]...)
190
			}
191
		}
192
		b = b[n:]
193
	}
194
	if groupTag != 0 {
195
		return out, errDecode
196
	}
197
	if mi.numRequiredFields > 0 && bits.OnesCount64(requiredMask) != int(mi.numRequiredFields) {
198
		initialized = false
199
	}
200
	if initialized {
201
		out.initialized = true
202
	}
203
	out.n = start - len(b)
204
	return out, nil
205
}
206

207
func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp protowire.Type, exts map[int32]ExtensionField, opts unmarshalOptions) (out unmarshalOutput, err error) {
208
	x := exts[int32(num)]
209
	xt := x.Type()
210
	if xt == nil {
211
		var err error
212
		xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
213
		if err != nil {
214
			if err == protoregistry.NotFound {
215
				return out, errUnknown
216
			}
217
			return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)
218
		}
219
	}
220
	xi := getExtensionFieldInfo(xt)
221
	if xi.funcs.unmarshal == nil {
222
		return out, errUnknown
223
	}
224
	if flags.LazyUnmarshalExtensions {
225
		if opts.IsDefault() && x.canLazy(xt) {
226
			out, valid := skipExtension(b, xi, num, wtyp, opts)
227
			switch valid {
228
			case ValidationValid:
229
				if out.initialized {
230
					x.appendLazyBytes(xt, xi, num, wtyp, b[:out.n])
231
					exts[int32(num)] = x
232
					return out, nil
233
				}
234
			case ValidationInvalid:
235
				return out, errDecode
236
			case ValidationUnknown:
237
			}
238
		}
239
	}
240
	ival := x.Value()
241
	if !ival.IsValid() && xi.unmarshalNeedsValue {
242
		// Create a new message, list, or map value to fill in.
243
		// For enums, create a prototype value to let the unmarshal func know the
244
		// concrete type.
245
		ival = xt.New()
246
	}
247
	v, out, err := xi.funcs.unmarshal(b, ival, num, wtyp, opts)
248
	if err != nil {
249
		return out, err
250
	}
251
	if xi.funcs.isInit == nil {
252
		out.initialized = true
253
	}
254
	x.Set(xt, v)
255
	exts[int32(num)] = x
256
	return out, nil
257
}
258

259
func skipExtension(b []byte, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, _ ValidationStatus) {
260
	if xi.validation.mi == nil {
261
		return out, ValidationUnknown
262
	}
263
	xi.validation.mi.init()
264
	switch xi.validation.typ {
265
	case validationTypeMessage:
266
		if wtyp != protowire.BytesType {
267
			return out, ValidationUnknown
268
		}
269
		v, n := protowire.ConsumeBytes(b)
270
		if n < 0 {
271
			return out, ValidationUnknown
272
		}
273
		out, st := xi.validation.mi.validate(v, 0, opts)
274
		out.n = n
275
		return out, st
276
	case validationTypeGroup:
277
		if wtyp != protowire.StartGroupType {
278
			return out, ValidationUnknown
279
		}
280
		out, st := xi.validation.mi.validate(b, num, opts)
281
		return out, st
282
	default:
283
		return out, ValidationUnknown
284
	}
285
}
286