| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package proto |
| |
| import ( |
| "google.golang.org/protobuf/encoding/protowire" |
| "google.golang.org/protobuf/internal/encoding/messageset" |
| "google.golang.org/protobuf/internal/errors" |
| "google.golang.org/protobuf/internal/flags" |
| "google.golang.org/protobuf/internal/genid" |
| "google.golang.org/protobuf/internal/pragma" |
| "google.golang.org/protobuf/reflect/protoreflect" |
| "google.golang.org/protobuf/reflect/protoregistry" |
| "google.golang.org/protobuf/runtime/protoiface" |
| ) |
| |
| // UnmarshalOptions configures the unmarshaler. |
| // |
| // Example usage: |
| // |
| // err := UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, m) |
| type UnmarshalOptions struct { |
| pragma.NoUnkeyedLiterals |
| |
| // Merge merges the input into the destination message. |
| // The default behavior is to always reset the message before unmarshaling, |
| // unless Merge is specified. |
| Merge bool |
| |
| // AllowPartial accepts input for messages that will result in missing |
| // required fields. If AllowPartial is false (the default), Unmarshal will |
| // return an error if there are any missing required fields. |
| AllowPartial bool |
| |
| // If DiscardUnknown is set, unknown fields are ignored. |
| DiscardUnknown bool |
| |
| // Resolver is used for looking up types when unmarshaling extension fields. |
| // If nil, this defaults to using protoregistry.GlobalTypes. |
| Resolver interface { |
| FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error) |
| FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error) |
| } |
| |
| // RecursionLimit limits how deeply messages may be nested. |
| // If zero, a default limit is applied. |
| RecursionLimit int |
| } |
| |
| // Unmarshal parses the wire-format message in b and places the result in m. |
| // The provided message must be mutable (e.g., a non-nil pointer to a message). |
| func Unmarshal(b []byte, m Message) error { |
| _, err := UnmarshalOptions{RecursionLimit: protowire.DefaultRecursionLimit}.unmarshal(b, m.ProtoReflect()) |
| return err |
| } |
| |
| // Unmarshal parses the wire-format message in b and places the result in m. |
| // The provided message must be mutable (e.g., a non-nil pointer to a message). |
| func (o UnmarshalOptions) Unmarshal(b []byte, m Message) error { |
| if o.RecursionLimit == 0 { |
| o.RecursionLimit = protowire.DefaultRecursionLimit |
| } |
| _, err := o.unmarshal(b, m.ProtoReflect()) |
| return err |
| } |
| |
| // UnmarshalState parses a wire-format message and places the result in m. |
| // |
| // This method permits fine-grained control over the unmarshaler. |
| // Most users should use Unmarshal instead. |
| func (o UnmarshalOptions) UnmarshalState(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) { |
| if o.RecursionLimit == 0 { |
| o.RecursionLimit = protowire.DefaultRecursionLimit |
| } |
| return o.unmarshal(in.Buf, in.Message) |
| } |
| |
| // unmarshal is a centralized function that all unmarshal operations go through. |
| // For profiling purposes, avoid changing the name of this function or |
| // introducing other code paths for unmarshal that do not go through this. |
| func (o UnmarshalOptions) unmarshal(b []byte, m protoreflect.Message) (out protoiface.UnmarshalOutput, err error) { |
| if o.Resolver == nil { |
| o.Resolver = protoregistry.GlobalTypes |
| } |
| if !o.Merge { |
| Reset(m.Interface()) |
| } |
| allowPartial := o.AllowPartial |
| o.Merge = true |
| o.AllowPartial = true |
| methods := protoMethods(m) |
| if methods != nil && methods.Unmarshal != nil && |
| !(o.DiscardUnknown && methods.Flags&protoiface.SupportUnmarshalDiscardUnknown == 0) { |
| in := protoiface.UnmarshalInput{ |
| Message: m, |
| Buf: b, |
| Resolver: o.Resolver, |
| Depth: o.RecursionLimit, |
| } |
| if o.DiscardUnknown { |
| in.Flags |= protoiface.UnmarshalDiscardUnknown |
| } |
| out, err = methods.Unmarshal(in) |
| } else { |
| o.RecursionLimit-- |
| if o.RecursionLimit < 0 { |
| return out, errors.New("exceeded max recursion depth") |
| } |
| err = o.unmarshalMessageSlow(b, m) |
| } |
| if err != nil { |
| return out, err |
| } |
| if allowPartial || (out.Flags&protoiface.UnmarshalInitialized != 0) { |
| return out, nil |
| } |
| return out, checkInitialized(m) |
| } |
| |
| func (o UnmarshalOptions) unmarshalMessage(b []byte, m protoreflect.Message) error { |
| _, err := o.unmarshal(b, m) |
| return err |
| } |
| |
| func (o UnmarshalOptions) unmarshalMessageSlow(b []byte, m protoreflect.Message) error { |
| md := m.Descriptor() |
| if messageset.IsMessageSet(md) { |
| return o.unmarshalMessageSet(b, m) |
| } |
| fields := md.Fields() |
| for len(b) > 0 { |
| // Parse the tag (field number and wire type). |
| num, wtyp, tagLen := protowire.ConsumeTag(b) |
| if tagLen < 0 { |
| return errDecode |
| } |
| if num > protowire.MaxValidNumber { |
| return errDecode |
| } |
| |
| // Find the field descriptor for this field number. |
| fd := fields.ByNumber(num) |
| if fd == nil && md.ExtensionRanges().Has(num) { |
| extType, err := o.Resolver.FindExtensionByNumber(md.FullName(), num) |
| if err != nil && err != protoregistry.NotFound { |
| return errors.New("%v: unable to resolve extension %v: %v", md.FullName(), num, err) |
| } |
| if extType != nil { |
| fd = extType.TypeDescriptor() |
| } |
| } |
| var err error |
| if fd == nil { |
| err = errUnknown |
| } else if flags.ProtoLegacy { |
| if fd.IsWeak() && fd.Message().IsPlaceholder() { |
| err = errUnknown // weak referent is not linked in |
| } |
| } |
| |
| // Parse the field value. |
| var valLen int |
| switch { |
| case err != nil: |
| case fd.IsList(): |
| valLen, err = o.unmarshalList(b[tagLen:], wtyp, m.Mutable(fd).List(), fd) |
| case fd.IsMap(): |
| valLen, err = o.unmarshalMap(b[tagLen:], wtyp, m.Mutable(fd).Map(), fd) |
| default: |
| valLen, err = o.unmarshalSingular(b[tagLen:], wtyp, m, fd) |
| } |
| if err != nil { |
| if err != errUnknown { |
| return err |
| } |
| valLen = protowire.ConsumeFieldValue(num, wtyp, b[tagLen:]) |
| if valLen < 0 { |
| return errDecode |
| } |
| if !o.DiscardUnknown { |
| m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...)) |
| } |
| } |
| b = b[tagLen+valLen:] |
| } |
| return nil |
| } |
| |
| func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp protowire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) { |
| v, n, err := o.unmarshalScalar(b, wtyp, fd) |
| if err != nil { |
| return 0, err |
| } |
| switch fd.Kind() { |
| case protoreflect.GroupKind, protoreflect.MessageKind: |
| m2 := m.Mutable(fd).Message() |
| if err := o.unmarshalMessage(v.Bytes(), m2); err != nil { |
| return n, err |
| } |
| default: |
| // Non-message scalars replace the previous value. |
| m.Set(fd, v) |
| } |
| return n, nil |
| } |
| |
| func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp protowire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) { |
| if wtyp != protowire.BytesType { |
| return 0, errUnknown |
| } |
| b, n = protowire.ConsumeBytes(b) |
| if n < 0 { |
| return 0, errDecode |
| } |
| var ( |
| keyField = fd.MapKey() |
| valField = fd.MapValue() |
| key protoreflect.Value |
| val protoreflect.Value |
| haveKey bool |
| haveVal bool |
| ) |
| switch valField.Kind() { |
| case protoreflect.GroupKind, protoreflect.MessageKind: |
| val = mapv.NewValue() |
| } |
| // Map entries are represented as a two-element message with fields |
| // containing the key and value. |
| for len(b) > 0 { |
| num, wtyp, n := protowire.ConsumeTag(b) |
| if n < 0 { |
| return 0, errDecode |
| } |
| if num > protowire.MaxValidNumber { |
| return 0, errDecode |
| } |
| b = b[n:] |
| err = errUnknown |
| switch num { |
| case genid.MapEntry_Key_field_number: |
| key, n, err = o.unmarshalScalar(b, wtyp, keyField) |
| if err != nil { |
| break |
| } |
| haveKey = true |
| case genid.MapEntry_Value_field_number: |
| var v protoreflect.Value |
| v, n, err = o.unmarshalScalar(b, wtyp, valField) |
| if err != nil { |
| break |
| } |
| switch valField.Kind() { |
| case protoreflect.GroupKind, protoreflect.MessageKind: |
| if err := o.unmarshalMessage(v.Bytes(), val.Message()); err != nil { |
| return 0, err |
| } |
| default: |
| val = v |
| } |
| haveVal = true |
| } |
| if err == errUnknown { |
| n = protowire.ConsumeFieldValue(num, wtyp, b) |
| if n < 0 { |
| return 0, errDecode |
| } |
| } else if err != nil { |
| return 0, err |
| } |
| b = b[n:] |
| } |
| // Every map entry should have entries for key and value, but this is not strictly required. |
| if !haveKey { |
| key = keyField.Default() |
| } |
| if !haveVal { |
| switch valField.Kind() { |
| case protoreflect.GroupKind, protoreflect.MessageKind: |
| default: |
| val = valField.Default() |
| } |
| } |
| mapv.Set(key.MapKey(), val) |
| return n, nil |
| } |
| |
| // errUnknown is used internally to indicate fields which should be added |
| // to the unknown field set of a message. It is never returned from an exported |
| // function. |
| var errUnknown = errors.New("BUG: internal error (unknown)") |
| |
| var errDecode = errors.New("cannot parse invalid wire-format data") |