]>
Commit | Line | Data |
---|---|---|
15c0b25d AP |
1 | // Go support for Protocol Buffers - Google's data interchange format |
2 | // | |
3 | // Copyright 2010 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 | package proto | |
33 | ||
34 | /* | |
35 | * Routines for encoding data into the wire format for protocol buffers. | |
36 | */ | |
37 | ||
38 | import ( | |
39 | "fmt" | |
40 | "log" | |
41 | "os" | |
42 | "reflect" | |
43 | "sort" | |
44 | "strconv" | |
45 | "strings" | |
46 | "sync" | |
47 | ) | |
48 | ||
49 | const debug bool = false | |
50 | ||
51 | // Constants that identify the encoding of a value on the wire. | |
52 | const ( | |
53 | WireVarint = 0 | |
54 | WireFixed64 = 1 | |
55 | WireBytes = 2 | |
56 | WireStartGroup = 3 | |
57 | WireEndGroup = 4 | |
58 | WireFixed32 = 5 | |
59 | ) | |
60 | ||
61 | // tagMap is an optimization over map[int]int for typical protocol buffer | |
62 | // use-cases. Encoded protocol buffers are often in tag order with small tag | |
63 | // numbers. | |
64 | type tagMap struct { | |
65 | fastTags []int | |
66 | slowTags map[int]int | |
67 | } | |
68 | ||
69 | // tagMapFastLimit is the upper bound on the tag number that will be stored in | |
70 | // the tagMap slice rather than its map. | |
71 | const tagMapFastLimit = 1024 | |
72 | ||
73 | func (p *tagMap) get(t int) (int, bool) { | |
74 | if t > 0 && t < tagMapFastLimit { | |
75 | if t >= len(p.fastTags) { | |
76 | return 0, false | |
77 | } | |
78 | fi := p.fastTags[t] | |
79 | return fi, fi >= 0 | |
80 | } | |
81 | fi, ok := p.slowTags[t] | |
82 | return fi, ok | |
83 | } | |
84 | ||
85 | func (p *tagMap) put(t int, fi int) { | |
86 | if t > 0 && t < tagMapFastLimit { | |
87 | for len(p.fastTags) < t+1 { | |
88 | p.fastTags = append(p.fastTags, -1) | |
89 | } | |
90 | p.fastTags[t] = fi | |
91 | return | |
92 | } | |
93 | if p.slowTags == nil { | |
94 | p.slowTags = make(map[int]int) | |
95 | } | |
96 | p.slowTags[t] = fi | |
97 | } | |
98 | ||
99 | // StructProperties represents properties for all the fields of a struct. | |
100 | // decoderTags and decoderOrigNames should only be used by the decoder. | |
101 | type StructProperties struct { | |
102 | Prop []*Properties // properties for each field | |
103 | reqCount int // required count | |
104 | decoderTags tagMap // map from proto tag to struct field number | |
105 | decoderOrigNames map[string]int // map from original name to struct field number | |
106 | order []int // list of struct field numbers in tag order | |
107 | ||
108 | // OneofTypes contains information about the oneof fields in this message. | |
109 | // It is keyed by the original name of a field. | |
110 | OneofTypes map[string]*OneofProperties | |
111 | } | |
112 | ||
113 | // OneofProperties represents information about a specific field in a oneof. | |
114 | type OneofProperties struct { | |
115 | Type reflect.Type // pointer to generated struct type for this oneof field | |
116 | Field int // struct field number of the containing oneof in the message | |
117 | Prop *Properties | |
118 | } | |
119 | ||
120 | // Implement the sorting interface so we can sort the fields in tag order, as recommended by the spec. | |
121 | // See encode.go, (*Buffer).enc_struct. | |
122 | ||
123 | func (sp *StructProperties) Len() int { return len(sp.order) } | |
124 | func (sp *StructProperties) Less(i, j int) bool { | |
125 | return sp.Prop[sp.order[i]].Tag < sp.Prop[sp.order[j]].Tag | |
126 | } | |
127 | func (sp *StructProperties) Swap(i, j int) { sp.order[i], sp.order[j] = sp.order[j], sp.order[i] } | |
128 | ||
129 | // Properties represents the protocol-specific behavior of a single struct field. | |
130 | type Properties struct { | |
131 | Name string // name of the field, for error messages | |
132 | OrigName string // original name before protocol compiler (always set) | |
133 | JSONName string // name to use for JSON; determined by protoc | |
134 | Wire string | |
135 | WireType int | |
136 | Tag int | |
137 | Required bool | |
138 | Optional bool | |
139 | Repeated bool | |
140 | Packed bool // relevant for repeated primitives only | |
141 | Enum string // set for enum types only | |
142 | proto3 bool // whether this is known to be a proto3 field | |
143 | oneof bool // whether this is a oneof field | |
144 | ||
145 | Default string // default value | |
146 | HasDefault bool // whether an explicit default was provided | |
147 | ||
148 | stype reflect.Type // set for struct types only | |
149 | sprop *StructProperties // set for struct types only | |
150 | ||
151 | mtype reflect.Type // set for map types only | |
152 | MapKeyProp *Properties // set for map types only | |
153 | MapValProp *Properties // set for map types only | |
154 | } | |
155 | ||
156 | // String formats the properties in the protobuf struct field tag style. | |
157 | func (p *Properties) String() string { | |
158 | s := p.Wire | |
159 | s += "," | |
160 | s += strconv.Itoa(p.Tag) | |
161 | if p.Required { | |
162 | s += ",req" | |
163 | } | |
164 | if p.Optional { | |
165 | s += ",opt" | |
166 | } | |
167 | if p.Repeated { | |
168 | s += ",rep" | |
169 | } | |
170 | if p.Packed { | |
171 | s += ",packed" | |
172 | } | |
173 | s += ",name=" + p.OrigName | |
174 | if p.JSONName != p.OrigName { | |
175 | s += ",json=" + p.JSONName | |
176 | } | |
177 | if p.proto3 { | |
178 | s += ",proto3" | |
179 | } | |
180 | if p.oneof { | |
181 | s += ",oneof" | |
182 | } | |
183 | if len(p.Enum) > 0 { | |
184 | s += ",enum=" + p.Enum | |
185 | } | |
186 | if p.HasDefault { | |
187 | s += ",def=" + p.Default | |
188 | } | |
189 | return s | |
190 | } | |
191 | ||
192 | // Parse populates p by parsing a string in the protobuf struct field tag style. | |
193 | func (p *Properties) Parse(s string) { | |
194 | // "bytes,49,opt,name=foo,def=hello!" | |
195 | fields := strings.Split(s, ",") // breaks def=, but handled below. | |
196 | if len(fields) < 2 { | |
197 | fmt.Fprintf(os.Stderr, "proto: tag has too few fields: %q\n", s) | |
198 | return | |
199 | } | |
200 | ||
201 | p.Wire = fields[0] | |
202 | switch p.Wire { | |
203 | case "varint": | |
204 | p.WireType = WireVarint | |
205 | case "fixed32": | |
206 | p.WireType = WireFixed32 | |
207 | case "fixed64": | |
208 | p.WireType = WireFixed64 | |
209 | case "zigzag32": | |
210 | p.WireType = WireVarint | |
211 | case "zigzag64": | |
212 | p.WireType = WireVarint | |
213 | case "bytes", "group": | |
214 | p.WireType = WireBytes | |
215 | // no numeric converter for non-numeric types | |
216 | default: | |
217 | fmt.Fprintf(os.Stderr, "proto: tag has unknown wire type: %q\n", s) | |
218 | return | |
219 | } | |
220 | ||
221 | var err error | |
222 | p.Tag, err = strconv.Atoi(fields[1]) | |
223 | if err != nil { | |
224 | return | |
225 | } | |
226 | ||
227 | outer: | |
228 | for i := 2; i < len(fields); i++ { | |
229 | f := fields[i] | |
230 | switch { | |
231 | case f == "req": | |
232 | p.Required = true | |
233 | case f == "opt": | |
234 | p.Optional = true | |
235 | case f == "rep": | |
236 | p.Repeated = true | |
237 | case f == "packed": | |
238 | p.Packed = true | |
239 | case strings.HasPrefix(f, "name="): | |
240 | p.OrigName = f[5:] | |
241 | case strings.HasPrefix(f, "json="): | |
242 | p.JSONName = f[5:] | |
243 | case strings.HasPrefix(f, "enum="): | |
244 | p.Enum = f[5:] | |
245 | case f == "proto3": | |
246 | p.proto3 = true | |
247 | case f == "oneof": | |
248 | p.oneof = true | |
249 | case strings.HasPrefix(f, "def="): | |
250 | p.HasDefault = true | |
251 | p.Default = f[4:] // rest of string | |
252 | if i+1 < len(fields) { | |
253 | // Commas aren't escaped, and def is always last. | |
254 | p.Default += "," + strings.Join(fields[i+1:], ",") | |
255 | break outer | |
256 | } | |
257 | } | |
258 | } | |
259 | } | |
260 | ||
261 | var protoMessageType = reflect.TypeOf((*Message)(nil)).Elem() | |
262 | ||
263 | // setFieldProps initializes the field properties for submessages and maps. | |
264 | func (p *Properties) setFieldProps(typ reflect.Type, f *reflect.StructField, lockGetProp bool) { | |
265 | switch t1 := typ; t1.Kind() { | |
266 | case reflect.Ptr: | |
267 | if t1.Elem().Kind() == reflect.Struct { | |
268 | p.stype = t1.Elem() | |
269 | } | |
270 | ||
271 | case reflect.Slice: | |
272 | if t2 := t1.Elem(); t2.Kind() == reflect.Ptr && t2.Elem().Kind() == reflect.Struct { | |
273 | p.stype = t2.Elem() | |
274 | } | |
275 | ||
276 | case reflect.Map: | |
277 | p.mtype = t1 | |
278 | p.MapKeyProp = &Properties{} | |
279 | p.MapKeyProp.init(reflect.PtrTo(p.mtype.Key()), "Key", f.Tag.Get("protobuf_key"), nil, lockGetProp) | |
280 | p.MapValProp = &Properties{} | |
281 | vtype := p.mtype.Elem() | |
282 | if vtype.Kind() != reflect.Ptr && vtype.Kind() != reflect.Slice { | |
283 | // The value type is not a message (*T) or bytes ([]byte), | |
284 | // so we need encoders for the pointer to this type. | |
285 | vtype = reflect.PtrTo(vtype) | |
286 | } | |
287 | p.MapValProp.init(vtype, "Value", f.Tag.Get("protobuf_val"), nil, lockGetProp) | |
288 | } | |
289 | ||
290 | if p.stype != nil { | |
291 | if lockGetProp { | |
292 | p.sprop = GetProperties(p.stype) | |
293 | } else { | |
294 | p.sprop = getPropertiesLocked(p.stype) | |
295 | } | |
296 | } | |
297 | } | |
298 | ||
299 | var ( | |
300 | marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem() | |
301 | ) | |
302 | ||
303 | // Init populates the properties from a protocol buffer struct tag. | |
304 | func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) { | |
305 | p.init(typ, name, tag, f, true) | |
306 | } | |
307 | ||
308 | func (p *Properties) init(typ reflect.Type, name, tag string, f *reflect.StructField, lockGetProp bool) { | |
309 | // "bytes,49,opt,def=hello!" | |
310 | p.Name = name | |
311 | p.OrigName = name | |
312 | if tag == "" { | |
313 | return | |
314 | } | |
315 | p.Parse(tag) | |
316 | p.setFieldProps(typ, f, lockGetProp) | |
317 | } | |
318 | ||
319 | var ( | |
320 | propertiesMu sync.RWMutex | |
321 | propertiesMap = make(map[reflect.Type]*StructProperties) | |
322 | ) | |
323 | ||
324 | // GetProperties returns the list of properties for the type represented by t. | |
325 | // t must represent a generated struct type of a protocol message. | |
326 | func GetProperties(t reflect.Type) *StructProperties { | |
327 | if t.Kind() != reflect.Struct { | |
328 | panic("proto: type must have kind struct") | |
329 | } | |
330 | ||
331 | // Most calls to GetProperties in a long-running program will be | |
332 | // retrieving details for types we have seen before. | |
333 | propertiesMu.RLock() | |
334 | sprop, ok := propertiesMap[t] | |
335 | propertiesMu.RUnlock() | |
336 | if ok { | |
15c0b25d AP |
337 | return sprop |
338 | } | |
339 | ||
340 | propertiesMu.Lock() | |
341 | sprop = getPropertiesLocked(t) | |
342 | propertiesMu.Unlock() | |
343 | return sprop | |
344 | } | |
345 | ||
107c1cdb ND |
346 | type ( |
347 | oneofFuncsIface interface { | |
348 | XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{}) | |
349 | } | |
350 | oneofWrappersIface interface { | |
351 | XXX_OneofWrappers() []interface{} | |
352 | } | |
353 | ) | |
354 | ||
15c0b25d AP |
355 | // getPropertiesLocked requires that propertiesMu is held. |
356 | func getPropertiesLocked(t reflect.Type) *StructProperties { | |
357 | if prop, ok := propertiesMap[t]; ok { | |
15c0b25d AP |
358 | return prop |
359 | } | |
15c0b25d AP |
360 | |
361 | prop := new(StructProperties) | |
362 | // in case of recursive protos, fill this in now. | |
363 | propertiesMap[t] = prop | |
364 | ||
365 | // build properties | |
366 | prop.Prop = make([]*Properties, t.NumField()) | |
367 | prop.order = make([]int, t.NumField()) | |
368 | ||
369 | for i := 0; i < t.NumField(); i++ { | |
370 | f := t.Field(i) | |
371 | p := new(Properties) | |
372 | name := f.Name | |
373 | p.init(f.Type, name, f.Tag.Get("protobuf"), &f, false) | |
374 | ||
375 | oneof := f.Tag.Get("protobuf_oneof") // special case | |
376 | if oneof != "" { | |
377 | // Oneof fields don't use the traditional protobuf tag. | |
378 | p.OrigName = oneof | |
379 | } | |
380 | prop.Prop[i] = p | |
381 | prop.order[i] = i | |
382 | if debug { | |
383 | print(i, " ", f.Name, " ", t.String(), " ") | |
384 | if p.Tag > 0 { | |
385 | print(p.String()) | |
386 | } | |
387 | print("\n") | |
388 | } | |
389 | } | |
390 | ||
391 | // Re-order prop.order. | |
392 | sort.Sort(prop) | |
393 | ||
107c1cdb ND |
394 | var oots []interface{} |
395 | switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) { | |
396 | case oneofFuncsIface: | |
397 | _, _, _, oots = m.XXX_OneofFuncs() | |
398 | case oneofWrappersIface: | |
399 | oots = m.XXX_OneofWrappers() | |
15c0b25d | 400 | } |
107c1cdb | 401 | if len(oots) > 0 { |
15c0b25d AP |
402 | // Interpret oneof metadata. |
403 | prop.OneofTypes = make(map[string]*OneofProperties) | |
404 | for _, oot := range oots { | |
405 | oop := &OneofProperties{ | |
406 | Type: reflect.ValueOf(oot).Type(), // *T | |
407 | Prop: new(Properties), | |
408 | } | |
409 | sft := oop.Type.Elem().Field(0) | |
410 | oop.Prop.Name = sft.Name | |
411 | oop.Prop.Parse(sft.Tag.Get("protobuf")) | |
412 | // There will be exactly one interface field that | |
413 | // this new value is assignable to. | |
414 | for i := 0; i < t.NumField(); i++ { | |
415 | f := t.Field(i) | |
416 | if f.Type.Kind() != reflect.Interface { | |
417 | continue | |
418 | } | |
419 | if !oop.Type.AssignableTo(f.Type) { | |
420 | continue | |
421 | } | |
422 | oop.Field = i | |
423 | break | |
424 | } | |
425 | prop.OneofTypes[oop.Prop.OrigName] = oop | |
426 | } | |
427 | } | |
428 | ||
429 | // build required counts | |
430 | // build tags | |
431 | reqCount := 0 | |
432 | prop.decoderOrigNames = make(map[string]int) | |
433 | for i, p := range prop.Prop { | |
434 | if strings.HasPrefix(p.Name, "XXX_") { | |
435 | // Internal fields should not appear in tags/origNames maps. | |
436 | // They are handled specially when encoding and decoding. | |
437 | continue | |
438 | } | |
439 | if p.Required { | |
440 | reqCount++ | |
441 | } | |
442 | prop.decoderTags.put(p.Tag, i) | |
443 | prop.decoderOrigNames[p.OrigName] = i | |
444 | } | |
445 | prop.reqCount = reqCount | |
446 | ||
447 | return prop | |
448 | } | |
449 | ||
450 | // A global registry of enum types. | |
451 | // The generated code will register the generated maps by calling RegisterEnum. | |
452 | ||
453 | var enumValueMaps = make(map[string]map[string]int32) | |
454 | ||
455 | // RegisterEnum is called from the generated code to install the enum descriptor | |
456 | // maps into the global table to aid parsing text format protocol buffers. | |
457 | func RegisterEnum(typeName string, unusedNameMap map[int32]string, valueMap map[string]int32) { | |
458 | if _, ok := enumValueMaps[typeName]; ok { | |
459 | panic("proto: duplicate enum registered: " + typeName) | |
460 | } | |
461 | enumValueMaps[typeName] = valueMap | |
462 | } | |
463 | ||
464 | // EnumValueMap returns the mapping from names to integers of the | |
465 | // enum type enumType, or a nil if not found. | |
466 | func EnumValueMap(enumType string) map[string]int32 { | |
467 | return enumValueMaps[enumType] | |
468 | } | |
469 | ||
470 | // A registry of all linked message types. | |
471 | // The string is a fully-qualified proto name ("pkg.Message"). | |
472 | var ( | |
473 | protoTypedNils = make(map[string]Message) // a map from proto names to typed nil pointers | |
474 | protoMapTypes = make(map[string]reflect.Type) // a map from proto names to map types | |
475 | revProtoTypes = make(map[reflect.Type]string) | |
476 | ) | |
477 | ||
478 | // RegisterType is called from generated code and maps from the fully qualified | |
479 | // proto name to the type (pointer to struct) of the protocol buffer. | |
480 | func RegisterType(x Message, name string) { | |
481 | if _, ok := protoTypedNils[name]; ok { | |
482 | // TODO: Some day, make this a panic. | |
483 | log.Printf("proto: duplicate proto type registered: %s", name) | |
484 | return | |
485 | } | |
486 | t := reflect.TypeOf(x) | |
487 | if v := reflect.ValueOf(x); v.Kind() == reflect.Ptr && v.Pointer() == 0 { | |
488 | // Generated code always calls RegisterType with nil x. | |
489 | // This check is just for extra safety. | |
490 | protoTypedNils[name] = x | |
491 | } else { | |
492 | protoTypedNils[name] = reflect.Zero(t).Interface().(Message) | |
493 | } | |
494 | revProtoTypes[t] = name | |
495 | } | |
496 | ||
497 | // RegisterMapType is called from generated code and maps from the fully qualified | |
498 | // proto name to the native map type of the proto map definition. | |
499 | func RegisterMapType(x interface{}, name string) { | |
500 | if reflect.TypeOf(x).Kind() != reflect.Map { | |
501 | panic(fmt.Sprintf("RegisterMapType(%T, %q); want map", x, name)) | |
502 | } | |
503 | if _, ok := protoMapTypes[name]; ok { | |
504 | log.Printf("proto: duplicate proto type registered: %s", name) | |
505 | return | |
506 | } | |
507 | t := reflect.TypeOf(x) | |
508 | protoMapTypes[name] = t | |
509 | revProtoTypes[t] = name | |
510 | } | |
511 | ||
512 | // MessageName returns the fully-qualified proto name for the given message type. | |
513 | func MessageName(x Message) string { | |
514 | type xname interface { | |
515 | XXX_MessageName() string | |
516 | } | |
517 | if m, ok := x.(xname); ok { | |
518 | return m.XXX_MessageName() | |
519 | } | |
520 | return revProtoTypes[reflect.TypeOf(x)] | |
521 | } | |
522 | ||
523 | // MessageType returns the message type (pointer to struct) for a named message. | |
524 | // The type is not guaranteed to implement proto.Message if the name refers to a | |
525 | // map entry. | |
526 | func MessageType(name string) reflect.Type { | |
527 | if t, ok := protoTypedNils[name]; ok { | |
528 | return reflect.TypeOf(t) | |
529 | } | |
530 | return protoMapTypes[name] | |
531 | } | |
532 | ||
533 | // A registry of all linked proto files. | |
534 | var ( | |
535 | protoFiles = make(map[string][]byte) // file name => fileDescriptor | |
536 | ) | |
537 | ||
538 | // RegisterFile is called from generated code and maps from the | |
539 | // full file name of a .proto file to its compressed FileDescriptorProto. | |
540 | func RegisterFile(filename string, fileDescriptor []byte) { | |
541 | protoFiles[filename] = fileDescriptor | |
542 | } | |
543 | ||
544 | // FileDescriptor returns the compressed FileDescriptorProto for a .proto file. | |
545 | func FileDescriptor(filename string) []byte { return protoFiles[filename] } |