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
	"sync"
9
	"sync/atomic"
10

11
	"google.golang.org/protobuf/encoding/protowire"
12
	"google.golang.org/protobuf/internal/errors"
13
	"google.golang.org/protobuf/reflect/protoreflect"
14
)
15

16
type extensionFieldInfo struct {
17
	wiretag             uint64
18
	tagsize             int
19
	unmarshalNeedsValue bool
20
	funcs               valueCoderFuncs
21
	validation          validationInfo
22
}
23

24
func getExtensionFieldInfo(xt protoreflect.ExtensionType) *extensionFieldInfo {
25
	if xi, ok := xt.(*ExtensionInfo); ok {
26
		xi.lazyInit()
27
		return xi.info
28
	}
29
	// Ideally we'd cache the resulting *extensionFieldInfo so we don't have to
30
	// recompute this metadata repeatedly. But without support for something like
31
	// weak references, such a cache would pin temporary values (like dynamic
32
	// extension types, constructed for the duration of a user request) to the
33
	// heap forever, causing memory usage of the cache to grow unbounded.
34
	// See discussion in https://github.com/golang/protobuf/issues/1521.
35
	return makeExtensionFieldInfo(xt.TypeDescriptor())
36
}
37

38
func makeExtensionFieldInfo(xd protoreflect.ExtensionDescriptor) *extensionFieldInfo {
39
	var wiretag uint64
40
	if !xd.IsPacked() {
41
		wiretag = protowire.EncodeTag(xd.Number(), wireTypes[xd.Kind()])
42
	} else {
43
		wiretag = protowire.EncodeTag(xd.Number(), protowire.BytesType)
44
	}
45
	e := &extensionFieldInfo{
46
		wiretag: wiretag,
47
		tagsize: protowire.SizeVarint(wiretag),
48
		funcs:   encoderFuncsForValue(xd),
49
	}
50
	// Does the unmarshal function need a value passed to it?
51
	// This is true for composite types, where we pass in a message, list, or map to fill in,
52
	// and for enums, where we pass in a prototype value to specify the concrete enum type.
53
	switch xd.Kind() {
54
	case protoreflect.MessageKind, protoreflect.GroupKind, protoreflect.EnumKind:
55
		e.unmarshalNeedsValue = true
56
	default:
57
		if xd.Cardinality() == protoreflect.Repeated {
58
			e.unmarshalNeedsValue = true
59
		}
60
	}
61
	return e
62
}
63

64
type lazyExtensionValue struct {
65
	atomicOnce uint32 // atomically set if value is valid
66
	mu         sync.Mutex
67
	xi         *extensionFieldInfo
68
	value      protoreflect.Value
69
	b          []byte
70
	fn         func() protoreflect.Value
71
}
72

73
type ExtensionField struct {
74
	typ protoreflect.ExtensionType
75

76
	// value is either the value of GetValue,
77
	// or a *lazyExtensionValue that then returns the value of GetValue.
78
	value protoreflect.Value
79
	lazy  *lazyExtensionValue
80
}
81

82
func (f *ExtensionField) appendLazyBytes(xt protoreflect.ExtensionType, xi *extensionFieldInfo, num protowire.Number, wtyp protowire.Type, b []byte) {
83
	if f.lazy == nil {
84
		f.lazy = &lazyExtensionValue{xi: xi}
85
	}
86
	f.typ = xt
87
	f.lazy.xi = xi
88
	f.lazy.b = protowire.AppendTag(f.lazy.b, num, wtyp)
89
	f.lazy.b = append(f.lazy.b, b...)
90
}
91

92
func (f *ExtensionField) canLazy(xt protoreflect.ExtensionType) bool {
93
	if f.typ == nil {
94
		return true
95
	}
96
	if f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
97
		return true
98
	}
99
	return false
100
}
101

102
func (f *ExtensionField) lazyInit() {
103
	f.lazy.mu.Lock()
104
	defer f.lazy.mu.Unlock()
105
	if atomic.LoadUint32(&f.lazy.atomicOnce) == 1 {
106
		return
107
	}
108
	if f.lazy.xi != nil {
109
		b := f.lazy.b
110
		val := f.typ.New()
111
		for len(b) > 0 {
112
			var tag uint64
113
			if b[0] < 0x80 {
114
				tag = uint64(b[0])
115
				b = b[1:]
116
			} else if len(b) >= 2 && b[1] < 128 {
117
				tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
118
				b = b[2:]
119
			} else {
120
				var n int
121
				tag, n = protowire.ConsumeVarint(b)
122
				if n < 0 {
123
					panic(errors.New("bad tag in lazy extension decoding"))
124
				}
125
				b = b[n:]
126
			}
127
			num := protowire.Number(tag >> 3)
128
			wtyp := protowire.Type(tag & 7)
129
			var out unmarshalOutput
130
			var err error
131
			val, out, err = f.lazy.xi.funcs.unmarshal(b, val, num, wtyp, lazyUnmarshalOptions)
132
			if err != nil {
133
				panic(errors.New("decode failure in lazy extension decoding: %v", err))
134
			}
135
			b = b[out.n:]
136
		}
137
		f.lazy.value = val
138
	} else {
139
		f.lazy.value = f.lazy.fn()
140
	}
141
	f.lazy.xi = nil
142
	f.lazy.fn = nil
143
	f.lazy.b = nil
144
	atomic.StoreUint32(&f.lazy.atomicOnce, 1)
145
}
146

147
// Set sets the type and value of the extension field.
148
// This must not be called concurrently.
149
func (f *ExtensionField) Set(t protoreflect.ExtensionType, v protoreflect.Value) {
150
	f.typ = t
151
	f.value = v
152
	f.lazy = nil
153
}
154

155
// SetLazy sets the type and a value that is to be lazily evaluated upon first use.
156
// This must not be called concurrently.
157
func (f *ExtensionField) SetLazy(t protoreflect.ExtensionType, fn func() protoreflect.Value) {
158
	f.typ = t
159
	f.lazy = &lazyExtensionValue{fn: fn}
160
}
161

162
// Value returns the value of the extension field.
163
// This may be called concurrently.
164
func (f *ExtensionField) Value() protoreflect.Value {
165
	if f.lazy != nil {
166
		if atomic.LoadUint32(&f.lazy.atomicOnce) == 0 {
167
			f.lazyInit()
168
		}
169
		return f.lazy.value
170
	}
171
	return f.value
172
}
173

174
// Type returns the type of the extension field.
175
// This may be called concurrently.
176
func (f ExtensionField) Type() protoreflect.ExtensionType {
177
	return f.typ
178
}
179

180
// IsSet returns whether the extension field is set.
181
// This may be called concurrently.
182
func (f ExtensionField) IsSet() bool {
183
	return f.typ != nil
184
}
185

186
// IsLazy reports whether a field is lazily encoded.
187
// It is exported for testing.
188
func IsLazy(m protoreflect.Message, fd protoreflect.FieldDescriptor) bool {
189
	var mi *MessageInfo
190
	var p pointer
191
	switch m := m.(type) {
192
	case *messageState:
193
		mi = m.messageInfo()
194
		p = m.pointer()
195
	case *messageReflectWrapper:
196
		mi = m.messageInfo()
197
		p = m.pointer()
198
	default:
199
		return false
200
	}
201
	xd, ok := fd.(protoreflect.ExtensionTypeDescriptor)
202
	if !ok {
203
		return false
204
	}
205
	xt := xd.Type()
206
	ext := mi.extensionMap(p)
207
	if ext == nil {
208
		return false
209
	}
210
	f, ok := (*ext)[int32(fd.Number())]
211
	if !ok {
212
		return false
213
	}
214
	return f.typ == xt && f.lazy != nil && atomic.LoadUint32(&f.lazy.atomicOnce) == 0
215
}
216