podman

1
// Go support for Protocol Buffers - Google's data interchange format
2
//
3
// Copyright 2011 The Go Authors.  All rights reserved.
4
// https://github.com/golang/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
//     * Neither the name of Google Inc. nor the names of its
17
// contributors may be used to endorse or promote products derived from
18
// this software without specific prior written permission.
19
//
20
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31

32
// Protocol buffer comparison.
33

34
package proto
35

36
import (
37
	"bytes"
38
	"log"
39
	"reflect"
40
	"strings"
41
)
42

43
/*
44
Equal returns true iff protocol buffers a and b are equal.
45
The arguments must both be pointers to protocol buffer structs.
46

47
Equality is defined in this way:
48
  - Two messages are equal iff they are the same type,
49
    corresponding fields are equal, unknown field sets
50
    are equal, and extensions sets are equal.
51
  - Two set scalar fields are equal iff their values are equal.
52
    If the fields are of a floating-point type, remember that
53
    NaN != x for all x, including NaN. If the message is defined
54
    in a proto3 .proto file, fields are not "set"; specifically,
55
    zero length proto3 "bytes" fields are equal (nil == {}).
56
  - Two repeated fields are equal iff their lengths are the same,
57
    and their corresponding elements are equal. Note a "bytes" field,
58
    although represented by []byte, is not a repeated field and the
59
    rule for the scalar fields described above applies.
60
  - Two unset fields are equal.
61
  - Two unknown field sets are equal if their current
62
    encoded state is equal.
63
  - Two extension sets are equal iff they have corresponding
64
    elements that are pairwise equal.
65
  - Two map fields are equal iff their lengths are the same,
66
    and they contain the same set of elements. Zero-length map
67
    fields are equal.
68
  - Every other combination of things are not equal.
69

70
The return value is undefined if a and b are not protocol buffers.
71
*/
72
func Equal(a, b Message) bool {
73
	if a == nil || b == nil {
74
		return a == b
75
	}
76
	v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b)
77
	if v1.Type() != v2.Type() {
78
		return false
79
	}
80
	if v1.Kind() == reflect.Ptr {
81
		if v1.IsNil() {
82
			return v2.IsNil()
83
		}
84
		if v2.IsNil() {
85
			return false
86
		}
87
		v1, v2 = v1.Elem(), v2.Elem()
88
	}
89
	if v1.Kind() != reflect.Struct {
90
		return false
91
	}
92
	return equalStruct(v1, v2)
93
}
94

95
// v1 and v2 are known to have the same type.
96
func equalStruct(v1, v2 reflect.Value) bool {
97
	sprop := GetProperties(v1.Type())
98
	for i := 0; i < v1.NumField(); i++ {
99
		f := v1.Type().Field(i)
100
		if strings.HasPrefix(f.Name, "XXX_") {
101
			continue
102
		}
103
		f1, f2 := v1.Field(i), v2.Field(i)
104
		if f.Type.Kind() == reflect.Ptr {
105
			if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 {
106
				// both unset
107
				continue
108
			} else if n1 != n2 {
109
				// set/unset mismatch
110
				return false
111
			}
112
			f1, f2 = f1.Elem(), f2.Elem()
113
		}
114
		if !equalAny(f1, f2, sprop.Prop[i]) {
115
			return false
116
		}
117
	}
118

119
	if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() {
120
		em2 := v2.FieldByName("XXX_InternalExtensions")
121
		if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) {
122
			return false
123
		}
124
	}
125

126
	if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() {
127
		em2 := v2.FieldByName("XXX_extensions")
128
		if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) {
129
			return false
130
		}
131
	}
132

133
	uf := v1.FieldByName("XXX_unrecognized")
134
	if !uf.IsValid() {
135
		return true
136
	}
137

138
	u1 := uf.Bytes()
139
	u2 := v2.FieldByName("XXX_unrecognized").Bytes()
140
	return bytes.Equal(u1, u2)
141
}
142

143
// v1 and v2 are known to have the same type.
144
// prop may be nil.
145
func equalAny(v1, v2 reflect.Value, prop *Properties) bool {
146
	if v1.Type() == protoMessageType {
147
		m1, _ := v1.Interface().(Message)
148
		m2, _ := v2.Interface().(Message)
149
		return Equal(m1, m2)
150
	}
151
	switch v1.Kind() {
152
	case reflect.Bool:
153
		return v1.Bool() == v2.Bool()
154
	case reflect.Float32, reflect.Float64:
155
		return v1.Float() == v2.Float()
156
	case reflect.Int32, reflect.Int64:
157
		return v1.Int() == v2.Int()
158
	case reflect.Interface:
159
		// Probably a oneof field; compare the inner values.
160
		n1, n2 := v1.IsNil(), v2.IsNil()
161
		if n1 || n2 {
162
			return n1 == n2
163
		}
164
		e1, e2 := v1.Elem(), v2.Elem()
165
		if e1.Type() != e2.Type() {
166
			return false
167
		}
168
		return equalAny(e1, e2, nil)
169
	case reflect.Map:
170
		if v1.Len() != v2.Len() {
171
			return false
172
		}
173
		for _, key := range v1.MapKeys() {
174
			val2 := v2.MapIndex(key)
175
			if !val2.IsValid() {
176
				// This key was not found in the second map.
177
				return false
178
			}
179
			if !equalAny(v1.MapIndex(key), val2, nil) {
180
				return false
181
			}
182
		}
183
		return true
184
	case reflect.Ptr:
185
		// Maps may have nil values in them, so check for nil.
186
		if v1.IsNil() && v2.IsNil() {
187
			return true
188
		}
189
		if v1.IsNil() != v2.IsNil() {
190
			return false
191
		}
192
		return equalAny(v1.Elem(), v2.Elem(), prop)
193
	case reflect.Slice:
194
		if v1.Type().Elem().Kind() == reflect.Uint8 {
195
			// short circuit: []byte
196

197
			// Edge case: if this is in a proto3 message, a zero length
198
			// bytes field is considered the zero value.
199
			if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 {
200
				return true
201
			}
202
			if v1.IsNil() != v2.IsNil() {
203
				return false
204
			}
205
			return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte))
206
		}
207

208
		if v1.Len() != v2.Len() {
209
			return false
210
		}
211
		for i := 0; i < v1.Len(); i++ {
212
			if !equalAny(v1.Index(i), v2.Index(i), prop) {
213
				return false
214
			}
215
		}
216
		return true
217
	case reflect.String:
218
		return v1.Interface().(string) == v2.Interface().(string)
219
	case reflect.Struct:
220
		return equalStruct(v1, v2)
221
	case reflect.Uint32, reflect.Uint64:
222
		return v1.Uint() == v2.Uint()
223
	}
224

225
	// unknown type, so not a protocol buffer
226
	log.Printf("proto: don't know how to compare %v", v1)
227
	return false
228
}
229

230
// base is the struct type that the extensions are based on.
231
// x1 and x2 are InternalExtensions.
232
func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool {
233
	em1, _ := x1.extensionsRead()
234
	em2, _ := x2.extensionsRead()
235
	return equalExtMap(base, em1, em2)
236
}
237

238
func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool {
239
	if len(em1) != len(em2) {
240
		return false
241
	}
242

243
	for extNum, e1 := range em1 {
244
		e2, ok := em2[extNum]
245
		if !ok {
246
			return false
247
		}
248

249
		m1, m2 := e1.value, e2.value
250

251
		if m1 == nil && m2 == nil {
252
			// Both have only encoded form.
253
			if bytes.Equal(e1.enc, e2.enc) {
254
				continue
255
			}
256
			// The bytes are different, but the extensions might still be
257
			// equal. We need to decode them to compare.
258
		}
259

260
		if m1 != nil && m2 != nil {
261
			// Both are unencoded.
262
			if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
263
				return false
264
			}
265
			continue
266
		}
267

268
		// At least one is encoded. To do a semantically correct comparison
269
		// we need to unmarshal them first.
270
		var desc *ExtensionDesc
271
		if m := extensionMaps[base]; m != nil {
272
			desc = m[extNum]
273
		}
274
		if desc == nil {
275
			// If both have only encoded form and the bytes are the same,
276
			// it is handled above. We get here when the bytes are different.
277
			// We don't know how to decode it, so just compare them as byte
278
			// slices.
279
			log.Printf("proto: don't know how to compare extension %d of %v", extNum, base)
280
			return false
281
		}
282
		var err error
283
		if m1 == nil {
284
			m1, err = decodeExtension(e1.enc, desc)
285
		}
286
		if m2 == nil && err == nil {
287
			m2, err = decodeExtension(e2.enc, desc)
288
		}
289
		if err != nil {
290
			// The encoded form is invalid.
291
			log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err)
292
			return false
293
		}
294
		if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) {
295
			return false
296
		}
297
	}
298

299
	return true
300
}
301