podman

1
// Copyright 2014 Google Inc. All Rights Reserved.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//     http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
// This file is a simple protocol buffer encoder and decoder.
16
// The format is described at
17
// https://developers.google.com/protocol-buffers/docs/encoding
18
//
19
// A protocol message must implement the message interface:
20
//   decoder() []decoder
21
//   encode(*buffer)
22
//
23
// The decode method returns a slice indexed by field number that gives the
24
// function to decode that field.
25
// The encode method encodes its receiver into the given buffer.
26
//
27
// The two methods are simple enough to be implemented by hand rather than
28
// by using a protocol compiler.
29
//
30
// See profile.go for examples of messages implementing this interface.
31
//
32
// There is no support for groups, message sets, or "has" bits.
33

34
package profile
35

36
import (
37
	"errors"
38
	"fmt"
39
)
40

41
type buffer struct {
42
	field int // field tag
43
	typ   int // proto wire type code for field
44
	u64   uint64
45
	data  []byte
46
	tmp   [16]byte
47
}
48

49
type decoder func(*buffer, message) error
50

51
type message interface {
52
	decoder() []decoder
53
	encode(*buffer)
54
}
55

56
func marshal(m message) []byte {
57
	var b buffer
58
	m.encode(&b)
59
	return b.data
60
}
61

62
func encodeVarint(b *buffer, x uint64) {
63
	for x >= 128 {
64
		b.data = append(b.data, byte(x)|0x80)
65
		x >>= 7
66
	}
67
	b.data = append(b.data, byte(x))
68
}
69

70
func encodeLength(b *buffer, tag int, len int) {
71
	encodeVarint(b, uint64(tag)<<3|2)
72
	encodeVarint(b, uint64(len))
73
}
74

75
func encodeUint64(b *buffer, tag int, x uint64) {
76
	// append varint to b.data
77
	encodeVarint(b, uint64(tag)<<3)
78
	encodeVarint(b, x)
79
}
80

81
func encodeUint64s(b *buffer, tag int, x []uint64) {
82
	if len(x) > 2 {
83
		// Use packed encoding
84
		n1 := len(b.data)
85
		for _, u := range x {
86
			encodeVarint(b, u)
87
		}
88
		n2 := len(b.data)
89
		encodeLength(b, tag, n2-n1)
90
		n3 := len(b.data)
91
		copy(b.tmp[:], b.data[n2:n3])
92
		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
93
		copy(b.data[n1:], b.tmp[:n3-n2])
94
		return
95
	}
96
	for _, u := range x {
97
		encodeUint64(b, tag, u)
98
	}
99
}
100

101
func encodeUint64Opt(b *buffer, tag int, x uint64) {
102
	if x == 0 {
103
		return
104
	}
105
	encodeUint64(b, tag, x)
106
}
107

108
func encodeInt64(b *buffer, tag int, x int64) {
109
	u := uint64(x)
110
	encodeUint64(b, tag, u)
111
}
112

113
func encodeInt64s(b *buffer, tag int, x []int64) {
114
	if len(x) > 2 {
115
		// Use packed encoding
116
		n1 := len(b.data)
117
		for _, u := range x {
118
			encodeVarint(b, uint64(u))
119
		}
120
		n2 := len(b.data)
121
		encodeLength(b, tag, n2-n1)
122
		n3 := len(b.data)
123
		copy(b.tmp[:], b.data[n2:n3])
124
		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
125
		copy(b.data[n1:], b.tmp[:n3-n2])
126
		return
127
	}
128
	for _, u := range x {
129
		encodeInt64(b, tag, u)
130
	}
131
}
132

133
func encodeInt64Opt(b *buffer, tag int, x int64) {
134
	if x == 0 {
135
		return
136
	}
137
	encodeInt64(b, tag, x)
138
}
139

140
func encodeString(b *buffer, tag int, x string) {
141
	encodeLength(b, tag, len(x))
142
	b.data = append(b.data, x...)
143
}
144

145
func encodeStrings(b *buffer, tag int, x []string) {
146
	for _, s := range x {
147
		encodeString(b, tag, s)
148
	}
149
}
150

151
func encodeBool(b *buffer, tag int, x bool) {
152
	if x {
153
		encodeUint64(b, tag, 1)
154
	} else {
155
		encodeUint64(b, tag, 0)
156
	}
157
}
158

159
func encodeBoolOpt(b *buffer, tag int, x bool) {
160
	if x {
161
		encodeBool(b, tag, x)
162
	}
163
}
164

165
func encodeMessage(b *buffer, tag int, m message) {
166
	n1 := len(b.data)
167
	m.encode(b)
168
	n2 := len(b.data)
169
	encodeLength(b, tag, n2-n1)
170
	n3 := len(b.data)
171
	copy(b.tmp[:], b.data[n2:n3])
172
	copy(b.data[n1+(n3-n2):], b.data[n1:n2])
173
	copy(b.data[n1:], b.tmp[:n3-n2])
174
}
175

176
func unmarshal(data []byte, m message) (err error) {
177
	b := buffer{data: data, typ: 2}
178
	return decodeMessage(&b, m)
179
}
180

181
func le64(p []byte) uint64 {
182
	return uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 | uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
183
}
184

185
func le32(p []byte) uint32 {
186
	return uint32(p[0]) | uint32(p[1])<<8 | uint32(p[2])<<16 | uint32(p[3])<<24
187
}
188

189
func decodeVarint(data []byte) (uint64, []byte, error) {
190
	var u uint64
191
	for i := 0; ; i++ {
192
		if i >= 10 || i >= len(data) {
193
			return 0, nil, errors.New("bad varint")
194
		}
195
		u |= uint64(data[i]&0x7F) << uint(7*i)
196
		if data[i]&0x80 == 0 {
197
			return u, data[i+1:], nil
198
		}
199
	}
200
}
201

202
func decodeField(b *buffer, data []byte) ([]byte, error) {
203
	x, data, err := decodeVarint(data)
204
	if err != nil {
205
		return nil, err
206
	}
207
	b.field = int(x >> 3)
208
	b.typ = int(x & 7)
209
	b.data = nil
210
	b.u64 = 0
211
	switch b.typ {
212
	case 0:
213
		b.u64, data, err = decodeVarint(data)
214
		if err != nil {
215
			return nil, err
216
		}
217
	case 1:
218
		if len(data) < 8 {
219
			return nil, errors.New("not enough data")
220
		}
221
		b.u64 = le64(data[:8])
222
		data = data[8:]
223
	case 2:
224
		var n uint64
225
		n, data, err = decodeVarint(data)
226
		if err != nil {
227
			return nil, err
228
		}
229
		if n > uint64(len(data)) {
230
			return nil, errors.New("too much data")
231
		}
232
		b.data = data[:n]
233
		data = data[n:]
234
	case 5:
235
		if len(data) < 4 {
236
			return nil, errors.New("not enough data")
237
		}
238
		b.u64 = uint64(le32(data[:4]))
239
		data = data[4:]
240
	default:
241
		return nil, fmt.Errorf("unknown wire type: %d", b.typ)
242
	}
243

244
	return data, nil
245
}
246

247
func checkType(b *buffer, typ int) error {
248
	if b.typ != typ {
249
		return errors.New("type mismatch")
250
	}
251
	return nil
252
}
253

254
func decodeMessage(b *buffer, m message) error {
255
	if err := checkType(b, 2); err != nil {
256
		return err
257
	}
258
	dec := m.decoder()
259
	data := b.data
260
	for len(data) > 0 {
261
		// pull varint field# + type
262
		var err error
263
		data, err = decodeField(b, data)
264
		if err != nil {
265
			return err
266
		}
267
		if b.field >= len(dec) || dec[b.field] == nil {
268
			continue
269
		}
270
		if err := dec[b.field](b, m); err != nil {
271
			return err
272
		}
273
	}
274
	return nil
275
}
276

277
func decodeInt64(b *buffer, x *int64) error {
278
	if err := checkType(b, 0); err != nil {
279
		return err
280
	}
281
	*x = int64(b.u64)
282
	return nil
283
}
284

285
func decodeInt64s(b *buffer, x *[]int64) error {
286
	if b.typ == 2 {
287
		// Packed encoding
288
		data := b.data
289
		tmp := make([]int64, 0, len(data)) // Maximally sized
290
		for len(data) > 0 {
291
			var u uint64
292
			var err error
293

294
			if u, data, err = decodeVarint(data); err != nil {
295
				return err
296
			}
297
			tmp = append(tmp, int64(u))
298
		}
299
		*x = append(*x, tmp...)
300
		return nil
301
	}
302
	var i int64
303
	if err := decodeInt64(b, &i); err != nil {
304
		return err
305
	}
306
	*x = append(*x, i)
307
	return nil
308
}
309

310
func decodeUint64(b *buffer, x *uint64) error {
311
	if err := checkType(b, 0); err != nil {
312
		return err
313
	}
314
	*x = b.u64
315
	return nil
316
}
317

318
func decodeUint64s(b *buffer, x *[]uint64) error {
319
	if b.typ == 2 {
320
		data := b.data
321
		// Packed encoding
322
		tmp := make([]uint64, 0, len(data)) // Maximally sized
323
		for len(data) > 0 {
324
			var u uint64
325
			var err error
326

327
			if u, data, err = decodeVarint(data); err != nil {
328
				return err
329
			}
330
			tmp = append(tmp, u)
331
		}
332
		*x = append(*x, tmp...)
333
		return nil
334
	}
335
	var u uint64
336
	if err := decodeUint64(b, &u); err != nil {
337
		return err
338
	}
339
	*x = append(*x, u)
340
	return nil
341
}
342

343
func decodeString(b *buffer, x *string) error {
344
	if err := checkType(b, 2); err != nil {
345
		return err
346
	}
347
	*x = string(b.data)
348
	return nil
349
}
350

351
func decodeStrings(b *buffer, x *[]string) error {
352
	var s string
353
	if err := decodeString(b, &s); err != nil {
354
		return err
355
	}
356
	*x = append(*x, s)
357
	return nil
358
}
359

360
func decodeBool(b *buffer, x *bool) error {
361
	if err := checkType(b, 0); err != nil {
362
		return err
363
	}
364
	if int64(b.u64) == 0 {
365
		*x = false
366
	} else {
367
		*x = true
368
	}
369
	return nil
370
}
371