blob: acee2fc52964081b2201a7bf7049492e82b02c46 [file] [log] [blame]
mpagenko7d6bb022021-03-11 15:07:55 +00001// Go support for Protocol Buffers - Google's data interchange format
2//
3// Copyright 2016 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
32package proto
33
34import (
35 "errors"
36 "fmt"
37 "io"
38 "math"
39 "reflect"
40 "strconv"
41 "strings"
42 "sync"
43 "sync/atomic"
44 "unicode/utf8"
45)
46
47// Unmarshal is the entry point from the generated .pb.go files.
48// This function is not intended to be used by non-generated code.
49// This function is not subject to any compatibility guarantee.
50// msg contains a pointer to a protocol buffer struct.
51// b is the data to be unmarshaled into the protocol buffer.
52// a is a pointer to a place to store cached unmarshal information.
53func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {
54 // Load the unmarshal information for this message type.
55 // The atomic load ensures memory consistency.
56 u := atomicLoadUnmarshalInfo(&a.unmarshal)
57 if u == nil {
58 // Slow path: find unmarshal info for msg, update a with it.
59 u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())
60 atomicStoreUnmarshalInfo(&a.unmarshal, u)
61 }
62 // Then do the unmarshaling.
63 err := u.unmarshal(toPointer(&msg), b)
64 return err
65}
66
67type unmarshalInfo struct {
68 typ reflect.Type // type of the protobuf struct
69
70 // 0 = only typ field is initialized
71 // 1 = completely initialized
72 initialized int32
73 lock sync.Mutex // prevents double initialization
74 dense []unmarshalFieldInfo // fields indexed by tag #
75 sparse map[uint64]unmarshalFieldInfo // fields indexed by tag #
76 reqFields []string // names of required fields
77 reqMask uint64 // 1<<len(reqFields)-1
78 unrecognized field // offset of []byte to put unrecognized data (or invalidField if we should throw it away)
79 extensions field // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist
80 oldExtensions field // offset of old-form extensions field (of type map[int]Extension)
81 extensionRanges []ExtensionRange // if non-nil, implies extensions field is valid
82 isMessageSet bool // if true, implies extensions field is valid
83}
84
85// An unmarshaler takes a stream of bytes and a pointer to a field of a message.
86// It decodes the field, stores it at f, and returns the unused bytes.
87// w is the wire encoding.
88// b is the data after the tag and wire encoding have been read.
89type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)
90
91type unmarshalFieldInfo struct {
92 // location of the field in the proto message structure.
93 field field
94
95 // function to unmarshal the data for the field.
96 unmarshal unmarshaler
97
98 // if a required field, contains a single set bit at this field's index in the required field list.
99 reqMask uint64
100
101 name string // name of the field, for error reporting
102}
103
104var (
105 unmarshalInfoMap = map[reflect.Type]*unmarshalInfo{}
106 unmarshalInfoLock sync.Mutex
107)
108
109// getUnmarshalInfo returns the data structure which can be
110// subsequently used to unmarshal a message of the given type.
111// t is the type of the message (note: not pointer to message).
112func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {
113 // It would be correct to return a new unmarshalInfo
114 // unconditionally. We would end up allocating one
115 // per occurrence of that type as a message or submessage.
116 // We use a cache here just to reduce memory usage.
117 unmarshalInfoLock.Lock()
118 defer unmarshalInfoLock.Unlock()
119 u := unmarshalInfoMap[t]
120 if u == nil {
121 u = &unmarshalInfo{typ: t}
122 // Note: we just set the type here. The rest of the fields
123 // will be initialized on first use.
124 unmarshalInfoMap[t] = u
125 }
126 return u
127}
128
129// unmarshal does the main work of unmarshaling a message.
130// u provides type information used to unmarshal the message.
131// m is a pointer to a protocol buffer message.
132// b is a byte stream to unmarshal into m.
133// This is top routine used when recursively unmarshaling submessages.
134func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {
135 if atomic.LoadInt32(&u.initialized) == 0 {
136 u.computeUnmarshalInfo()
137 }
138 if u.isMessageSet {
139 return unmarshalMessageSet(b, m.offset(u.extensions).toExtensions())
140 }
141 var reqMask uint64 // bitmask of required fields we've seen.
142 var errLater error
143 for len(b) > 0 {
144 // Read tag and wire type.
145 // Special case 1 and 2 byte varints.
146 var x uint64
147 if b[0] < 128 {
148 x = uint64(b[0])
149 b = b[1:]
150 } else if len(b) >= 2 && b[1] < 128 {
151 x = uint64(b[0]&0x7f) + uint64(b[1])<<7
152 b = b[2:]
153 } else {
154 var n int
155 x, n = decodeVarint(b)
156 if n == 0 {
157 return io.ErrUnexpectedEOF
158 }
159 b = b[n:]
160 }
161 tag := x >> 3
162 wire := int(x) & 7
163
164 // Dispatch on the tag to one of the unmarshal* functions below.
165 var f unmarshalFieldInfo
166 if tag < uint64(len(u.dense)) {
167 f = u.dense[tag]
168 } else {
169 f = u.sparse[tag]
170 }
171 if fn := f.unmarshal; fn != nil {
172 var err error
173 b, err = fn(b, m.offset(f.field), wire)
174 if err == nil {
175 reqMask |= f.reqMask
176 continue
177 }
178 if r, ok := err.(*RequiredNotSetError); ok {
179 // Remember this error, but keep parsing. We need to produce
180 // a full parse even if a required field is missing.
181 if errLater == nil {
182 errLater = r
183 }
184 reqMask |= f.reqMask
185 continue
186 }
187 if err != errInternalBadWireType {
188 if err == errInvalidUTF8 {
189 if errLater == nil {
190 fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
191 errLater = &invalidUTF8Error{fullName}
192 }
193 continue
194 }
195 return err
196 }
197 // Fragments with bad wire type are treated as unknown fields.
198 }
199
200 // Unknown tag.
201 if !u.unrecognized.IsValid() {
202 // Don't keep unrecognized data; just skip it.
203 var err error
204 b, err = skipField(b, wire)
205 if err != nil {
206 return err
207 }
208 continue
209 }
210 // Keep unrecognized data around.
211 // maybe in extensions, maybe in the unrecognized field.
212 z := m.offset(u.unrecognized).toBytes()
213 var emap map[int32]Extension
214 var e Extension
215 for _, r := range u.extensionRanges {
216 if uint64(r.Start) <= tag && tag <= uint64(r.End) {
217 if u.extensions.IsValid() {
218 mp := m.offset(u.extensions).toExtensions()
219 emap = mp.extensionsWrite()
220 e = emap[int32(tag)]
221 z = &e.enc
222 break
223 }
224 if u.oldExtensions.IsValid() {
225 p := m.offset(u.oldExtensions).toOldExtensions()
226 emap = *p
227 if emap == nil {
228 emap = map[int32]Extension{}
229 *p = emap
230 }
231 e = emap[int32(tag)]
232 z = &e.enc
233 break
234 }
235 panic("no extensions field available")
236 }
237 }
238
239 // Use wire type to skip data.
240 var err error
241 b0 := b
242 b, err = skipField(b, wire)
243 if err != nil {
244 return err
245 }
246 *z = encodeVarint(*z, tag<<3|uint64(wire))
247 *z = append(*z, b0[:len(b0)-len(b)]...)
248
249 if emap != nil {
250 emap[int32(tag)] = e
251 }
252 }
253 if reqMask != u.reqMask && errLater == nil {
254 // A required field of this message is missing.
255 for _, n := range u.reqFields {
256 if reqMask&1 == 0 {
257 errLater = &RequiredNotSetError{n}
258 }
259 reqMask >>= 1
260 }
261 }
262 return errLater
263}
264
265// computeUnmarshalInfo fills in u with information for use
266// in unmarshaling protocol buffers of type u.typ.
267func (u *unmarshalInfo) computeUnmarshalInfo() {
268 u.lock.Lock()
269 defer u.lock.Unlock()
270 if u.initialized != 0 {
271 return
272 }
273 t := u.typ
274 n := t.NumField()
275
276 // Set up the "not found" value for the unrecognized byte buffer.
277 // This is the default for proto3.
278 u.unrecognized = invalidField
279 u.extensions = invalidField
280 u.oldExtensions = invalidField
281
282 // List of the generated type and offset for each oneof field.
283 type oneofField struct {
284 ityp reflect.Type // interface type of oneof field
285 field field // offset in containing message
286 }
287 var oneofFields []oneofField
288
289 for i := 0; i < n; i++ {
290 f := t.Field(i)
291 if f.Name == "XXX_unrecognized" {
292 // The byte slice used to hold unrecognized input is special.
293 if f.Type != reflect.TypeOf(([]byte)(nil)) {
294 panic("bad type for XXX_unrecognized field: " + f.Type.Name())
295 }
296 u.unrecognized = toField(&f)
297 continue
298 }
299 if f.Name == "XXX_InternalExtensions" {
300 // Ditto here.
301 if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {
302 panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())
303 }
304 u.extensions = toField(&f)
305 if f.Tag.Get("protobuf_messageset") == "1" {
306 u.isMessageSet = true
307 }
308 continue
309 }
310 if f.Name == "XXX_extensions" {
311 // An older form of the extensions field.
312 if f.Type != reflect.TypeOf((map[int32]Extension)(nil)) {
313 panic("bad type for XXX_extensions field: " + f.Type.Name())
314 }
315 u.oldExtensions = toField(&f)
316 continue
317 }
318 if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {
319 continue
320 }
321
322 oneof := f.Tag.Get("protobuf_oneof")
323 if oneof != "" {
324 oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})
325 // The rest of oneof processing happens below.
326 continue
327 }
328
329 tags := f.Tag.Get("protobuf")
330 tagArray := strings.Split(tags, ",")
331 if len(tagArray) < 2 {
332 panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)
333 }
334 tag, err := strconv.Atoi(tagArray[1])
335 if err != nil {
336 panic("protobuf tag field not an integer: " + tagArray[1])
337 }
338
339 name := ""
340 for _, tag := range tagArray[3:] {
341 if strings.HasPrefix(tag, "name=") {
342 name = tag[5:]
343 }
344 }
345
346 // Extract unmarshaling function from the field (its type and tags).
347 unmarshal := fieldUnmarshaler(&f)
348
349 // Required field?
350 var reqMask uint64
351 if tagArray[2] == "req" {
352 bit := len(u.reqFields)
353 u.reqFields = append(u.reqFields, name)
354 reqMask = uint64(1) << uint(bit)
355 // TODO: if we have more than 64 required fields, we end up
356 // not verifying that all required fields are present.
357 // Fix this, perhaps using a count of required fields?
358 }
359
360 // Store the info in the correct slot in the message.
361 u.setTag(tag, toField(&f), unmarshal, reqMask, name)
362 }
363
364 // Find any types associated with oneof fields.
365 var oneofImplementers []interface{}
366 switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
367 case oneofFuncsIface:
368 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
369 case oneofWrappersIface:
370 oneofImplementers = m.XXX_OneofWrappers()
371 }
372 for _, v := range oneofImplementers {
373 tptr := reflect.TypeOf(v) // *Msg_X
374 typ := tptr.Elem() // Msg_X
375
376 f := typ.Field(0) // oneof implementers have one field
377 baseUnmarshal := fieldUnmarshaler(&f)
378 tags := strings.Split(f.Tag.Get("protobuf"), ",")
379 fieldNum, err := strconv.Atoi(tags[1])
380 if err != nil {
381 panic("protobuf tag field not an integer: " + tags[1])
382 }
383 var name string
384 for _, tag := range tags {
385 if strings.HasPrefix(tag, "name=") {
386 name = strings.TrimPrefix(tag, "name=")
387 break
388 }
389 }
390
391 // Find the oneof field that this struct implements.
392 // Might take O(n^2) to process all of the oneofs, but who cares.
393 for _, of := range oneofFields {
394 if tptr.Implements(of.ityp) {
395 // We have found the corresponding interface for this struct.
396 // That lets us know where this struct should be stored
397 // when we encounter it during unmarshaling.
398 unmarshal := makeUnmarshalOneof(typ, of.ityp, baseUnmarshal)
399 u.setTag(fieldNum, of.field, unmarshal, 0, name)
400 }
401 }
402
403 }
404
405 // Get extension ranges, if any.
406 fn := reflect.Zero(reflect.PtrTo(t)).MethodByName("ExtensionRangeArray")
407 if fn.IsValid() {
408 if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {
409 panic("a message with extensions, but no extensions field in " + t.Name())
410 }
411 u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)
412 }
413
414 // Explicitly disallow tag 0. This will ensure we flag an error
415 // when decoding a buffer of all zeros. Without this code, we
416 // would decode and skip an all-zero buffer of even length.
417 // [0 0] is [tag=0/wiretype=varint varint-encoded-0].
418 u.setTag(0, zeroField, func(b []byte, f pointer, w int) ([]byte, error) {
419 return nil, fmt.Errorf("proto: %s: illegal tag 0 (wire type %d)", t, w)
420 }, 0, "")
421
422 // Set mask for required field check.
423 u.reqMask = uint64(1)<<uint(len(u.reqFields)) - 1
424
425 atomic.StoreInt32(&u.initialized, 1)
426}
427
428// setTag stores the unmarshal information for the given tag.
429// tag = tag # for field
430// field/unmarshal = unmarshal info for that field.
431// reqMask = if required, bitmask for field position in required field list. 0 otherwise.
432// name = short name of the field.
433func (u *unmarshalInfo) setTag(tag int, field field, unmarshal unmarshaler, reqMask uint64, name string) {
434 i := unmarshalFieldInfo{field: field, unmarshal: unmarshal, reqMask: reqMask, name: name}
435 n := u.typ.NumField()
436 if tag >= 0 && (tag < 16 || tag < 2*n) { // TODO: what are the right numbers here?
437 for len(u.dense) <= tag {
438 u.dense = append(u.dense, unmarshalFieldInfo{})
439 }
440 u.dense[tag] = i
441 return
442 }
443 if u.sparse == nil {
444 u.sparse = map[uint64]unmarshalFieldInfo{}
445 }
446 u.sparse[uint64(tag)] = i
447}
448
449// fieldUnmarshaler returns an unmarshaler for the given field.
450func fieldUnmarshaler(f *reflect.StructField) unmarshaler {
451 if f.Type.Kind() == reflect.Map {
452 return makeUnmarshalMap(f)
453 }
454 return typeUnmarshaler(f.Type, f.Tag.Get("protobuf"))
455}
456
457// typeUnmarshaler returns an unmarshaler for the given field type / field tag pair.
458func typeUnmarshaler(t reflect.Type, tags string) unmarshaler {
459 tagArray := strings.Split(tags, ",")
460 encoding := tagArray[0]
461 name := "unknown"
462 proto3 := false
463 validateUTF8 := true
464 for _, tag := range tagArray[3:] {
465 if strings.HasPrefix(tag, "name=") {
466 name = tag[5:]
467 }
468 if tag == "proto3" {
469 proto3 = true
470 }
471 }
472 validateUTF8 = validateUTF8 && proto3
473
474 // Figure out packaging (pointer, slice, or both)
475 slice := false
476 pointer := false
477 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
478 slice = true
479 t = t.Elem()
480 }
481 if t.Kind() == reflect.Ptr {
482 pointer = true
483 t = t.Elem()
484 }
485
486 // We'll never have both pointer and slice for basic types.
487 if pointer && slice && t.Kind() != reflect.Struct {
488 panic("both pointer and slice for basic type in " + t.Name())
489 }
490
491 switch t.Kind() {
492 case reflect.Bool:
493 if pointer {
494 return unmarshalBoolPtr
495 }
496 if slice {
497 return unmarshalBoolSlice
498 }
499 return unmarshalBoolValue
500 case reflect.Int32:
501 switch encoding {
502 case "fixed32":
503 if pointer {
504 return unmarshalFixedS32Ptr
505 }
506 if slice {
507 return unmarshalFixedS32Slice
508 }
509 return unmarshalFixedS32Value
510 case "varint":
511 // this could be int32 or enum
512 if pointer {
513 return unmarshalInt32Ptr
514 }
515 if slice {
516 return unmarshalInt32Slice
517 }
518 return unmarshalInt32Value
519 case "zigzag32":
520 if pointer {
521 return unmarshalSint32Ptr
522 }
523 if slice {
524 return unmarshalSint32Slice
525 }
526 return unmarshalSint32Value
527 }
528 case reflect.Int64:
529 switch encoding {
530 case "fixed64":
531 if pointer {
532 return unmarshalFixedS64Ptr
533 }
534 if slice {
535 return unmarshalFixedS64Slice
536 }
537 return unmarshalFixedS64Value
538 case "varint":
539 if pointer {
540 return unmarshalInt64Ptr
541 }
542 if slice {
543 return unmarshalInt64Slice
544 }
545 return unmarshalInt64Value
546 case "zigzag64":
547 if pointer {
548 return unmarshalSint64Ptr
549 }
550 if slice {
551 return unmarshalSint64Slice
552 }
553 return unmarshalSint64Value
554 }
555 case reflect.Uint32:
556 switch encoding {
557 case "fixed32":
558 if pointer {
559 return unmarshalFixed32Ptr
560 }
561 if slice {
562 return unmarshalFixed32Slice
563 }
564 return unmarshalFixed32Value
565 case "varint":
566 if pointer {
567 return unmarshalUint32Ptr
568 }
569 if slice {
570 return unmarshalUint32Slice
571 }
572 return unmarshalUint32Value
573 }
574 case reflect.Uint64:
575 switch encoding {
576 case "fixed64":
577 if pointer {
578 return unmarshalFixed64Ptr
579 }
580 if slice {
581 return unmarshalFixed64Slice
582 }
583 return unmarshalFixed64Value
584 case "varint":
585 if pointer {
586 return unmarshalUint64Ptr
587 }
588 if slice {
589 return unmarshalUint64Slice
590 }
591 return unmarshalUint64Value
592 }
593 case reflect.Float32:
594 if pointer {
595 return unmarshalFloat32Ptr
596 }
597 if slice {
598 return unmarshalFloat32Slice
599 }
600 return unmarshalFloat32Value
601 case reflect.Float64:
602 if pointer {
603 return unmarshalFloat64Ptr
604 }
605 if slice {
606 return unmarshalFloat64Slice
607 }
608 return unmarshalFloat64Value
609 case reflect.Map:
610 panic("map type in typeUnmarshaler in " + t.Name())
611 case reflect.Slice:
612 if pointer {
613 panic("bad pointer in slice case in " + t.Name())
614 }
615 if slice {
616 return unmarshalBytesSlice
617 }
618 return unmarshalBytesValue
619 case reflect.String:
620 if validateUTF8 {
621 if pointer {
622 return unmarshalUTF8StringPtr
623 }
624 if slice {
625 return unmarshalUTF8StringSlice
626 }
627 return unmarshalUTF8StringValue
628 }
629 if pointer {
630 return unmarshalStringPtr
631 }
632 if slice {
633 return unmarshalStringSlice
634 }
635 return unmarshalStringValue
636 case reflect.Struct:
637 // message or group field
638 if !pointer {
639 panic(fmt.Sprintf("message/group field %s:%s without pointer", t, encoding))
640 }
641 switch encoding {
642 case "bytes":
643 if slice {
644 return makeUnmarshalMessageSlicePtr(getUnmarshalInfo(t), name)
645 }
646 return makeUnmarshalMessagePtr(getUnmarshalInfo(t), name)
647 case "group":
648 if slice {
649 return makeUnmarshalGroupSlicePtr(getUnmarshalInfo(t), name)
650 }
651 return makeUnmarshalGroupPtr(getUnmarshalInfo(t), name)
652 }
653 }
654 panic(fmt.Sprintf("unmarshaler not found type:%s encoding:%s", t, encoding))
655}
656
657// Below are all the unmarshalers for individual fields of various types.
658
659func unmarshalInt64Value(b []byte, f pointer, w int) ([]byte, error) {
660 if w != WireVarint {
661 return b, errInternalBadWireType
662 }
663 x, n := decodeVarint(b)
664 if n == 0 {
665 return nil, io.ErrUnexpectedEOF
666 }
667 b = b[n:]
668 v := int64(x)
669 *f.toInt64() = v
670 return b, nil
671}
672
673func unmarshalInt64Ptr(b []byte, f pointer, w int) ([]byte, error) {
674 if w != WireVarint {
675 return b, errInternalBadWireType
676 }
677 x, n := decodeVarint(b)
678 if n == 0 {
679 return nil, io.ErrUnexpectedEOF
680 }
681 b = b[n:]
682 v := int64(x)
683 *f.toInt64Ptr() = &v
684 return b, nil
685}
686
687func unmarshalInt64Slice(b []byte, f pointer, w int) ([]byte, error) {
688 if w == WireBytes { // packed
689 x, n := decodeVarint(b)
690 if n == 0 {
691 return nil, io.ErrUnexpectedEOF
692 }
693 b = b[n:]
694 if x > uint64(len(b)) {
695 return nil, io.ErrUnexpectedEOF
696 }
697 res := b[x:]
698 b = b[:x]
699 for len(b) > 0 {
700 x, n = decodeVarint(b)
701 if n == 0 {
702 return nil, io.ErrUnexpectedEOF
703 }
704 b = b[n:]
705 v := int64(x)
706 s := f.toInt64Slice()
707 *s = append(*s, v)
708 }
709 return res, nil
710 }
711 if w != WireVarint {
712 return b, errInternalBadWireType
713 }
714 x, n := decodeVarint(b)
715 if n == 0 {
716 return nil, io.ErrUnexpectedEOF
717 }
718 b = b[n:]
719 v := int64(x)
720 s := f.toInt64Slice()
721 *s = append(*s, v)
722 return b, nil
723}
724
725func unmarshalSint64Value(b []byte, f pointer, w int) ([]byte, error) {
726 if w != WireVarint {
727 return b, errInternalBadWireType
728 }
729 x, n := decodeVarint(b)
730 if n == 0 {
731 return nil, io.ErrUnexpectedEOF
732 }
733 b = b[n:]
734 v := int64(x>>1) ^ int64(x)<<63>>63
735 *f.toInt64() = v
736 return b, nil
737}
738
739func unmarshalSint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
740 if w != WireVarint {
741 return b, errInternalBadWireType
742 }
743 x, n := decodeVarint(b)
744 if n == 0 {
745 return nil, io.ErrUnexpectedEOF
746 }
747 b = b[n:]
748 v := int64(x>>1) ^ int64(x)<<63>>63
749 *f.toInt64Ptr() = &v
750 return b, nil
751}
752
753func unmarshalSint64Slice(b []byte, f pointer, w int) ([]byte, error) {
754 if w == WireBytes { // packed
755 x, n := decodeVarint(b)
756 if n == 0 {
757 return nil, io.ErrUnexpectedEOF
758 }
759 b = b[n:]
760 if x > uint64(len(b)) {
761 return nil, io.ErrUnexpectedEOF
762 }
763 res := b[x:]
764 b = b[:x]
765 for len(b) > 0 {
766 x, n = decodeVarint(b)
767 if n == 0 {
768 return nil, io.ErrUnexpectedEOF
769 }
770 b = b[n:]
771 v := int64(x>>1) ^ int64(x)<<63>>63
772 s := f.toInt64Slice()
773 *s = append(*s, v)
774 }
775 return res, nil
776 }
777 if w != WireVarint {
778 return b, errInternalBadWireType
779 }
780 x, n := decodeVarint(b)
781 if n == 0 {
782 return nil, io.ErrUnexpectedEOF
783 }
784 b = b[n:]
785 v := int64(x>>1) ^ int64(x)<<63>>63
786 s := f.toInt64Slice()
787 *s = append(*s, v)
788 return b, nil
789}
790
791func unmarshalUint64Value(b []byte, f pointer, w int) ([]byte, error) {
792 if w != WireVarint {
793 return b, errInternalBadWireType
794 }
795 x, n := decodeVarint(b)
796 if n == 0 {
797 return nil, io.ErrUnexpectedEOF
798 }
799 b = b[n:]
800 v := uint64(x)
801 *f.toUint64() = v
802 return b, nil
803}
804
805func unmarshalUint64Ptr(b []byte, f pointer, w int) ([]byte, error) {
806 if w != WireVarint {
807 return b, errInternalBadWireType
808 }
809 x, n := decodeVarint(b)
810 if n == 0 {
811 return nil, io.ErrUnexpectedEOF
812 }
813 b = b[n:]
814 v := uint64(x)
815 *f.toUint64Ptr() = &v
816 return b, nil
817}
818
819func unmarshalUint64Slice(b []byte, f pointer, w int) ([]byte, error) {
820 if w == WireBytes { // packed
821 x, n := decodeVarint(b)
822 if n == 0 {
823 return nil, io.ErrUnexpectedEOF
824 }
825 b = b[n:]
826 if x > uint64(len(b)) {
827 return nil, io.ErrUnexpectedEOF
828 }
829 res := b[x:]
830 b = b[:x]
831 for len(b) > 0 {
832 x, n = decodeVarint(b)
833 if n == 0 {
834 return nil, io.ErrUnexpectedEOF
835 }
836 b = b[n:]
837 v := uint64(x)
838 s := f.toUint64Slice()
839 *s = append(*s, v)
840 }
841 return res, nil
842 }
843 if w != WireVarint {
844 return b, errInternalBadWireType
845 }
846 x, n := decodeVarint(b)
847 if n == 0 {
848 return nil, io.ErrUnexpectedEOF
849 }
850 b = b[n:]
851 v := uint64(x)
852 s := f.toUint64Slice()
853 *s = append(*s, v)
854 return b, nil
855}
856
857func unmarshalInt32Value(b []byte, f pointer, w int) ([]byte, error) {
858 if w != WireVarint {
859 return b, errInternalBadWireType
860 }
861 x, n := decodeVarint(b)
862 if n == 0 {
863 return nil, io.ErrUnexpectedEOF
864 }
865 b = b[n:]
866 v := int32(x)
867 *f.toInt32() = v
868 return b, nil
869}
870
871func unmarshalInt32Ptr(b []byte, f pointer, w int) ([]byte, error) {
872 if w != WireVarint {
873 return b, errInternalBadWireType
874 }
875 x, n := decodeVarint(b)
876 if n == 0 {
877 return nil, io.ErrUnexpectedEOF
878 }
879 b = b[n:]
880 v := int32(x)
881 f.setInt32Ptr(v)
882 return b, nil
883}
884
885func unmarshalInt32Slice(b []byte, f pointer, w int) ([]byte, error) {
886 if w == WireBytes { // packed
887 x, n := decodeVarint(b)
888 if n == 0 {
889 return nil, io.ErrUnexpectedEOF
890 }
891 b = b[n:]
892 if x > uint64(len(b)) {
893 return nil, io.ErrUnexpectedEOF
894 }
895 res := b[x:]
896 b = b[:x]
897 for len(b) > 0 {
898 x, n = decodeVarint(b)
899 if n == 0 {
900 return nil, io.ErrUnexpectedEOF
901 }
902 b = b[n:]
903 v := int32(x)
904 f.appendInt32Slice(v)
905 }
906 return res, nil
907 }
908 if w != WireVarint {
909 return b, errInternalBadWireType
910 }
911 x, n := decodeVarint(b)
912 if n == 0 {
913 return nil, io.ErrUnexpectedEOF
914 }
915 b = b[n:]
916 v := int32(x)
917 f.appendInt32Slice(v)
918 return b, nil
919}
920
921func unmarshalSint32Value(b []byte, f pointer, w int) ([]byte, error) {
922 if w != WireVarint {
923 return b, errInternalBadWireType
924 }
925 x, n := decodeVarint(b)
926 if n == 0 {
927 return nil, io.ErrUnexpectedEOF
928 }
929 b = b[n:]
930 v := int32(x>>1) ^ int32(x)<<31>>31
931 *f.toInt32() = v
932 return b, nil
933}
934
935func unmarshalSint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
936 if w != WireVarint {
937 return b, errInternalBadWireType
938 }
939 x, n := decodeVarint(b)
940 if n == 0 {
941 return nil, io.ErrUnexpectedEOF
942 }
943 b = b[n:]
944 v := int32(x>>1) ^ int32(x)<<31>>31
945 f.setInt32Ptr(v)
946 return b, nil
947}
948
949func unmarshalSint32Slice(b []byte, f pointer, w int) ([]byte, error) {
950 if w == WireBytes { // packed
951 x, n := decodeVarint(b)
952 if n == 0 {
953 return nil, io.ErrUnexpectedEOF
954 }
955 b = b[n:]
956 if x > uint64(len(b)) {
957 return nil, io.ErrUnexpectedEOF
958 }
959 res := b[x:]
960 b = b[:x]
961 for len(b) > 0 {
962 x, n = decodeVarint(b)
963 if n == 0 {
964 return nil, io.ErrUnexpectedEOF
965 }
966 b = b[n:]
967 v := int32(x>>1) ^ int32(x)<<31>>31
968 f.appendInt32Slice(v)
969 }
970 return res, nil
971 }
972 if w != WireVarint {
973 return b, errInternalBadWireType
974 }
975 x, n := decodeVarint(b)
976 if n == 0 {
977 return nil, io.ErrUnexpectedEOF
978 }
979 b = b[n:]
980 v := int32(x>>1) ^ int32(x)<<31>>31
981 f.appendInt32Slice(v)
982 return b, nil
983}
984
985func unmarshalUint32Value(b []byte, f pointer, w int) ([]byte, error) {
986 if w != WireVarint {
987 return b, errInternalBadWireType
988 }
989 x, n := decodeVarint(b)
990 if n == 0 {
991 return nil, io.ErrUnexpectedEOF
992 }
993 b = b[n:]
994 v := uint32(x)
995 *f.toUint32() = v
996 return b, nil
997}
998
999func unmarshalUint32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1000 if w != WireVarint {
1001 return b, errInternalBadWireType
1002 }
1003 x, n := decodeVarint(b)
1004 if n == 0 {
1005 return nil, io.ErrUnexpectedEOF
1006 }
1007 b = b[n:]
1008 v := uint32(x)
1009 *f.toUint32Ptr() = &v
1010 return b, nil
1011}
1012
1013func unmarshalUint32Slice(b []byte, f pointer, w int) ([]byte, error) {
1014 if w == WireBytes { // packed
1015 x, n := decodeVarint(b)
1016 if n == 0 {
1017 return nil, io.ErrUnexpectedEOF
1018 }
1019 b = b[n:]
1020 if x > uint64(len(b)) {
1021 return nil, io.ErrUnexpectedEOF
1022 }
1023 res := b[x:]
1024 b = b[:x]
1025 for len(b) > 0 {
1026 x, n = decodeVarint(b)
1027 if n == 0 {
1028 return nil, io.ErrUnexpectedEOF
1029 }
1030 b = b[n:]
1031 v := uint32(x)
1032 s := f.toUint32Slice()
1033 *s = append(*s, v)
1034 }
1035 return res, nil
1036 }
1037 if w != WireVarint {
1038 return b, errInternalBadWireType
1039 }
1040 x, n := decodeVarint(b)
1041 if n == 0 {
1042 return nil, io.ErrUnexpectedEOF
1043 }
1044 b = b[n:]
1045 v := uint32(x)
1046 s := f.toUint32Slice()
1047 *s = append(*s, v)
1048 return b, nil
1049}
1050
1051func unmarshalFixed64Value(b []byte, f pointer, w int) ([]byte, error) {
1052 if w != WireFixed64 {
1053 return b, errInternalBadWireType
1054 }
1055 if len(b) < 8 {
1056 return nil, io.ErrUnexpectedEOF
1057 }
1058 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1059 *f.toUint64() = v
1060 return b[8:], nil
1061}
1062
1063func unmarshalFixed64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1064 if w != WireFixed64 {
1065 return b, errInternalBadWireType
1066 }
1067 if len(b) < 8 {
1068 return nil, io.ErrUnexpectedEOF
1069 }
1070 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1071 *f.toUint64Ptr() = &v
1072 return b[8:], nil
1073}
1074
1075func unmarshalFixed64Slice(b []byte, f pointer, w int) ([]byte, error) {
1076 if w == WireBytes { // packed
1077 x, n := decodeVarint(b)
1078 if n == 0 {
1079 return nil, io.ErrUnexpectedEOF
1080 }
1081 b = b[n:]
1082 if x > uint64(len(b)) {
1083 return nil, io.ErrUnexpectedEOF
1084 }
1085 res := b[x:]
1086 b = b[:x]
1087 for len(b) > 0 {
1088 if len(b) < 8 {
1089 return nil, io.ErrUnexpectedEOF
1090 }
1091 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1092 s := f.toUint64Slice()
1093 *s = append(*s, v)
1094 b = b[8:]
1095 }
1096 return res, nil
1097 }
1098 if w != WireFixed64 {
1099 return b, errInternalBadWireType
1100 }
1101 if len(b) < 8 {
1102 return nil, io.ErrUnexpectedEOF
1103 }
1104 v := uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56
1105 s := f.toUint64Slice()
1106 *s = append(*s, v)
1107 return b[8:], nil
1108}
1109
1110func unmarshalFixedS64Value(b []byte, f pointer, w int) ([]byte, error) {
1111 if w != WireFixed64 {
1112 return b, errInternalBadWireType
1113 }
1114 if len(b) < 8 {
1115 return nil, io.ErrUnexpectedEOF
1116 }
1117 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1118 *f.toInt64() = v
1119 return b[8:], nil
1120}
1121
1122func unmarshalFixedS64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1123 if w != WireFixed64 {
1124 return b, errInternalBadWireType
1125 }
1126 if len(b) < 8 {
1127 return nil, io.ErrUnexpectedEOF
1128 }
1129 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1130 *f.toInt64Ptr() = &v
1131 return b[8:], nil
1132}
1133
1134func unmarshalFixedS64Slice(b []byte, f pointer, w int) ([]byte, error) {
1135 if w == WireBytes { // packed
1136 x, n := decodeVarint(b)
1137 if n == 0 {
1138 return nil, io.ErrUnexpectedEOF
1139 }
1140 b = b[n:]
1141 if x > uint64(len(b)) {
1142 return nil, io.ErrUnexpectedEOF
1143 }
1144 res := b[x:]
1145 b = b[:x]
1146 for len(b) > 0 {
1147 if len(b) < 8 {
1148 return nil, io.ErrUnexpectedEOF
1149 }
1150 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1151 s := f.toInt64Slice()
1152 *s = append(*s, v)
1153 b = b[8:]
1154 }
1155 return res, nil
1156 }
1157 if w != WireFixed64 {
1158 return b, errInternalBadWireType
1159 }
1160 if len(b) < 8 {
1161 return nil, io.ErrUnexpectedEOF
1162 }
1163 v := int64(b[0]) | int64(b[1])<<8 | int64(b[2])<<16 | int64(b[3])<<24 | int64(b[4])<<32 | int64(b[5])<<40 | int64(b[6])<<48 | int64(b[7])<<56
1164 s := f.toInt64Slice()
1165 *s = append(*s, v)
1166 return b[8:], nil
1167}
1168
1169func unmarshalFixed32Value(b []byte, f pointer, w int) ([]byte, error) {
1170 if w != WireFixed32 {
1171 return b, errInternalBadWireType
1172 }
1173 if len(b) < 4 {
1174 return nil, io.ErrUnexpectedEOF
1175 }
1176 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1177 *f.toUint32() = v
1178 return b[4:], nil
1179}
1180
1181func unmarshalFixed32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1182 if w != WireFixed32 {
1183 return b, errInternalBadWireType
1184 }
1185 if len(b) < 4 {
1186 return nil, io.ErrUnexpectedEOF
1187 }
1188 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1189 *f.toUint32Ptr() = &v
1190 return b[4:], nil
1191}
1192
1193func unmarshalFixed32Slice(b []byte, f pointer, w int) ([]byte, error) {
1194 if w == WireBytes { // packed
1195 x, n := decodeVarint(b)
1196 if n == 0 {
1197 return nil, io.ErrUnexpectedEOF
1198 }
1199 b = b[n:]
1200 if x > uint64(len(b)) {
1201 return nil, io.ErrUnexpectedEOF
1202 }
1203 res := b[x:]
1204 b = b[:x]
1205 for len(b) > 0 {
1206 if len(b) < 4 {
1207 return nil, io.ErrUnexpectedEOF
1208 }
1209 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1210 s := f.toUint32Slice()
1211 *s = append(*s, v)
1212 b = b[4:]
1213 }
1214 return res, nil
1215 }
1216 if w != WireFixed32 {
1217 return b, errInternalBadWireType
1218 }
1219 if len(b) < 4 {
1220 return nil, io.ErrUnexpectedEOF
1221 }
1222 v := uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
1223 s := f.toUint32Slice()
1224 *s = append(*s, v)
1225 return b[4:], nil
1226}
1227
1228func unmarshalFixedS32Value(b []byte, f pointer, w int) ([]byte, error) {
1229 if w != WireFixed32 {
1230 return b, errInternalBadWireType
1231 }
1232 if len(b) < 4 {
1233 return nil, io.ErrUnexpectedEOF
1234 }
1235 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1236 *f.toInt32() = v
1237 return b[4:], nil
1238}
1239
1240func unmarshalFixedS32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1241 if w != WireFixed32 {
1242 return b, errInternalBadWireType
1243 }
1244 if len(b) < 4 {
1245 return nil, io.ErrUnexpectedEOF
1246 }
1247 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1248 f.setInt32Ptr(v)
1249 return b[4:], nil
1250}
1251
1252func unmarshalFixedS32Slice(b []byte, f pointer, w int) ([]byte, error) {
1253 if w == WireBytes { // packed
1254 x, n := decodeVarint(b)
1255 if n == 0 {
1256 return nil, io.ErrUnexpectedEOF
1257 }
1258 b = b[n:]
1259 if x > uint64(len(b)) {
1260 return nil, io.ErrUnexpectedEOF
1261 }
1262 res := b[x:]
1263 b = b[:x]
1264 for len(b) > 0 {
1265 if len(b) < 4 {
1266 return nil, io.ErrUnexpectedEOF
1267 }
1268 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1269 f.appendInt32Slice(v)
1270 b = b[4:]
1271 }
1272 return res, nil
1273 }
1274 if w != WireFixed32 {
1275 return b, errInternalBadWireType
1276 }
1277 if len(b) < 4 {
1278 return nil, io.ErrUnexpectedEOF
1279 }
1280 v := int32(b[0]) | int32(b[1])<<8 | int32(b[2])<<16 | int32(b[3])<<24
1281 f.appendInt32Slice(v)
1282 return b[4:], nil
1283}
1284
1285func unmarshalBoolValue(b []byte, f pointer, w int) ([]byte, error) {
1286 if w != WireVarint {
1287 return b, errInternalBadWireType
1288 }
1289 // Note: any length varint is allowed, even though any sane
1290 // encoder will use one byte.
1291 // See https://github.com/golang/protobuf/issues/76
1292 x, n := decodeVarint(b)
1293 if n == 0 {
1294 return nil, io.ErrUnexpectedEOF
1295 }
1296 // TODO: check if x>1? Tests seem to indicate no.
1297 v := x != 0
1298 *f.toBool() = v
1299 return b[n:], nil
1300}
1301
1302func unmarshalBoolPtr(b []byte, f pointer, w int) ([]byte, error) {
1303 if w != WireVarint {
1304 return b, errInternalBadWireType
1305 }
1306 x, n := decodeVarint(b)
1307 if n == 0 {
1308 return nil, io.ErrUnexpectedEOF
1309 }
1310 v := x != 0
1311 *f.toBoolPtr() = &v
1312 return b[n:], nil
1313}
1314
1315func unmarshalBoolSlice(b []byte, f pointer, w int) ([]byte, error) {
1316 if w == WireBytes { // packed
1317 x, n := decodeVarint(b)
1318 if n == 0 {
1319 return nil, io.ErrUnexpectedEOF
1320 }
1321 b = b[n:]
1322 if x > uint64(len(b)) {
1323 return nil, io.ErrUnexpectedEOF
1324 }
1325 res := b[x:]
1326 b = b[:x]
1327 for len(b) > 0 {
1328 x, n = decodeVarint(b)
1329 if n == 0 {
1330 return nil, io.ErrUnexpectedEOF
1331 }
1332 v := x != 0
1333 s := f.toBoolSlice()
1334 *s = append(*s, v)
1335 b = b[n:]
1336 }
1337 return res, nil
1338 }
1339 if w != WireVarint {
1340 return b, errInternalBadWireType
1341 }
1342 x, n := decodeVarint(b)
1343 if n == 0 {
1344 return nil, io.ErrUnexpectedEOF
1345 }
1346 v := x != 0
1347 s := f.toBoolSlice()
1348 *s = append(*s, v)
1349 return b[n:], nil
1350}
1351
1352func unmarshalFloat64Value(b []byte, f pointer, w int) ([]byte, error) {
1353 if w != WireFixed64 {
1354 return b, errInternalBadWireType
1355 }
1356 if len(b) < 8 {
1357 return nil, io.ErrUnexpectedEOF
1358 }
1359 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1360 *f.toFloat64() = v
1361 return b[8:], nil
1362}
1363
1364func unmarshalFloat64Ptr(b []byte, f pointer, w int) ([]byte, error) {
1365 if w != WireFixed64 {
1366 return b, errInternalBadWireType
1367 }
1368 if len(b) < 8 {
1369 return nil, io.ErrUnexpectedEOF
1370 }
1371 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1372 *f.toFloat64Ptr() = &v
1373 return b[8:], nil
1374}
1375
1376func unmarshalFloat64Slice(b []byte, f pointer, w int) ([]byte, error) {
1377 if w == WireBytes { // packed
1378 x, n := decodeVarint(b)
1379 if n == 0 {
1380 return nil, io.ErrUnexpectedEOF
1381 }
1382 b = b[n:]
1383 if x > uint64(len(b)) {
1384 return nil, io.ErrUnexpectedEOF
1385 }
1386 res := b[x:]
1387 b = b[:x]
1388 for len(b) > 0 {
1389 if len(b) < 8 {
1390 return nil, io.ErrUnexpectedEOF
1391 }
1392 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1393 s := f.toFloat64Slice()
1394 *s = append(*s, v)
1395 b = b[8:]
1396 }
1397 return res, nil
1398 }
1399 if w != WireFixed64 {
1400 return b, errInternalBadWireType
1401 }
1402 if len(b) < 8 {
1403 return nil, io.ErrUnexpectedEOF
1404 }
1405 v := math.Float64frombits(uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 | uint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56)
1406 s := f.toFloat64Slice()
1407 *s = append(*s, v)
1408 return b[8:], nil
1409}
1410
1411func unmarshalFloat32Value(b []byte, f pointer, w int) ([]byte, error) {
1412 if w != WireFixed32 {
1413 return b, errInternalBadWireType
1414 }
1415 if len(b) < 4 {
1416 return nil, io.ErrUnexpectedEOF
1417 }
1418 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1419 *f.toFloat32() = v
1420 return b[4:], nil
1421}
1422
1423func unmarshalFloat32Ptr(b []byte, f pointer, w int) ([]byte, error) {
1424 if w != WireFixed32 {
1425 return b, errInternalBadWireType
1426 }
1427 if len(b) < 4 {
1428 return nil, io.ErrUnexpectedEOF
1429 }
1430 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1431 *f.toFloat32Ptr() = &v
1432 return b[4:], nil
1433}
1434
1435func unmarshalFloat32Slice(b []byte, f pointer, w int) ([]byte, error) {
1436 if w == WireBytes { // packed
1437 x, n := decodeVarint(b)
1438 if n == 0 {
1439 return nil, io.ErrUnexpectedEOF
1440 }
1441 b = b[n:]
1442 if x > uint64(len(b)) {
1443 return nil, io.ErrUnexpectedEOF
1444 }
1445 res := b[x:]
1446 b = b[:x]
1447 for len(b) > 0 {
1448 if len(b) < 4 {
1449 return nil, io.ErrUnexpectedEOF
1450 }
1451 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1452 s := f.toFloat32Slice()
1453 *s = append(*s, v)
1454 b = b[4:]
1455 }
1456 return res, nil
1457 }
1458 if w != WireFixed32 {
1459 return b, errInternalBadWireType
1460 }
1461 if len(b) < 4 {
1462 return nil, io.ErrUnexpectedEOF
1463 }
1464 v := math.Float32frombits(uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24)
1465 s := f.toFloat32Slice()
1466 *s = append(*s, v)
1467 return b[4:], nil
1468}
1469
1470func unmarshalStringValue(b []byte, f pointer, w int) ([]byte, error) {
1471 if w != WireBytes {
1472 return b, errInternalBadWireType
1473 }
1474 x, n := decodeVarint(b)
1475 if n == 0 {
1476 return nil, io.ErrUnexpectedEOF
1477 }
1478 b = b[n:]
1479 if x > uint64(len(b)) {
1480 return nil, io.ErrUnexpectedEOF
1481 }
1482 v := string(b[:x])
1483 *f.toString() = v
1484 return b[x:], nil
1485}
1486
1487func unmarshalStringPtr(b []byte, f pointer, w int) ([]byte, error) {
1488 if w != WireBytes {
1489 return b, errInternalBadWireType
1490 }
1491 x, n := decodeVarint(b)
1492 if n == 0 {
1493 return nil, io.ErrUnexpectedEOF
1494 }
1495 b = b[n:]
1496 if x > uint64(len(b)) {
1497 return nil, io.ErrUnexpectedEOF
1498 }
1499 v := string(b[:x])
1500 *f.toStringPtr() = &v
1501 return b[x:], nil
1502}
1503
1504func unmarshalStringSlice(b []byte, f pointer, w int) ([]byte, error) {
1505 if w != WireBytes {
1506 return b, errInternalBadWireType
1507 }
1508 x, n := decodeVarint(b)
1509 if n == 0 {
1510 return nil, io.ErrUnexpectedEOF
1511 }
1512 b = b[n:]
1513 if x > uint64(len(b)) {
1514 return nil, io.ErrUnexpectedEOF
1515 }
1516 v := string(b[:x])
1517 s := f.toStringSlice()
1518 *s = append(*s, v)
1519 return b[x:], nil
1520}
1521
1522func unmarshalUTF8StringValue(b []byte, f pointer, w int) ([]byte, error) {
1523 if w != WireBytes {
1524 return b, errInternalBadWireType
1525 }
1526 x, n := decodeVarint(b)
1527 if n == 0 {
1528 return nil, io.ErrUnexpectedEOF
1529 }
1530 b = b[n:]
1531 if x > uint64(len(b)) {
1532 return nil, io.ErrUnexpectedEOF
1533 }
1534 v := string(b[:x])
1535 *f.toString() = v
1536 if !utf8.ValidString(v) {
1537 return b[x:], errInvalidUTF8
1538 }
1539 return b[x:], nil
1540}
1541
1542func unmarshalUTF8StringPtr(b []byte, f pointer, w int) ([]byte, error) {
1543 if w != WireBytes {
1544 return b, errInternalBadWireType
1545 }
1546 x, n := decodeVarint(b)
1547 if n == 0 {
1548 return nil, io.ErrUnexpectedEOF
1549 }
1550 b = b[n:]
1551 if x > uint64(len(b)) {
1552 return nil, io.ErrUnexpectedEOF
1553 }
1554 v := string(b[:x])
1555 *f.toStringPtr() = &v
1556 if !utf8.ValidString(v) {
1557 return b[x:], errInvalidUTF8
1558 }
1559 return b[x:], nil
1560}
1561
1562func unmarshalUTF8StringSlice(b []byte, f pointer, w int) ([]byte, error) {
1563 if w != WireBytes {
1564 return b, errInternalBadWireType
1565 }
1566 x, n := decodeVarint(b)
1567 if n == 0 {
1568 return nil, io.ErrUnexpectedEOF
1569 }
1570 b = b[n:]
1571 if x > uint64(len(b)) {
1572 return nil, io.ErrUnexpectedEOF
1573 }
1574 v := string(b[:x])
1575 s := f.toStringSlice()
1576 *s = append(*s, v)
1577 if !utf8.ValidString(v) {
1578 return b[x:], errInvalidUTF8
1579 }
1580 return b[x:], nil
1581}
1582
1583var emptyBuf [0]byte
1584
1585func unmarshalBytesValue(b []byte, f pointer, w int) ([]byte, error) {
1586 if w != WireBytes {
1587 return b, errInternalBadWireType
1588 }
1589 x, n := decodeVarint(b)
1590 if n == 0 {
1591 return nil, io.ErrUnexpectedEOF
1592 }
1593 b = b[n:]
1594 if x > uint64(len(b)) {
1595 return nil, io.ErrUnexpectedEOF
1596 }
1597 // The use of append here is a trick which avoids the zeroing
1598 // that would be required if we used a make/copy pair.
1599 // We append to emptyBuf instead of nil because we want
1600 // a non-nil result even when the length is 0.
1601 v := append(emptyBuf[:], b[:x]...)
1602 *f.toBytes() = v
1603 return b[x:], nil
1604}
1605
1606func unmarshalBytesSlice(b []byte, f pointer, w int) ([]byte, error) {
1607 if w != WireBytes {
1608 return b, errInternalBadWireType
1609 }
1610 x, n := decodeVarint(b)
1611 if n == 0 {
1612 return nil, io.ErrUnexpectedEOF
1613 }
1614 b = b[n:]
1615 if x > uint64(len(b)) {
1616 return nil, io.ErrUnexpectedEOF
1617 }
1618 v := append(emptyBuf[:], b[:x]...)
1619 s := f.toBytesSlice()
1620 *s = append(*s, v)
1621 return b[x:], nil
1622}
1623
1624func makeUnmarshalMessagePtr(sub *unmarshalInfo, name string) unmarshaler {
1625 return func(b []byte, f pointer, w int) ([]byte, error) {
1626 if w != WireBytes {
1627 return b, errInternalBadWireType
1628 }
1629 x, n := decodeVarint(b)
1630 if n == 0 {
1631 return nil, io.ErrUnexpectedEOF
1632 }
1633 b = b[n:]
1634 if x > uint64(len(b)) {
1635 return nil, io.ErrUnexpectedEOF
1636 }
1637 // First read the message field to see if something is there.
1638 // The semantics of multiple submessages are weird. Instead of
1639 // the last one winning (as it is for all other fields), multiple
1640 // submessages are merged.
1641 v := f.getPointer()
1642 if v.isNil() {
1643 v = valToPointer(reflect.New(sub.typ))
1644 f.setPointer(v)
1645 }
1646 err := sub.unmarshal(v, b[:x])
1647 if err != nil {
1648 if r, ok := err.(*RequiredNotSetError); ok {
1649 r.field = name + "." + r.field
1650 } else {
1651 return nil, err
1652 }
1653 }
1654 return b[x:], err
1655 }
1656}
1657
1658func makeUnmarshalMessageSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
1659 return func(b []byte, f pointer, w int) ([]byte, error) {
1660 if w != WireBytes {
1661 return b, errInternalBadWireType
1662 }
1663 x, n := decodeVarint(b)
1664 if n == 0 {
1665 return nil, io.ErrUnexpectedEOF
1666 }
1667 b = b[n:]
1668 if x > uint64(len(b)) {
1669 return nil, io.ErrUnexpectedEOF
1670 }
1671 v := valToPointer(reflect.New(sub.typ))
1672 err := sub.unmarshal(v, b[:x])
1673 if err != nil {
1674 if r, ok := err.(*RequiredNotSetError); ok {
1675 r.field = name + "." + r.field
1676 } else {
1677 return nil, err
1678 }
1679 }
1680 f.appendPointer(v)
1681 return b[x:], err
1682 }
1683}
1684
1685func makeUnmarshalGroupPtr(sub *unmarshalInfo, name string) unmarshaler {
1686 return func(b []byte, f pointer, w int) ([]byte, error) {
1687 if w != WireStartGroup {
1688 return b, errInternalBadWireType
1689 }
1690 x, y := findEndGroup(b)
1691 if x < 0 {
1692 return nil, io.ErrUnexpectedEOF
1693 }
1694 v := f.getPointer()
1695 if v.isNil() {
1696 v = valToPointer(reflect.New(sub.typ))
1697 f.setPointer(v)
1698 }
1699 err := sub.unmarshal(v, b[:x])
1700 if err != nil {
1701 if r, ok := err.(*RequiredNotSetError); ok {
1702 r.field = name + "." + r.field
1703 } else {
1704 return nil, err
1705 }
1706 }
1707 return b[y:], err
1708 }
1709}
1710
1711func makeUnmarshalGroupSlicePtr(sub *unmarshalInfo, name string) unmarshaler {
1712 return func(b []byte, f pointer, w int) ([]byte, error) {
1713 if w != WireStartGroup {
1714 return b, errInternalBadWireType
1715 }
1716 x, y := findEndGroup(b)
1717 if x < 0 {
1718 return nil, io.ErrUnexpectedEOF
1719 }
1720 v := valToPointer(reflect.New(sub.typ))
1721 err := sub.unmarshal(v, b[:x])
1722 if err != nil {
1723 if r, ok := err.(*RequiredNotSetError); ok {
1724 r.field = name + "." + r.field
1725 } else {
1726 return nil, err
1727 }
1728 }
1729 f.appendPointer(v)
1730 return b[y:], err
1731 }
1732}
1733
1734func makeUnmarshalMap(f *reflect.StructField) unmarshaler {
1735 t := f.Type
1736 kt := t.Key()
1737 vt := t.Elem()
1738 unmarshalKey := typeUnmarshaler(kt, f.Tag.Get("protobuf_key"))
1739 unmarshalVal := typeUnmarshaler(vt, f.Tag.Get("protobuf_val"))
1740 return func(b []byte, f pointer, w int) ([]byte, error) {
1741 // The map entry is a submessage. Figure out how big it is.
1742 if w != WireBytes {
1743 return nil, fmt.Errorf("proto: bad wiretype for map field: got %d want %d", w, WireBytes)
1744 }
1745 x, n := decodeVarint(b)
1746 if n == 0 {
1747 return nil, io.ErrUnexpectedEOF
1748 }
1749 b = b[n:]
1750 if x > uint64(len(b)) {
1751 return nil, io.ErrUnexpectedEOF
1752 }
1753 r := b[x:] // unused data to return
1754 b = b[:x] // data for map entry
1755
1756 // Note: we could use #keys * #values ~= 200 functions
1757 // to do map decoding without reflection. Probably not worth it.
1758 // Maps will be somewhat slow. Oh well.
1759
1760 // Read key and value from data.
1761 var nerr nonFatal
1762 k := reflect.New(kt)
1763 v := reflect.New(vt)
1764 for len(b) > 0 {
1765 x, n := decodeVarint(b)
1766 if n == 0 {
1767 return nil, io.ErrUnexpectedEOF
1768 }
1769 wire := int(x) & 7
1770 b = b[n:]
1771
1772 var err error
1773 switch x >> 3 {
1774 case 1:
1775 b, err = unmarshalKey(b, valToPointer(k), wire)
1776 case 2:
1777 b, err = unmarshalVal(b, valToPointer(v), wire)
1778 default:
1779 err = errInternalBadWireType // skip unknown tag
1780 }
1781
1782 if nerr.Merge(err) {
1783 continue
1784 }
1785 if err != errInternalBadWireType {
1786 return nil, err
1787 }
1788
1789 // Skip past unknown fields.
1790 b, err = skipField(b, wire)
1791 if err != nil {
1792 return nil, err
1793 }
1794 }
1795
1796 // Get map, allocate if needed.
1797 m := f.asPointerTo(t).Elem() // an addressable map[K]T
1798 if m.IsNil() {
1799 m.Set(reflect.MakeMap(t))
1800 }
1801
1802 // Insert into map.
1803 m.SetMapIndex(k.Elem(), v.Elem())
1804
1805 return r, nerr.E
1806 }
1807}
1808
1809// makeUnmarshalOneof makes an unmarshaler for oneof fields.
1810// for:
1811// message Msg {
1812// oneof F {
1813// int64 X = 1;
1814// float64 Y = 2;
1815// }
1816// }
1817// typ is the type of the concrete entry for a oneof case (e.g. Msg_X).
1818// ityp is the interface type of the oneof field (e.g. isMsg_F).
1819// unmarshal is the unmarshaler for the base type of the oneof case (e.g. int64).
1820// Note that this function will be called once for each case in the oneof.
1821func makeUnmarshalOneof(typ, ityp reflect.Type, unmarshal unmarshaler) unmarshaler {
1822 sf := typ.Field(0)
1823 field0 := toField(&sf)
1824 return func(b []byte, f pointer, w int) ([]byte, error) {
1825 // Allocate holder for value.
1826 v := reflect.New(typ)
1827
1828 // Unmarshal data into holder.
1829 // We unmarshal into the first field of the holder object.
1830 var err error
1831 var nerr nonFatal
1832 b, err = unmarshal(b, valToPointer(v).offset(field0), w)
1833 if !nerr.Merge(err) {
1834 return nil, err
1835 }
1836
1837 // Write pointer to holder into target field.
1838 f.asPointerTo(ityp).Elem().Set(v)
1839
1840 return b, nerr.E
1841 }
1842}
1843
1844// Error used by decode internally.
1845var errInternalBadWireType = errors.New("proto: internal error: bad wiretype")
1846
1847// skipField skips past a field of type wire and returns the remaining bytes.
1848func skipField(b []byte, wire int) ([]byte, error) {
1849 switch wire {
1850 case WireVarint:
1851 _, k := decodeVarint(b)
1852 if k == 0 {
1853 return b, io.ErrUnexpectedEOF
1854 }
1855 b = b[k:]
1856 case WireFixed32:
1857 if len(b) < 4 {
1858 return b, io.ErrUnexpectedEOF
1859 }
1860 b = b[4:]
1861 case WireFixed64:
1862 if len(b) < 8 {
1863 return b, io.ErrUnexpectedEOF
1864 }
1865 b = b[8:]
1866 case WireBytes:
1867 m, k := decodeVarint(b)
1868 if k == 0 || uint64(len(b)-k) < m {
1869 return b, io.ErrUnexpectedEOF
1870 }
1871 b = b[uint64(k)+m:]
1872 case WireStartGroup:
1873 _, i := findEndGroup(b)
1874 if i == -1 {
1875 return b, io.ErrUnexpectedEOF
1876 }
1877 b = b[i:]
1878 default:
1879 return b, fmt.Errorf("proto: can't skip unknown wire type %d", wire)
1880 }
1881 return b, nil
1882}
1883
1884// findEndGroup finds the index of the next EndGroup tag.
1885// Groups may be nested, so the "next" EndGroup tag is the first
1886// unpaired EndGroup.
1887// findEndGroup returns the indexes of the start and end of the EndGroup tag.
1888// Returns (-1,-1) if it can't find one.
1889func findEndGroup(b []byte) (int, int) {
1890 depth := 1
1891 i := 0
1892 for {
1893 x, n := decodeVarint(b[i:])
1894 if n == 0 {
1895 return -1, -1
1896 }
1897 j := i
1898 i += n
1899 switch x & 7 {
1900 case WireVarint:
1901 _, k := decodeVarint(b[i:])
1902 if k == 0 {
1903 return -1, -1
1904 }
1905 i += k
1906 case WireFixed32:
1907 if len(b)-4 < i {
1908 return -1, -1
1909 }
1910 i += 4
1911 case WireFixed64:
1912 if len(b)-8 < i {
1913 return -1, -1
1914 }
1915 i += 8
1916 case WireBytes:
1917 m, k := decodeVarint(b[i:])
1918 if k == 0 {
1919 return -1, -1
1920 }
1921 i += k
1922 if uint64(len(b)-i) < m {
1923 return -1, -1
1924 }
1925 i += int(m)
1926 case WireStartGroup:
1927 depth++
1928 case WireEndGroup:
1929 depth--
1930 if depth == 0 {
1931 return j, i
1932 }
1933 default:
1934 return -1, -1
1935 }
1936 }
1937}
1938
1939// encodeVarint appends a varint-encoded integer to b and returns the result.
1940func encodeVarint(b []byte, x uint64) []byte {
1941 for x >= 1<<7 {
1942 b = append(b, byte(x&0x7f|0x80))
1943 x >>= 7
1944 }
1945 return append(b, byte(x))
1946}
1947
1948// decodeVarint reads a varint-encoded integer from b.
1949// Returns the decoded integer and the number of bytes read.
1950// If there is an error, it returns 0,0.
1951func decodeVarint(b []byte) (uint64, int) {
1952 var x, y uint64
1953 if len(b) == 0 {
1954 goto bad
1955 }
1956 x = uint64(b[0])
1957 if x < 0x80 {
1958 return x, 1
1959 }
1960 x -= 0x80
1961
1962 if len(b) <= 1 {
1963 goto bad
1964 }
1965 y = uint64(b[1])
1966 x += y << 7
1967 if y < 0x80 {
1968 return x, 2
1969 }
1970 x -= 0x80 << 7
1971
1972 if len(b) <= 2 {
1973 goto bad
1974 }
1975 y = uint64(b[2])
1976 x += y << 14
1977 if y < 0x80 {
1978 return x, 3
1979 }
1980 x -= 0x80 << 14
1981
1982 if len(b) <= 3 {
1983 goto bad
1984 }
1985 y = uint64(b[3])
1986 x += y << 21
1987 if y < 0x80 {
1988 return x, 4
1989 }
1990 x -= 0x80 << 21
1991
1992 if len(b) <= 4 {
1993 goto bad
1994 }
1995 y = uint64(b[4])
1996 x += y << 28
1997 if y < 0x80 {
1998 return x, 5
1999 }
2000 x -= 0x80 << 28
2001
2002 if len(b) <= 5 {
2003 goto bad
2004 }
2005 y = uint64(b[5])
2006 x += y << 35
2007 if y < 0x80 {
2008 return x, 6
2009 }
2010 x -= 0x80 << 35
2011
2012 if len(b) <= 6 {
2013 goto bad
2014 }
2015 y = uint64(b[6])
2016 x += y << 42
2017 if y < 0x80 {
2018 return x, 7
2019 }
2020 x -= 0x80 << 42
2021
2022 if len(b) <= 7 {
2023 goto bad
2024 }
2025 y = uint64(b[7])
2026 x += y << 49
2027 if y < 0x80 {
2028 return x, 8
2029 }
2030 x -= 0x80 << 49
2031
2032 if len(b) <= 8 {
2033 goto bad
2034 }
2035 y = uint64(b[8])
2036 x += y << 56
2037 if y < 0x80 {
2038 return x, 9
2039 }
2040 x -= 0x80 << 56
2041
2042 if len(b) <= 9 {
2043 goto bad
2044 }
2045 y = uint64(b[9])
2046 x += y << 63
2047 if y < 2 {
2048 return x, 10
2049 }
2050
2051bad:
2052 return 0, 0
2053}