decode.go

Documentation: google.golang.org/protobuf/encoding/prototext

     1  // Copyright 2018 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package prototext
     6  
     7  import (
     8  	"fmt"
     9  	"unicode/utf8"
    10  
    11  	"google.golang.org/protobuf/internal/encoding/messageset"
    12  	"google.golang.org/protobuf/internal/encoding/text"
    13  	"google.golang.org/protobuf/internal/errors"
    14  	"google.golang.org/protobuf/internal/flags"
    15  	"google.golang.org/protobuf/internal/genid"
    16  	"google.golang.org/protobuf/internal/pragma"
    17  	"google.golang.org/protobuf/internal/set"
    18  	"google.golang.org/protobuf/internal/strs"
    19  	"google.golang.org/protobuf/proto"
    20  	"google.golang.org/protobuf/reflect/protoreflect"
    21  	"google.golang.org/protobuf/reflect/protoregistry"
    22  )
    23  
    24  // Unmarshal reads the given []byte into the given [proto.Message].
    25  // The provided message must be mutable (e.g., a non-nil pointer to a message).
    26  func Unmarshal(b []byte, m proto.Message) error {
    27  	return UnmarshalOptions{}.Unmarshal(b, m)
    28  }
    29  
    30  // UnmarshalOptions is a configurable textproto format unmarshaler.
    31  type UnmarshalOptions struct {
    32  	pragma.NoUnkeyedLiterals
    33  
    34  	// AllowPartial accepts input for messages that will result in missing
    35  	// required fields. If AllowPartial is false (the default), Unmarshal will
    36  	// return error if there are any missing required fields.
    37  	AllowPartial bool
    38  
    39  	// DiscardUnknown specifies whether to ignore unknown fields when parsing.
    40  	// An unknown field is any field whose field name or field number does not
    41  	// resolve to any known or extension field in the message.
    42  	// By default, unmarshal rejects unknown fields as an error.
    43  	DiscardUnknown bool
    44  
    45  	// Resolver is used for looking up types when unmarshaling
    46  	// google.protobuf.Any messages or extension fields.
    47  	// If nil, this defaults to using protoregistry.GlobalTypes.
    48  	Resolver interface {
    49  		protoregistry.MessageTypeResolver
    50  		protoregistry.ExtensionTypeResolver
    51  	}
    52  }
    53  
    54  // Unmarshal reads the given []byte and populates the given [proto.Message]
    55  // using options in the UnmarshalOptions object.
    56  // The provided message must be mutable (e.g., a non-nil pointer to a message).
    57  func (o UnmarshalOptions) Unmarshal(b []byte, m proto.Message) error {
    58  	return o.unmarshal(b, m)
    59  }
    60  
    61  // unmarshal is a centralized function that all unmarshal operations go through.
    62  // For profiling purposes, avoid changing the name of this function or
    63  // introducing other code paths for unmarshal that do not go through this.
    64  func (o UnmarshalOptions) unmarshal(b []byte, m proto.Message) error {
    65  	proto.Reset(m)
    66  
    67  	if o.Resolver == nil {
    68  		o.Resolver = protoregistry.GlobalTypes
    69  	}
    70  
    71  	dec := decoder{text.NewDecoder(b), o}
    72  	if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
    73  		return err
    74  	}
    75  	if o.AllowPartial {
    76  		return nil
    77  	}
    78  	return proto.CheckInitialized(m)
    79  }
    80  
    81  type decoder struct {
    82  	*text.Decoder
    83  	opts UnmarshalOptions
    84  }
    85  
    86  // newError returns an error object with position info.
    87  func (d decoder) newError(pos int, f string, x ...interface{}) error {
    88  	line, column := d.Position(pos)
    89  	head := fmt.Sprintf("(line %d:%d): ", line, column)
    90  	return errors.New(head+f, x...)
    91  }
    92  
    93  // unexpectedTokenError returns a syntax error for the given unexpected token.
    94  func (d decoder) unexpectedTokenError(tok text.Token) error {
    95  	return d.syntaxError(tok.Pos(), "unexpected token: %s", tok.RawString())
    96  }
    97  
    98  // syntaxError returns a syntax error for given position.
    99  func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
   100  	line, column := d.Position(pos)
   101  	head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
   102  	return errors.New(head+f, x...)
   103  }
   104  
   105  // unmarshalMessage unmarshals into the given protoreflect.Message.
   106  func (d decoder) unmarshalMessage(m protoreflect.Message, checkDelims bool) error {
   107  	messageDesc := m.Descriptor()
   108  	if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
   109  		return errors.New("no support for proto1 MessageSets")
   110  	}
   111  
   112  	if messageDesc.FullName() == genid.Any_message_fullname {
   113  		return d.unmarshalAny(m, checkDelims)
   114  	}
   115  
   116  	if checkDelims {
   117  		tok, err := d.Read()
   118  		if err != nil {
   119  			return err
   120  		}
   121  
   122  		if tok.Kind() != text.MessageOpen {
   123  			return d.unexpectedTokenError(tok)
   124  		}
   125  	}
   126  
   127  	var seenNums set.Ints
   128  	var seenOneofs set.Ints
   129  	fieldDescs := messageDesc.Fields()
   130  
   131  	for {
   132  		// Read field name.
   133  		tok, err := d.Read()
   134  		if err != nil {
   135  			return err
   136  		}
   137  		switch typ := tok.Kind(); typ {
   138  		case text.Name:
   139  			// Continue below.
   140  		case text.EOF:
   141  			if checkDelims {
   142  				return text.ErrUnexpectedEOF
   143  			}
   144  			return nil
   145  		default:
   146  			if checkDelims && typ == text.MessageClose {
   147  				return nil
   148  			}
   149  			return d.unexpectedTokenError(tok)
   150  		}
   151  
   152  		// Resolve the field descriptor.
   153  		var name protoreflect.Name
   154  		var fd protoreflect.FieldDescriptor
   155  		var xt protoreflect.ExtensionType
   156  		var xtErr error
   157  		var isFieldNumberName bool
   158  
   159  		switch tok.NameKind() {
   160  		case text.IdentName:
   161  			name = protoreflect.Name(tok.IdentName())
   162  			fd = fieldDescs.ByTextName(string(name))
   163  
   164  		case text.TypeName:
   165  			// Handle extensions only. This code path is not for Any.
   166  			xt, xtErr = d.opts.Resolver.FindExtensionByName(protoreflect.FullName(tok.TypeName()))
   167  
   168  		case text.FieldNumber:
   169  			isFieldNumberName = true
   170  			num := protoreflect.FieldNumber(tok.FieldNumber())
   171  			if !num.IsValid() {
   172  				return d.newError(tok.Pos(), "invalid field number: %d", num)
   173  			}
   174  			fd = fieldDescs.ByNumber(num)
   175  			if fd == nil {
   176  				xt, xtErr = d.opts.Resolver.FindExtensionByNumber(messageDesc.FullName(), num)
   177  			}
   178  		}
   179  
   180  		if xt != nil {
   181  			fd = xt.TypeDescriptor()
   182  			if !messageDesc.ExtensionRanges().Has(fd.Number()) || fd.ContainingMessage().FullName() != messageDesc.FullName() {
   183  				return d.newError(tok.Pos(), "message %v cannot be extended by %v", messageDesc.FullName(), fd.FullName())
   184  			}
   185  		} else if xtErr != nil && xtErr != protoregistry.NotFound {
   186  			return d.newError(tok.Pos(), "unable to resolve [%s]: %v", tok.RawString(), xtErr)
   187  		}
   188  		if flags.ProtoLegacy {
   189  			if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
   190  				fd = nil // reset since the weak reference is not linked in
   191  			}
   192  		}
   193  
   194  		// Handle unknown fields.
   195  		if fd == nil {
   196  			if d.opts.DiscardUnknown || messageDesc.ReservedNames().Has(name) {
   197  				d.skipValue()
   198  				continue
   199  			}
   200  			return d.newError(tok.Pos(), "unknown field: %v", tok.RawString())
   201  		}
   202  
   203  		// Handle fields identified by field number.
   204  		if isFieldNumberName {
   205  			// TODO: Add an option to permit parsing field numbers.
   206  			//
   207  			// This requires careful thought as the MarshalOptions.EmitUnknown
   208  			// option allows formatting unknown fields as the field number and the
   209  			// best-effort textual representation of the field value.  In that case,
   210  			// it may not be possible to unmarshal the value from a parser that does
   211  			// have information about the unknown field.
   212  			return d.newError(tok.Pos(), "cannot specify field by number: %v", tok.RawString())
   213  		}
   214  
   215  		switch {
   216  		case fd.IsList():
   217  			kind := fd.Kind()
   218  			if kind != protoreflect.MessageKind && kind != protoreflect.GroupKind && !tok.HasSeparator() {
   219  				return d.syntaxError(tok.Pos(), "missing field separator :")
   220  			}
   221  
   222  			list := m.Mutable(fd).List()
   223  			if err := d.unmarshalList(fd, list); err != nil {
   224  				return err
   225  			}
   226  
   227  		case fd.IsMap():
   228  			mmap := m.Mutable(fd).Map()
   229  			if err := d.unmarshalMap(fd, mmap); err != nil {
   230  				return err
   231  			}
   232  
   233  		default:
   234  			kind := fd.Kind()
   235  			if kind != protoreflect.MessageKind && kind != protoreflect.GroupKind && !tok.HasSeparator() {
   236  				return d.syntaxError(tok.Pos(), "missing field separator :")
   237  			}
   238  
   239  			// If field is a oneof, check if it has already been set.
   240  			if od := fd.ContainingOneof(); od != nil {
   241  				idx := uint64(od.Index())
   242  				if seenOneofs.Has(idx) {
   243  					return d.newError(tok.Pos(), "error parsing %q, oneof %v is already set", tok.RawString(), od.FullName())
   244  				}
   245  				seenOneofs.Set(idx)
   246  			}
   247  
   248  			num := uint64(fd.Number())
   249  			if seenNums.Has(num) {
   250  				return d.newError(tok.Pos(), "non-repeated field %q is repeated", tok.RawString())
   251  			}
   252  
   253  			if err := d.unmarshalSingular(fd, m); err != nil {
   254  				return err
   255  			}
   256  			seenNums.Set(num)
   257  		}
   258  	}
   259  
   260  	return nil
   261  }
   262  
   263  // unmarshalSingular unmarshals a non-repeated field value specified by the
   264  // given FieldDescriptor.
   265  func (d decoder) unmarshalSingular(fd protoreflect.FieldDescriptor, m protoreflect.Message) error {
   266  	var val protoreflect.Value
   267  	var err error
   268  	switch fd.Kind() {
   269  	case protoreflect.MessageKind, protoreflect.GroupKind:
   270  		val = m.NewField(fd)
   271  		err = d.unmarshalMessage(val.Message(), true)
   272  	default:
   273  		val, err = d.unmarshalScalar(fd)
   274  	}
   275  	if err == nil {
   276  		m.Set(fd, val)
   277  	}
   278  	return err
   279  }
   280  
   281  // unmarshalScalar unmarshals a scalar/enum protoreflect.Value specified by the
   282  // given FieldDescriptor.
   283  func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
   284  	tok, err := d.Read()
   285  	if err != nil {
   286  		return protoreflect.Value{}, err
   287  	}
   288  
   289  	if tok.Kind() != text.Scalar {
   290  		return protoreflect.Value{}, d.unexpectedTokenError(tok)
   291  	}
   292  
   293  	kind := fd.Kind()
   294  	switch kind {
   295  	case protoreflect.BoolKind:
   296  		if b, ok := tok.Bool(); ok {
   297  			return protoreflect.ValueOfBool(b), nil
   298  		}
   299  
   300  	case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
   301  		if n, ok := tok.Int32(); ok {
   302  			return protoreflect.ValueOfInt32(n), nil
   303  		}
   304  
   305  	case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
   306  		if n, ok := tok.Int64(); ok {
   307  			return protoreflect.ValueOfInt64(n), nil
   308  		}
   309  
   310  	case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
   311  		if n, ok := tok.Uint32(); ok {
   312  			return protoreflect.ValueOfUint32(n), nil
   313  		}
   314  
   315  	case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
   316  		if n, ok := tok.Uint64(); ok {
   317  			return protoreflect.ValueOfUint64(n), nil
   318  		}
   319  
   320  	case protoreflect.FloatKind:
   321  		if n, ok := tok.Float32(); ok {
   322  			return protoreflect.ValueOfFloat32(n), nil
   323  		}
   324  
   325  	case protoreflect.DoubleKind:
   326  		if n, ok := tok.Float64(); ok {
   327  			return protoreflect.ValueOfFloat64(n), nil
   328  		}
   329  
   330  	case protoreflect.StringKind:
   331  		if s, ok := tok.String(); ok {
   332  			if strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
   333  				return protoreflect.Value{}, d.newError(tok.Pos(), "contains invalid UTF-8")
   334  			}
   335  			return protoreflect.ValueOfString(s), nil
   336  		}
   337  
   338  	case protoreflect.BytesKind:
   339  		if b, ok := tok.String(); ok {
   340  			return protoreflect.ValueOfBytes([]byte(b)), nil
   341  		}
   342  
   343  	case protoreflect.EnumKind:
   344  		if lit, ok := tok.Enum(); ok {
   345  			// Lookup EnumNumber based on name.
   346  			if enumVal := fd.Enum().Values().ByName(protoreflect.Name(lit)); enumVal != nil {
   347  				return protoreflect.ValueOfEnum(enumVal.Number()), nil
   348  			}
   349  		}
   350  		if num, ok := tok.Int32(); ok {
   351  			return protoreflect.ValueOfEnum(protoreflect.EnumNumber(num)), nil
   352  		}
   353  
   354  	default:
   355  		panic(fmt.Sprintf("invalid scalar kind %v", kind))
   356  	}
   357  
   358  	return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
   359  }
   360  
   361  // unmarshalList unmarshals into given protoreflect.List. A list value can
   362  // either be in [] syntax or simply just a single scalar/message value.
   363  func (d decoder) unmarshalList(fd protoreflect.FieldDescriptor, list protoreflect.List) error {
   364  	tok, err := d.Peek()
   365  	if err != nil {
   366  		return err
   367  	}
   368  
   369  	switch fd.Kind() {
   370  	case protoreflect.MessageKind, protoreflect.GroupKind:
   371  		switch tok.Kind() {
   372  		case text.ListOpen:
   373  			d.Read()
   374  			for {
   375  				tok, err := d.Peek()
   376  				if err != nil {
   377  					return err
   378  				}
   379  
   380  				switch tok.Kind() {
   381  				case text.ListClose:
   382  					d.Read()
   383  					return nil
   384  				case text.MessageOpen:
   385  					pval := list.NewElement()
   386  					if err := d.unmarshalMessage(pval.Message(), true); err != nil {
   387  						return err
   388  					}
   389  					list.Append(pval)
   390  				default:
   391  					return d.unexpectedTokenError(tok)
   392  				}
   393  			}
   394  
   395  		case text.MessageOpen:
   396  			pval := list.NewElement()
   397  			if err := d.unmarshalMessage(pval.Message(), true); err != nil {
   398  				return err
   399  			}
   400  			list.Append(pval)
   401  			return nil
   402  		}
   403  
   404  	default:
   405  		switch tok.Kind() {
   406  		case text.ListOpen:
   407  			d.Read()
   408  			for {
   409  				tok, err := d.Peek()
   410  				if err != nil {
   411  					return err
   412  				}
   413  
   414  				switch tok.Kind() {
   415  				case text.ListClose:
   416  					d.Read()
   417  					return nil
   418  				case text.Scalar:
   419  					pval, err := d.unmarshalScalar(fd)
   420  					if err != nil {
   421  						return err
   422  					}
   423  					list.Append(pval)
   424  				default:
   425  					return d.unexpectedTokenError(tok)
   426  				}
   427  			}
   428  
   429  		case text.Scalar:
   430  			pval, err := d.unmarshalScalar(fd)
   431  			if err != nil {
   432  				return err
   433  			}
   434  			list.Append(pval)
   435  			return nil
   436  		}
   437  	}
   438  
   439  	return d.unexpectedTokenError(tok)
   440  }
   441  
   442  // unmarshalMap unmarshals into given protoreflect.Map. A map value is a
   443  // textproto message containing {key: <kvalue>, value: <mvalue>}.
   444  func (d decoder) unmarshalMap(fd protoreflect.FieldDescriptor, mmap protoreflect.Map) error {
   445  	// Determine ahead whether map entry is a scalar type or a message type in
   446  	// order to call the appropriate unmarshalMapValue func inside
   447  	// unmarshalMapEntry.
   448  	var unmarshalMapValue func() (protoreflect.Value, error)
   449  	switch fd.MapValue().Kind() {
   450  	case protoreflect.MessageKind, protoreflect.GroupKind:
   451  		unmarshalMapValue = func() (protoreflect.Value, error) {
   452  			pval := mmap.NewValue()
   453  			if err := d.unmarshalMessage(pval.Message(), true); err != nil {
   454  				return protoreflect.Value{}, err
   455  			}
   456  			return pval, nil
   457  		}
   458  	default:
   459  		unmarshalMapValue = func() (protoreflect.Value, error) {
   460  			return d.unmarshalScalar(fd.MapValue())
   461  		}
   462  	}
   463  
   464  	tok, err := d.Read()
   465  	if err != nil {
   466  		return err
   467  	}
   468  	switch tok.Kind() {
   469  	case text.MessageOpen:
   470  		return d.unmarshalMapEntry(fd, mmap, unmarshalMapValue)
   471  
   472  	case text.ListOpen:
   473  		for {
   474  			tok, err := d.Read()
   475  			if err != nil {
   476  				return err
   477  			}
   478  			switch tok.Kind() {
   479  			case text.ListClose:
   480  				return nil
   481  			case text.MessageOpen:
   482  				if err := d.unmarshalMapEntry(fd, mmap, unmarshalMapValue); err != nil {
   483  					return err
   484  				}
   485  			default:
   486  				return d.unexpectedTokenError(tok)
   487  			}
   488  		}
   489  
   490  	default:
   491  		return d.unexpectedTokenError(tok)
   492  	}
   493  }
   494  
   495  // unmarshalMap unmarshals into given protoreflect.Map. A map value is a
   496  // textproto message containing {key: <kvalue>, value: <mvalue>}.
   497  func (d decoder) unmarshalMapEntry(fd protoreflect.FieldDescriptor, mmap protoreflect.Map, unmarshalMapValue func() (protoreflect.Value, error)) error {
   498  	var key protoreflect.MapKey
   499  	var pval protoreflect.Value
   500  Loop:
   501  	for {
   502  		// Read field name.
   503  		tok, err := d.Read()
   504  		if err != nil {
   505  			return err
   506  		}
   507  		switch tok.Kind() {
   508  		case text.Name:
   509  			if tok.NameKind() != text.IdentName {
   510  				if !d.opts.DiscardUnknown {
   511  					return d.newError(tok.Pos(), "unknown map entry field %q", tok.RawString())
   512  				}
   513  				d.skipValue()
   514  				continue Loop
   515  			}
   516  			// Continue below.
   517  		case text.MessageClose:
   518  			break Loop
   519  		default:
   520  			return d.unexpectedTokenError(tok)
   521  		}
   522  
   523  		switch name := protoreflect.Name(tok.IdentName()); name {
   524  		case genid.MapEntry_Key_field_name:
   525  			if !tok.HasSeparator() {
   526  				return d.syntaxError(tok.Pos(), "missing field separator :")
   527  			}
   528  			if key.IsValid() {
   529  				return d.newError(tok.Pos(), "map entry %q cannot be repeated", name)
   530  			}
   531  			val, err := d.unmarshalScalar(fd.MapKey())
   532  			if err != nil {
   533  				return err
   534  			}
   535  			key = val.MapKey()
   536  
   537  		case genid.MapEntry_Value_field_name:
   538  			if kind := fd.MapValue().Kind(); (kind != protoreflect.MessageKind) && (kind != protoreflect.GroupKind) {
   539  				if !tok.HasSeparator() {
   540  					return d.syntaxError(tok.Pos(), "missing field separator :")
   541  				}
   542  			}
   543  			if pval.IsValid() {
   544  				return d.newError(tok.Pos(), "map entry %q cannot be repeated", name)
   545  			}
   546  			pval, err = unmarshalMapValue()
   547  			if err != nil {
   548  				return err
   549  			}
   550  
   551  		default:
   552  			if !d.opts.DiscardUnknown {
   553  				return d.newError(tok.Pos(), "unknown map entry field %q", name)
   554  			}
   555  			d.skipValue()
   556  		}
   557  	}
   558  
   559  	if !key.IsValid() {
   560  		key = fd.MapKey().Default().MapKey()
   561  	}
   562  	if !pval.IsValid() {
   563  		switch fd.MapValue().Kind() {
   564  		case protoreflect.MessageKind, protoreflect.GroupKind:
   565  			// If value field is not set for message/group types, construct an
   566  			// empty one as default.
   567  			pval = mmap.NewValue()
   568  		default:
   569  			pval = fd.MapValue().Default()
   570  		}
   571  	}
   572  	mmap.Set(key, pval)
   573  	return nil
   574  }
   575  
   576  // unmarshalAny unmarshals an Any textproto. It can either be in expanded form
   577  // or non-expanded form.
   578  func (d decoder) unmarshalAny(m protoreflect.Message, checkDelims bool) error {
   579  	var typeURL string
   580  	var bValue []byte
   581  	var seenTypeUrl bool
   582  	var seenValue bool
   583  	var isExpanded bool
   584  
   585  	if checkDelims {
   586  		tok, err := d.Read()
   587  		if err != nil {
   588  			return err
   589  		}
   590  
   591  		if tok.Kind() != text.MessageOpen {
   592  			return d.unexpectedTokenError(tok)
   593  		}
   594  	}
   595  
   596  Loop:
   597  	for {
   598  		// Read field name. Can only have 3 possible field names, i.e. type_url,
   599  		// value and type URL name inside [].
   600  		tok, err := d.Read()
   601  		if err != nil {
   602  			return err
   603  		}
   604  		if typ := tok.Kind(); typ != text.Name {
   605  			if checkDelims {
   606  				if typ == text.MessageClose {
   607  					break Loop
   608  				}
   609  			} else if typ == text.EOF {
   610  				break Loop
   611  			}
   612  			return d.unexpectedTokenError(tok)
   613  		}
   614  
   615  		switch tok.NameKind() {
   616  		case text.IdentName:
   617  			// Both type_url and value fields require field separator :.
   618  			if !tok.HasSeparator() {
   619  				return d.syntaxError(tok.Pos(), "missing field separator :")
   620  			}
   621  
   622  			switch name := protoreflect.Name(tok.IdentName()); name {
   623  			case genid.Any_TypeUrl_field_name:
   624  				if seenTypeUrl {
   625  					return d.newError(tok.Pos(), "duplicate %v field", genid.Any_TypeUrl_field_fullname)
   626  				}
   627  				if isExpanded {
   628  					return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
   629  				}
   630  				tok, err := d.Read()
   631  				if err != nil {
   632  					return err
   633  				}
   634  				var ok bool
   635  				typeURL, ok = tok.String()
   636  				if !ok {
   637  					return d.newError(tok.Pos(), "invalid %v field value: %v", genid.Any_TypeUrl_field_fullname, tok.RawString())
   638  				}
   639  				seenTypeUrl = true
   640  
   641  			case genid.Any_Value_field_name:
   642  				if seenValue {
   643  					return d.newError(tok.Pos(), "duplicate %v field", genid.Any_Value_field_fullname)
   644  				}
   645  				if isExpanded {
   646  					return d.newError(tok.Pos(), "conflict with [%s] field", typeURL)
   647  				}
   648  				tok, err := d.Read()
   649  				if err != nil {
   650  					return err
   651  				}
   652  				s, ok := tok.String()
   653  				if !ok {
   654  					return d.newError(tok.Pos(), "invalid %v field value: %v", genid.Any_Value_field_fullname, tok.RawString())
   655  				}
   656  				bValue = []byte(s)
   657  				seenValue = true
   658  
   659  			default:
   660  				if !d.opts.DiscardUnknown {
   661  					return d.newError(tok.Pos(), "invalid field name %q in %v message", tok.RawString(), genid.Any_message_fullname)
   662  				}
   663  			}
   664  
   665  		case text.TypeName:
   666  			if isExpanded {
   667  				return d.newError(tok.Pos(), "cannot have more than one type")
   668  			}
   669  			if seenTypeUrl {
   670  				return d.newError(tok.Pos(), "conflict with type_url field")
   671  			}
   672  			typeURL = tok.TypeName()
   673  			var err error
   674  			bValue, err = d.unmarshalExpandedAny(typeURL, tok.Pos())
   675  			if err != nil {
   676  				return err
   677  			}
   678  			isExpanded = true
   679  
   680  		default:
   681  			if !d.opts.DiscardUnknown {
   682  				return d.newError(tok.Pos(), "invalid field name %q in %v message", tok.RawString(), genid.Any_message_fullname)
   683  			}
   684  		}
   685  	}
   686  
   687  	fds := m.Descriptor().Fields()
   688  	if len(typeURL) > 0 {
   689  		m.Set(fds.ByNumber(genid.Any_TypeUrl_field_number), protoreflect.ValueOfString(typeURL))
   690  	}
   691  	if len(bValue) > 0 {
   692  		m.Set(fds.ByNumber(genid.Any_Value_field_number), protoreflect.ValueOfBytes(bValue))
   693  	}
   694  	return nil
   695  }
   696  
   697  func (d decoder) unmarshalExpandedAny(typeURL string, pos int) ([]byte, error) {
   698  	mt, err := d.opts.Resolver.FindMessageByURL(typeURL)
   699  	if err != nil {
   700  		return nil, d.newError(pos, "unable to resolve message [%v]: %v", typeURL, err)
   701  	}
   702  	// Create new message for the embedded message type and unmarshal the value
   703  	// field into it.
   704  	m := mt.New()
   705  	if err := d.unmarshalMessage(m, true); err != nil {
   706  		return nil, err
   707  	}
   708  	// Serialize the embedded message and return the resulting bytes.
   709  	b, err := proto.MarshalOptions{
   710  		AllowPartial:  true, // Never check required fields inside an Any.
   711  		Deterministic: true,
   712  	}.Marshal(m.Interface())
   713  	if err != nil {
   714  		return nil, d.newError(pos, "error in marshaling message into Any.value: %v", err)
   715  	}
   716  	return b, nil
   717  }
   718  
   719  // skipValue makes the decoder parse a field value in order to advance the read
   720  // to the next field. It relies on Read returning an error if the types are not
   721  // in valid sequence.
   722  func (d decoder) skipValue() error {
   723  	tok, err := d.Read()
   724  	if err != nil {
   725  		return err
   726  	}
   727  	// Only need to continue reading for messages and lists.
   728  	switch tok.Kind() {
   729  	case text.MessageOpen:
   730  		return d.skipMessageValue()
   731  
   732  	case text.ListOpen:
   733  		for {
   734  			tok, err := d.Read()
   735  			if err != nil {
   736  				return err
   737  			}
   738  			switch tok.Kind() {
   739  			case text.ListClose:
   740  				return nil
   741  			case text.MessageOpen:
   742  				if err := d.skipMessageValue(); err != nil {
   743  					return err
   744  				}
   745  			default:
   746  				// Skip items. This will not validate whether skipped values are
   747  				// of the same type or not, same behavior as C++
   748  				// TextFormat::Parser::AllowUnknownField(true) version 3.8.0.
   749  			}
   750  		}
   751  	}
   752  	return nil
   753  }
   754  
   755  // skipMessageValue makes the decoder parse and skip over all fields in a
   756  // message. It assumes that the previous read type is MessageOpen.
   757  func (d decoder) skipMessageValue() error {
   758  	for {
   759  		tok, err := d.Read()
   760  		if err != nil {
   761  			return err
   762  		}
   763  		switch tok.Kind() {
   764  		case text.MessageClose:
   765  			return nil
   766  		case text.Name:
   767  			if err := d.skipValue(); err != nil {
   768  				return err
   769  			}
   770  		}
   771  	}
   772  }
   773
View as plain text