Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 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 proto |
| 6 | |
| 7 | import ( |
Damien Neil | e89e624 | 2019-05-13 23:55:40 -0700 | [diff] [blame] | 8 | "google.golang.org/protobuf/internal/encoding/wire" |
| 9 | "google.golang.org/protobuf/internal/errors" |
| 10 | "google.golang.org/protobuf/internal/pragma" |
| 11 | "google.golang.org/protobuf/reflect/protoreflect" |
| 12 | "google.golang.org/protobuf/reflect/protoregistry" |
| 13 | "google.golang.org/protobuf/runtime/protoiface" |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 14 | ) |
| 15 | |
| 16 | // UnmarshalOptions configures the unmarshaler. |
| 17 | // |
| 18 | // Example usage: |
| 19 | // err := UnmarshalOptions{DiscardUnknown: true}.Unmarshal(b, m) |
| 20 | type UnmarshalOptions struct { |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 21 | // AllowPartial accepts input for messages that will result in missing |
| 22 | // required fields. If AllowPartial is false (the default), Unmarshal will |
| 23 | // return an error if there are any missing required fields. |
| 24 | AllowPartial bool |
| 25 | |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 26 | // If DiscardUnknown is set, unknown fields are ignored. |
| 27 | DiscardUnknown bool |
| 28 | |
Joe Tsai | db38ddd | 2019-05-07 15:14:40 -0700 | [diff] [blame] | 29 | // Resolver is used for looking up types when unmarshaling extension fields. |
| 30 | // If nil, this defaults to using protoregistry.GlobalTypes. |
Joe Tsai | 1c28304 | 2019-05-14 14:28:19 -0700 | [diff] [blame] | 31 | Resolver interface { |
| 32 | protoregistry.ExtensionTypeResolver |
| 33 | } |
Joe Tsai | db38ddd | 2019-05-07 15:14:40 -0700 | [diff] [blame] | 34 | |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 35 | pragma.NoUnkeyedLiterals |
| 36 | } |
| 37 | |
Damien Neil | 0d3e8cc | 2019-04-01 13:31:55 -0700 | [diff] [blame] | 38 | var _ = protoiface.UnmarshalOptions(UnmarshalOptions{}) |
| 39 | |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 40 | // Unmarshal parses the wire-format message in b and places the result in m. |
| 41 | func Unmarshal(b []byte, m Message) error { |
| 42 | return UnmarshalOptions{}.Unmarshal(b, m) |
| 43 | } |
| 44 | |
| 45 | // Unmarshal parses the wire-format message in b and places the result in m. |
| 46 | func (o UnmarshalOptions) Unmarshal(b []byte, m Message) error { |
Joe Tsai | db38ddd | 2019-05-07 15:14:40 -0700 | [diff] [blame] | 47 | if o.Resolver == nil { |
| 48 | o.Resolver = protoregistry.GlobalTypes |
| 49 | } |
| 50 | |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 51 | // TODO: Reset m? |
Damien Neil | 4686e23 | 2019-04-05 13:31:40 -0700 | [diff] [blame] | 52 | err := o.unmarshalMessageFast(b, m) |
| 53 | if err == errInternalNoFast { |
| 54 | err = o.unmarshalMessage(b, m.ProtoReflect()) |
| 55 | } |
| 56 | var nerr errors.NonFatal |
| 57 | if !nerr.Merge(err) { |
Damien Neil | 0d3e8cc | 2019-04-01 13:31:55 -0700 | [diff] [blame] | 58 | return err |
| 59 | } |
Damien Neil | 4686e23 | 2019-04-05 13:31:40 -0700 | [diff] [blame] | 60 | if !o.AllowPartial { |
| 61 | nerr.Merge(IsInitialized(m)) |
| 62 | } |
| 63 | return nerr.E |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 64 | } |
| 65 | |
Damien Neil | 0d3e8cc | 2019-04-01 13:31:55 -0700 | [diff] [blame] | 66 | func (o UnmarshalOptions) unmarshalMessageFast(b []byte, m Message) error { |
Damien Neil | 0d3e8cc | 2019-04-01 13:31:55 -0700 | [diff] [blame] | 67 | methods := protoMethods(m) |
| 68 | if methods == nil || methods.Unmarshal == nil { |
| 69 | return errInternalNoFast |
| 70 | } |
| 71 | return methods.Unmarshal(b, m, protoiface.UnmarshalOptions(o)) |
| 72 | } |
| 73 | |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 74 | func (o UnmarshalOptions) unmarshalMessage(b []byte, m protoreflect.Message) error { |
Joe Tsai | 0fc49f8 | 2019-05-01 12:29:25 -0700 | [diff] [blame] | 75 | messageDesc := m.Descriptor() |
| 76 | fieldDescs := messageDesc.Fields() |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 77 | var nerr errors.NonFatal |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 78 | for len(b) > 0 { |
| 79 | // Parse the tag (field number and wire type). |
| 80 | num, wtyp, tagLen := wire.ConsumeTag(b) |
| 81 | if tagLen < 0 { |
| 82 | return wire.ParseError(tagLen) |
| 83 | } |
| 84 | |
| 85 | // Parse the field value. |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 86 | fd := fieldDescs.ByNumber(num) |
| 87 | if fd == nil && messageDesc.ExtensionRanges().Has(num) { |
| 88 | extType, err := o.Resolver.FindExtensionByNumber(messageDesc.FullName(), num) |
| 89 | if err != nil && err != protoregistry.NotFound { |
| 90 | return err |
Joe Tsai | db38ddd | 2019-05-07 15:14:40 -0700 | [diff] [blame] | 91 | } |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 92 | fd = extType |
Damien Neil | d068d30 | 2018-12-17 14:06:08 -0800 | [diff] [blame] | 93 | } |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 94 | var err error |
| 95 | var valLen int |
| 96 | switch { |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 97 | case fd == nil: |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 98 | err = errUnknown |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 99 | case fd.IsList(): |
| 100 | valLen, err = o.unmarshalList(b[tagLen:], wtyp, m.Mutable(fd).List(), fd) |
| 101 | case fd.IsMap(): |
| 102 | valLen, err = o.unmarshalMap(b[tagLen:], wtyp, m.Mutable(fd).Map(), fd) |
Joe Tsai | ac31a35 | 2019-05-13 14:32:56 -0700 | [diff] [blame] | 103 | default: |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 104 | valLen, err = o.unmarshalSingular(b[tagLen:], wtyp, m, fd) |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 105 | } |
| 106 | if err == errUnknown { |
| 107 | valLen = wire.ConsumeFieldValue(num, wtyp, b[tagLen:]) |
| 108 | if valLen < 0 { |
| 109 | return wire.ParseError(valLen) |
| 110 | } |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 111 | m.SetUnknown(append(m.GetUnknown(), b[:tagLen+valLen]...)) |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 112 | } else if !nerr.Merge(err) { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 113 | return err |
| 114 | } |
| 115 | b = b[tagLen+valLen:] |
| 116 | } |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 117 | return nerr.E |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 118 | } |
| 119 | |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 120 | func (o UnmarshalOptions) unmarshalSingular(b []byte, wtyp wire.Type, m protoreflect.Message, fd protoreflect.FieldDescriptor) (n int, err error) { |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 121 | var nerr errors.NonFatal |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 122 | v, n, err := o.unmarshalScalar(b, wtyp, fd) |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 123 | if !nerr.Merge(err) { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 124 | return 0, err |
| 125 | } |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 126 | switch fd.Kind() { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 127 | case protoreflect.GroupKind, protoreflect.MessageKind: |
| 128 | // Messages are merged with any existing message value, |
| 129 | // unless the message is part of a oneof. |
| 130 | // |
| 131 | // TODO: C++ merges into oneofs, while v1 does not. |
| 132 | // Evaluate which behavior to pick. |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 133 | var m2 protoreflect.Message |
| 134 | if m.Has(fd) && fd.ContainingOneof() == nil { |
| 135 | m2 = m.Mutable(fd).Message() |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 136 | } else { |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 137 | m2 = m.NewMessage(fd) |
| 138 | m.Set(fd, protoreflect.ValueOf(m2)) |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 139 | } |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 140 | // Pass up errors (fatal and otherwise). |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 141 | if err := o.unmarshalMessage(v.Bytes(), m2); !nerr.Merge(err) { |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 142 | return n, err |
| 143 | } |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 144 | default: |
| 145 | // Non-message scalars replace the previous value. |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 146 | m.Set(fd, v) |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 147 | } |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 148 | return n, nerr.E |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 149 | } |
| 150 | |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 151 | func (o UnmarshalOptions) unmarshalMap(b []byte, wtyp wire.Type, mapv protoreflect.Map, fd protoreflect.FieldDescriptor) (n int, err error) { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 152 | if wtyp != wire.BytesType { |
| 153 | return 0, errUnknown |
| 154 | } |
| 155 | b, n = wire.ConsumeBytes(b) |
| 156 | if n < 0 { |
| 157 | return 0, wire.ParseError(n) |
| 158 | } |
| 159 | var ( |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 160 | keyField = fd.MapKey() |
| 161 | valField = fd.MapValue() |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 162 | key protoreflect.Value |
| 163 | val protoreflect.Value |
| 164 | haveKey bool |
| 165 | haveVal bool |
| 166 | ) |
| 167 | switch valField.Kind() { |
| 168 | case protoreflect.GroupKind, protoreflect.MessageKind: |
Joe Tsai | 3bc7d6f | 2019-01-09 02:57:13 -0800 | [diff] [blame] | 169 | val = protoreflect.ValueOf(mapv.NewMessage()) |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 170 | } |
| 171 | // Map entries are represented as a two-element message with fields |
| 172 | // containing the key and value. |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 173 | var nerr errors.NonFatal |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 174 | for len(b) > 0 { |
| 175 | num, wtyp, n := wire.ConsumeTag(b) |
| 176 | if n < 0 { |
| 177 | return 0, wire.ParseError(n) |
| 178 | } |
| 179 | b = b[n:] |
| 180 | err = errUnknown |
| 181 | switch num { |
| 182 | case 1: |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 183 | key, n, err = o.unmarshalScalar(b, wtyp, keyField) |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 184 | if !nerr.Merge(err) { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 185 | break |
| 186 | } |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 187 | err = nil |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 188 | haveKey = true |
| 189 | case 2: |
| 190 | var v protoreflect.Value |
Joe Tsai | 378c132 | 2019-04-25 23:48:08 -0700 | [diff] [blame^] | 191 | v, n, err = o.unmarshalScalar(b, wtyp, valField) |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 192 | if !nerr.Merge(err) { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 193 | break |
| 194 | } |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 195 | err = nil |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 196 | switch valField.Kind() { |
| 197 | case protoreflect.GroupKind, protoreflect.MessageKind: |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 198 | if err := o.unmarshalMessage(v.Bytes(), val.Message()); !nerr.Merge(err) { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 199 | return 0, err |
| 200 | } |
| 201 | default: |
| 202 | val = v |
| 203 | } |
| 204 | haveVal = true |
| 205 | } |
| 206 | if err == errUnknown { |
| 207 | n = wire.ConsumeFieldValue(num, wtyp, b) |
| 208 | if n < 0 { |
| 209 | return 0, wire.ParseError(n) |
| 210 | } |
Damien Neil | bc310b5 | 2019-04-11 11:46:55 -0700 | [diff] [blame] | 211 | } else if err != nil { |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 212 | return 0, err |
| 213 | } |
| 214 | b = b[n:] |
| 215 | } |
| 216 | // Every map entry should have entries for key and value, but this is not strictly required. |
| 217 | if !haveKey { |
| 218 | key = keyField.Default() |
| 219 | } |
| 220 | if !haveVal { |
| 221 | switch valField.Kind() { |
| 222 | case protoreflect.GroupKind, protoreflect.MessageKind: |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 223 | default: |
| 224 | val = valField.Default() |
| 225 | } |
| 226 | } |
| 227 | mapv.Set(key.MapKey(), val) |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 228 | return n, nerr.E |
Damien Neil | ba23aa5 | 2018-12-07 14:38:17 -0800 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | // errUnknown is used internally to indicate fields which should be added |
| 232 | // to the unknown field set of a message. It is never returned from an exported |
| 233 | // function. |
Damien Neil | 96c229a | 2019-04-03 12:17:24 -0700 | [diff] [blame] | 234 | var errUnknown = errors.New("BUG: internal error (unknown)") |