podman

1
// Protocol Buffers for Go with Gadgets
2
//
3
// Copyright (c) 2018, The GoGo Authors. All rights reserved.
4
// http://github.com/gogo/protobuf
5
//
6
// Redistribution and use in source and binary forms, with or without
7
// modification, are permitted provided that the following conditions are
8
// met:
9
//
10
//     * Redistributions of source code must retain the above copyright
11
// notice, this list of conditions and the following disclaimer.
12
//     * Redistributions in binary form must reproduce the above
13
// copyright notice, this list of conditions and the following disclaimer
14
// in the documentation and/or other materials provided with the
15
// distribution.
16
//
17
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28

29
package proto
30

31
import (
32
	"io"
33
	"reflect"
34
)
35

36
func makeUnmarshalMessage(sub *unmarshalInfo, name string) unmarshaler {
37
	return func(b []byte, f pointer, w int) ([]byte, error) {
38
		if w != WireBytes {
39
			return nil, errInternalBadWireType
40
		}
41
		x, n := decodeVarint(b)
42
		if n == 0 {
43
			return nil, io.ErrUnexpectedEOF
44
		}
45
		b = b[n:]
46
		if x > uint64(len(b)) {
47
			return nil, io.ErrUnexpectedEOF
48
		}
49
		// First read the message field to see if something is there.
50
		// The semantics of multiple submessages are weird.  Instead of
51
		// the last one winning (as it is for all other fields), multiple
52
		// submessages are merged.
53
		v := f // gogo: changed from v := f.getPointer()
54
		if v.isNil() {
55
			v = valToPointer(reflect.New(sub.typ))
56
			f.setPointer(v)
57
		}
58
		err := sub.unmarshal(v, b[:x])
59
		if err != nil {
60
			if r, ok := err.(*RequiredNotSetError); ok {
61
				r.field = name + "." + r.field
62
			} else {
63
				return nil, err
64
			}
65
		}
66
		return b[x:], err
67
	}
68
}
69

70
func makeUnmarshalMessageSlice(sub *unmarshalInfo, name string) unmarshaler {
71
	return func(b []byte, f pointer, w int) ([]byte, error) {
72
		if w != WireBytes {
73
			return nil, errInternalBadWireType
74
		}
75
		x, n := decodeVarint(b)
76
		if n == 0 {
77
			return nil, io.ErrUnexpectedEOF
78
		}
79
		b = b[n:]
80
		if x > uint64(len(b)) {
81
			return nil, io.ErrUnexpectedEOF
82
		}
83
		v := valToPointer(reflect.New(sub.typ))
84
		err := sub.unmarshal(v, b[:x])
85
		if err != nil {
86
			if r, ok := err.(*RequiredNotSetError); ok {
87
				r.field = name + "." + r.field
88
			} else {
89
				return nil, err
90
			}
91
		}
92
		f.appendRef(v, sub.typ) // gogo: changed from f.appendPointer(v)
93
		return b[x:], err
94
	}
95
}
96

97
func makeUnmarshalCustomPtr(sub *unmarshalInfo, name string) unmarshaler {
98
	return func(b []byte, f pointer, w int) ([]byte, error) {
99
		if w != WireBytes {
100
			return nil, errInternalBadWireType
101
		}
102
		x, n := decodeVarint(b)
103
		if n == 0 {
104
			return nil, io.ErrUnexpectedEOF
105
		}
106
		b = b[n:]
107
		if x > uint64(len(b)) {
108
			return nil, io.ErrUnexpectedEOF
109
		}
110

111
		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
112
		s.Set(reflect.New(sub.typ))
113
		m := s.Interface().(custom)
114
		if err := m.Unmarshal(b[:x]); err != nil {
115
			return nil, err
116
		}
117
		return b[x:], nil
118
	}
119
}
120

121
func makeUnmarshalCustomSlice(sub *unmarshalInfo, name string) unmarshaler {
122
	return func(b []byte, f pointer, w int) ([]byte, error) {
123
		if w != WireBytes {
124
			return nil, errInternalBadWireType
125
		}
126
		x, n := decodeVarint(b)
127
		if n == 0 {
128
			return nil, io.ErrUnexpectedEOF
129
		}
130
		b = b[n:]
131
		if x > uint64(len(b)) {
132
			return nil, io.ErrUnexpectedEOF
133
		}
134
		m := reflect.New(sub.typ)
135
		c := m.Interface().(custom)
136
		if err := c.Unmarshal(b[:x]); err != nil {
137
			return nil, err
138
		}
139
		v := valToPointer(m)
140
		f.appendRef(v, sub.typ)
141
		return b[x:], nil
142
	}
143
}
144

145
func makeUnmarshalCustom(sub *unmarshalInfo, name string) unmarshaler {
146
	return func(b []byte, f pointer, w int) ([]byte, error) {
147
		if w != WireBytes {
148
			return nil, errInternalBadWireType
149
		}
150
		x, n := decodeVarint(b)
151
		if n == 0 {
152
			return nil, io.ErrUnexpectedEOF
153
		}
154
		b = b[n:]
155
		if x > uint64(len(b)) {
156
			return nil, io.ErrUnexpectedEOF
157
		}
158

159
		m := f.asPointerTo(sub.typ).Interface().(custom)
160
		if err := m.Unmarshal(b[:x]); err != nil {
161
			return nil, err
162
		}
163
		return b[x:], nil
164
	}
165
}
166

167
func makeUnmarshalTime(sub *unmarshalInfo, name string) unmarshaler {
168
	return func(b []byte, f pointer, w int) ([]byte, error) {
169
		if w != WireBytes {
170
			return nil, errInternalBadWireType
171
		}
172
		x, n := decodeVarint(b)
173
		if n == 0 {
174
			return nil, io.ErrUnexpectedEOF
175
		}
176
		b = b[n:]
177
		if x > uint64(len(b)) {
178
			return nil, io.ErrUnexpectedEOF
179
		}
180
		m := &timestamp{}
181
		if err := Unmarshal(b[:x], m); err != nil {
182
			return nil, err
183
		}
184
		t, err := timestampFromProto(m)
185
		if err != nil {
186
			return nil, err
187
		}
188
		s := f.asPointerTo(sub.typ).Elem()
189
		s.Set(reflect.ValueOf(t))
190
		return b[x:], nil
191
	}
192
}
193

194
func makeUnmarshalTimePtr(sub *unmarshalInfo, name string) unmarshaler {
195
	return func(b []byte, f pointer, w int) ([]byte, error) {
196
		if w != WireBytes {
197
			return nil, errInternalBadWireType
198
		}
199
		x, n := decodeVarint(b)
200
		if n == 0 {
201
			return nil, io.ErrUnexpectedEOF
202
		}
203
		b = b[n:]
204
		if x > uint64(len(b)) {
205
			return nil, io.ErrUnexpectedEOF
206
		}
207
		m := &timestamp{}
208
		if err := Unmarshal(b[:x], m); err != nil {
209
			return nil, err
210
		}
211
		t, err := timestampFromProto(m)
212
		if err != nil {
213
			return nil, err
214
		}
215
		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
216
		s.Set(reflect.ValueOf(&t))
217
		return b[x:], nil
218
	}
219
}
220

221
func makeUnmarshalTimePtrSlice(sub *unmarshalInfo, name string) unmarshaler {
222
	return func(b []byte, f pointer, w int) ([]byte, error) {
223
		if w != WireBytes {
224
			return nil, errInternalBadWireType
225
		}
226
		x, n := decodeVarint(b)
227
		if n == 0 {
228
			return nil, io.ErrUnexpectedEOF
229
		}
230
		b = b[n:]
231
		if x > uint64(len(b)) {
232
			return nil, io.ErrUnexpectedEOF
233
		}
234
		m := &timestamp{}
235
		if err := Unmarshal(b[:x], m); err != nil {
236
			return nil, err
237
		}
238
		t, err := timestampFromProto(m)
239
		if err != nil {
240
			return nil, err
241
		}
242
		slice := f.getSlice(reflect.PtrTo(sub.typ))
243
		newSlice := reflect.Append(slice, reflect.ValueOf(&t))
244
		slice.Set(newSlice)
245
		return b[x:], nil
246
	}
247
}
248

249
func makeUnmarshalTimeSlice(sub *unmarshalInfo, name string) unmarshaler {
250
	return func(b []byte, f pointer, w int) ([]byte, error) {
251
		if w != WireBytes {
252
			return nil, errInternalBadWireType
253
		}
254
		x, n := decodeVarint(b)
255
		if n == 0 {
256
			return nil, io.ErrUnexpectedEOF
257
		}
258
		b = b[n:]
259
		if x > uint64(len(b)) {
260
			return nil, io.ErrUnexpectedEOF
261
		}
262
		m := &timestamp{}
263
		if err := Unmarshal(b[:x], m); err != nil {
264
			return nil, err
265
		}
266
		t, err := timestampFromProto(m)
267
		if err != nil {
268
			return nil, err
269
		}
270
		slice := f.getSlice(sub.typ)
271
		newSlice := reflect.Append(slice, reflect.ValueOf(t))
272
		slice.Set(newSlice)
273
		return b[x:], nil
274
	}
275
}
276

277
func makeUnmarshalDurationPtr(sub *unmarshalInfo, name string) unmarshaler {
278
	return func(b []byte, f pointer, w int) ([]byte, error) {
279
		if w != WireBytes {
280
			return nil, errInternalBadWireType
281
		}
282
		x, n := decodeVarint(b)
283
		if n == 0 {
284
			return nil, io.ErrUnexpectedEOF
285
		}
286
		b = b[n:]
287
		if x > uint64(len(b)) {
288
			return nil, io.ErrUnexpectedEOF
289
		}
290
		m := &duration{}
291
		if err := Unmarshal(b[:x], m); err != nil {
292
			return nil, err
293
		}
294
		d, err := durationFromProto(m)
295
		if err != nil {
296
			return nil, err
297
		}
298
		s := f.asPointerTo(reflect.PtrTo(sub.typ)).Elem()
299
		s.Set(reflect.ValueOf(&d))
300
		return b[x:], nil
301
	}
302
}
303

304
func makeUnmarshalDuration(sub *unmarshalInfo, name string) unmarshaler {
305
	return func(b []byte, f pointer, w int) ([]byte, error) {
306
		if w != WireBytes {
307
			return nil, errInternalBadWireType
308
		}
309
		x, n := decodeVarint(b)
310
		if n == 0 {
311
			return nil, io.ErrUnexpectedEOF
312
		}
313
		b = b[n:]
314
		if x > uint64(len(b)) {
315
			return nil, io.ErrUnexpectedEOF
316
		}
317
		m := &duration{}
318
		if err := Unmarshal(b[:x], m); err != nil {
319
			return nil, err
320
		}
321
		d, err := durationFromProto(m)
322
		if err != nil {
323
			return nil, err
324
		}
325
		s := f.asPointerTo(sub.typ).Elem()
326
		s.Set(reflect.ValueOf(d))
327
		return b[x:], nil
328
	}
329
}
330

331
func makeUnmarshalDurationPtrSlice(sub *unmarshalInfo, name string) unmarshaler {
332
	return func(b []byte, f pointer, w int) ([]byte, error) {
333
		if w != WireBytes {
334
			return nil, errInternalBadWireType
335
		}
336
		x, n := decodeVarint(b)
337
		if n == 0 {
338
			return nil, io.ErrUnexpectedEOF
339
		}
340
		b = b[n:]
341
		if x > uint64(len(b)) {
342
			return nil, io.ErrUnexpectedEOF
343
		}
344
		m := &duration{}
345
		if err := Unmarshal(b[:x], m); err != nil {
346
			return nil, err
347
		}
348
		d, err := durationFromProto(m)
349
		if err != nil {
350
			return nil, err
351
		}
352
		slice := f.getSlice(reflect.PtrTo(sub.typ))
353
		newSlice := reflect.Append(slice, reflect.ValueOf(&d))
354
		slice.Set(newSlice)
355
		return b[x:], nil
356
	}
357
}
358

359
func makeUnmarshalDurationSlice(sub *unmarshalInfo, name string) unmarshaler {
360
	return func(b []byte, f pointer, w int) ([]byte, error) {
361
		if w != WireBytes {
362
			return nil, errInternalBadWireType
363
		}
364
		x, n := decodeVarint(b)
365
		if n == 0 {
366
			return nil, io.ErrUnexpectedEOF
367
		}
368
		b = b[n:]
369
		if x > uint64(len(b)) {
370
			return nil, io.ErrUnexpectedEOF
371
		}
372
		m := &duration{}
373
		if err := Unmarshal(b[:x], m); err != nil {
374
			return nil, err
375
		}
376
		d, err := durationFromProto(m)
377
		if err != nil {
378
			return nil, err
379
		}
380
		slice := f.getSlice(sub.typ)
381
		newSlice := reflect.Append(slice, reflect.ValueOf(d))
382
		slice.Set(newSlice)
383
		return b[x:], nil
384
	}
385
}
386