decode.go 20 KB

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