// Go support for Protocol Buffers - Google's data interchange format

//

// Copyright 2016 The Go Authors.  All rights reserved.

// https://github.com/golang/protobuf

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package proto

import (

	"errors"

	"fmt"

	"io"

	"math"

	"reflect"

	"strconv"

	"strings"

	"sync"

	"sync/atomic"

	"unicode/utf8"

)

// Unmarshal is the entry point from the generated .pb.go files.

// This function is not intended to be used by non-generated code.

// This function is not subject to any compatibility guarantee.

// msg contains a pointer to a protocol buffer struct.

// b is the data to be unmarshaled into the protocol buffer.

// a is a pointer to a place to store cached unmarshal information.

func (a *InternalMessageInfo) Unmarshal(msg Message, b []byte) error {

	// Load the unmarshal information for this message type.

	// The atomic load ensures memory consistency.

	u := atomicLoadUnmarshalInfo(&a.unmarshal)

	if u == nil {

		// Slow path: find unmarshal info for msg, update a with it.

		u = getUnmarshalInfo(reflect.TypeOf(msg).Elem())

		atomicStoreUnmarshalInfo(&a.unmarshal, u)

	}

	// Then do the unmarshaling.

	err := u.unmarshal(toPointer(&msg), b)

	return err

}

type unmarshalInfo struct {

	typ reflect.Type // type of the protobuf struct

	// 0 = only typ field is initialized

	// 1 = completely initialized

	initialized     int32

	lock            sync.Mutex                    // prevents double initialization

	dense           []unmarshalFieldInfo          // fields indexed by tag #

	sparse          map[uint64]unmarshalFieldInfo // fields indexed by tag #

	reqFields       []string                      // names of required fields

	reqMask         uint64                        // 1<<len(reqFields)-1

	unrecognized    field                         // offset of []byte to put unrecognized data (or invalidField if we should throw it away)

	extensions      field                         // offset of extensions field (of type proto.XXX_InternalExtensions), or invalidField if it does not exist

	oldExtensions   field                         // offset of old-form extensions field (of type map[int]Extension)

	extensionRanges []ExtensionRange              // if non-nil, implies extensions field is valid

	isMessageSet    bool                          // if true, implies extensions field is valid

}

// An unmarshaler takes a stream of bytes and a pointer to a field of a message.

// It decodes the field, stores it at f, and returns the unused bytes.

// w is the wire encoding.

// b is the data after the tag and wire encoding have been read.

type unmarshaler func(b []byte, f pointer, w int) ([]byte, error)

type unmarshalFieldInfo struct {

	// location of the field in the proto message structure.

	field field

	// function to unmarshal the data for the field.

	unmarshal unmarshaler

	// if a required field, contains a single set bit at this field's index in the required field list.

	reqMask uint64

	name string // name of the field, for error reporting

}

var (

	unmarshalInfoMap  = map[reflect.Type]*unmarshalInfo{}

	unmarshalInfoLock sync.Mutex

)

// getUnmarshalInfo returns the data structure which can be

// subsequently used to unmarshal a message of the given type.

// t is the type of the message (note: not pointer to message).

func getUnmarshalInfo(t reflect.Type) *unmarshalInfo {

	// It would be correct to return a new unmarshalInfo

	// unconditionally. We would end up allocating one

	// per occurrence of that type as a message or submessage.

	// We use a cache here just to reduce memory usage.

	unmarshalInfoLock.Lock()

	defer unmarshalInfoLock.Unlock()

	u := unmarshalInfoMap[t]

	if u == nil {

		u = &unmarshalInfo{typ: t}

		// Note: we just set the type here. The rest of the fields

		// will be initialized on first use.

		unmarshalInfoMap[t] = u

	}

	return u

}

// unmarshal does the main work of unmarshaling a message.

// u provides type information used to unmarshal the message.

// m is a pointer to a protocol buffer message.

// b is a byte stream to unmarshal into m.

// This is top routine used when recursively unmarshaling submessages.

func (u *unmarshalInfo) unmarshal(m pointer, b []byte) error {

	if atomic.LoadInt32(&u.initialized) == 0 {

		u.computeUnmarshalInfo()

	}

	if u.isMessageSet {

	}

	var reqMask uint64 // bitmask of required fields we've seen.

	var errLater error

	for len(b) > 0 {

		// Read tag and wire type.

		// Special case 1 and 2 byte varints.

		var x uint64

		if b[0] < 128 {

			x = uint64(b[0])

			b = b[1:]

		} else if len(b) >= 2 && b[1] < 128 {

			x = uint64(b[0]&0x7f) + uint64(b[1])<<7

			b = b[2:]

		} else {

			var n int

			x, n = decodeVarint(b)

			if n == 0 {

				return io.ErrUnexpectedEOF

			}

			b = b[n:]

		}

		tag := x >> 3

		wire := int(x) & 7

		// Dispatch on the tag to one of the unmarshal* functions below.

		var f unmarshalFieldInfo

		if tag < uint64(len(u.dense)) {

			f = u.dense[tag]

		} else {

			f = u.sparse[tag]

		}

		if fn := f.unmarshal; fn != nil {

			var err error

			b, err = fn(b, m.offset(f.field), wire)

			if err == nil {

				reqMask |= f.reqMask

				continue

			}

			if r, ok := err.(*RequiredNotSetError); ok {

				// Remember this error, but keep parsing. We need to produce

				// a full parse even if a required field is missing.

				if errLater == nil {

					errLater = r

				}

				reqMask |= f.reqMask

				continue

			}

			if err != errInternalBadWireType {

				if err == errInvalidUTF8 {

					if errLater == nil {

						fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name

						errLater = &invalidUTF8Error{fullName}

					}

					continue

				}

				return err

			}

			// Fragments with bad wire type are treated as unknown fields.

		}

		// Unknown tag.

		if !u.unrecognized.IsValid() {

			// Don't keep unrecognized data; just skip it.

			var err error

			b, err = skipField(b, wire)

			if err != nil {

				return err

			}

			continue

		}

		// Keep unrecognized data around.

		// maybe in extensions, maybe in the unrecognized field.

		z := m.offset(u.unrecognized).toBytes()

		var emap map[int32]Extension

		var e Extension

		for _, r := range u.extensionRanges {

			if uint64(r.Start) <= tag && tag <= uint64(r.End) {

				if u.extensions.IsValid() {

					mp := m.offset(u.extensions).toExtensions()

					emap = mp.extensionsWrite()

					e = emap[int32(tag)]

					z = &e.enc

					break

				}

				if u.oldExtensions.IsValid() {

					p := m.offset(u.oldExtensions).toOldExtensions()

					emap = *p

					if emap == nil {

						emap = map[int32]Extension{}

						*p = emap

					}

					e = emap[int32(tag)]

					z = &e.enc

					break

				}

				panic("no extensions field available")

			}

		}

		// Use wire type to skip data.

		var err error

		b0 := b

		b, err = skipField(b, wire)

		if err != nil {

			return err

		}

		*z = encodeVarint(*z, tag<<3|uint64(wire))

		*z = append(*z, b0[:len(b0)-len(b)]...)

		if emap != nil {

			emap[int32(tag)] = e

		}

	}

	if reqMask != u.reqMask && errLater == nil {

		// A required field of this message is missing.

		for _, n := range u.reqFields {

			if reqMask&1 == 0 {

				errLater = &RequiredNotSetError{n}

			}

			reqMask >>= 1

		}

	}

	return errLater

}

// computeUnmarshalInfo fills in u with information for use

// in unmarshaling protocol buffers of type u.typ.

func (u *unmarshalInfo) computeUnmarshalInfo() {

	u.lock.Lock()

	defer u.lock.Unlock()

	if u.initialized != 0 {

		return

	}

	t := u.typ

	n := t.NumField()

	// Set up the "not found" value for the unrecognized byte buffer.

	// This is the default for proto3.

	u.unrecognized = invalidField

	u.extensions = invalidField

	u.oldExtensions = invalidField

	// List of the generated type and offset for each oneof field.

	type oneofField struct {

		ityp  reflect.Type // interface type of oneof field

		field field        // offset in containing message

	}

	var oneofFields []oneofField

	for i := 0; i < n; i++ {

		f := t.Field(i)

		if f.Name == "XXX_unrecognized" {

			// The byte slice used to hold unrecognized input is special.

			if f.Type != reflect.TypeOf(([]byte)(nil)) {

				panic("bad type for XXX_unrecognized field: " + f.Type.Name())

			}

			u.unrecognized = toField(&f)

			continue

		}

		if f.Name == "XXX_InternalExtensions" {

			// Ditto here.

			if f.Type != reflect.TypeOf(XXX_InternalExtensions{}) {

				panic("bad type for XXX_InternalExtensions field: " + f.Type.Name())

			}

			u.extensions = toField(&f)

			if f.Tag.Get("protobuf_messageset") == "1" {

				u.isMessageSet = true

			}

			continue

		}

		if f.Name == "XXX_extensions" {

			// An older form of the extensions field.

			if f.Type != reflect.TypeOf((map[int32]Extension)(nil)) {

				panic("bad type for XXX_extensions field: " + f.Type.Name())

			}

			u.oldExtensions = toField(&f)

			continue

		}

		if f.Name == "XXX_NoUnkeyedLiteral" || f.Name == "XXX_sizecache" {

			continue

		}

		oneof := f.Tag.Get("protobuf_oneof")

		if oneof != "" {

			oneofFields = append(oneofFields, oneofField{f.Type, toField(&f)})

			// The rest of oneof processing happens below.

			continue

		}

		tags := f.Tag.Get("protobuf")

		tagArray := strings.Split(tags, ",")

		if len(tagArray) < 2 {

			panic("protobuf tag not enough fields in " + t.Name() + "." + f.Name + ": " + tags)

		}

		tag, err := strconv.Atoi(tagArray[1])

		if err != nil {

			panic("protobuf tag field not an integer: " + tagArray[1])

		}

		name := ""

		for _, tag := range tagArray[3:] {

			if strings.HasPrefix(tag, "name=") {

				name = tag[5:]

			}

		}

		// Extract unmarshaling function from the field (its type and tags).

		unmarshal := fieldUnmarshaler(&f)

		// Required field?

		var reqMask uint64

		if tagArray[2] == "req" {

			bit := len(u.reqFields)

			u.reqFields = append(u.reqFields, name)

			reqMask = uint64(1) << uint(bit)

			// TODO: if we have more than 64 required fields, we end up

			// not verifying that all required fields are present.

			// Fix this, perhaps using a count of required fields?

		}

		// Store the info in the correct slot in the message.

		u.setTag(tag, toField(&f), unmarshal, reqMask, name)

	}

	// Find any types associated with oneof fields.

			}

		}

	}

	// Get extension ranges, if any.

	if fn.IsValid() {

		if !u.extensions.IsValid() && !u.oldExtensions.IsValid() {

			panic("a message with extensions, but no extensions field in " + t.Name())

		}

		u.extensionRanges = fn.Call(nil)[0].Interface().([]ExtensionRange)