vendor/github.com/golang/protobuf/proto/decode.go

   1 // Go support for Protocol Buffers - Google's data interchange format
   2 //
   3 // Copyright 2010 The Go Authors.  All rights reserved.
   4 // https://github.com/golang/protobuf
   5 //
   6 // Redistribution and use in source and binary forms, with or without
   7 // modification, are permitted provided that the following conditions are
   8 // met:
   9 //
  10 //     * Redistributions of source code must retain the above copyright
  11 // notice, this list of conditions and the following disclaimer.
  12 //     * Redistributions in binary form must reproduce the above
  13 // copyright notice, this list of conditions and the following disclaimer
  14 // in the documentation and/or other materials provided with the
  15 // distribution.
  16 //     * Neither the name of Google Inc. nor the names of its
  17 // contributors may be used to endorse or promote products derived from
  18 // this software without specific prior written permission.
  19 //
  20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31
  32 package proto
  33
  34 /*
  35  * Routines for decoding protocol buffer data to construct in-memory representations.
  36  */
  37
  38 import (
  39         "errors"
  40         "fmt"
  41         "io"
  42 )
  43
  44 // errOverflow is returned when an integer is too large to be represented.
  45 var errOverflow = errors.New("proto: integer overflow")
  46
  47 // ErrInternalBadWireType is returned by generated code when an incorrect
  48 // wire type is encountered. It does not get returned to user code.
  49 var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof")
  50
  51 // DecodeVarint reads a varint-encoded integer from the slice.
  52 // It returns the integer and the number of bytes consumed, or
  53 // zero if there is not enough.
  54 // This is the format for the
  55 // int32, int64, uint32, uint64, bool, and enum
  56 // protocol buffer types.
  57 func DecodeVarint(buf []byte) (x uint64, n int) {
  58         for shift := uint(0); shift < 64; shift += 7 {
  59                 if n >= len(buf) {
  60                         return 0, 0
  61                 }
  62                 b := uint64(buf[n])
  63                 n++
  64                 x |= (b & 0x7F) << shift
  65                 if (b & 0x80) == 0 {
  66                         return x, n
  67                 }
  68         }
  69
  70         // The number is too large to represent in a 64-bit value.
  71         return 0, 0
  72 }
  73
  74 func (p *Buffer) decodeVarintSlow() (x uint64, err error) {
  75         i := p.index
  76         l := len(p.buf)
  77
  78         for shift := uint(0); shift < 64; shift += 7 {
  79                 if i >= l {
  80                         err = io.ErrUnexpectedEOF
  81                         return
  82                 }
  83                 b := p.buf[i]
  84                 i++
  85                 x |= (uint64(b) & 0x7F) << shift
  86                 if b < 0x80 {
  87                         p.index = i
  88                         return
  89                 }
  90         }
  91
  92         // The number is too large to represent in a 64-bit value.
  93         err = errOverflow
  94         return
  95 }
  96
  97 // DecodeVarint reads a varint-encoded integer from the Buffer.
  98 // This is the format for the
  99 // int32, int64, uint32, uint64, bool, and enum
 100 // protocol buffer types.
 101 func (p *Buffer) DecodeVarint() (x uint64, err error) {
 102         i := p.index
 103         buf := p.buf
 104
 105         if i >= len(buf) {
 106                 return 0, io.ErrUnexpectedEOF
 107         } else if buf[i] < 0x80 {
 108                 p.index++
 109                 return uint64(buf[i]), nil
 110         } else if len(buf)-i < 10 {
 111                 return p.decodeVarintSlow()
 112         }
 113
 114         var b uint64
 115         // we already checked the first byte
 116         x = uint64(buf[i]) - 0x80
 117         i++
 118
 119         b = uint64(buf[i])
 120         i++
 121         x += b << 7
 122         if b&0x80 == 0 {
 123                 goto done
 124         }
 125         x -= 0x80 << 7
 126
 127         b = uint64(buf[i])
 128         i++
 129         x += b << 14
 130         if b&0x80 == 0 {
 131                 goto done
 132         }
 133         x -= 0x80 << 14
 134
 135         b = uint64(buf[i])
 136         i++
 137         x += b << 21
 138         if b&0x80 == 0 {
 139                 goto done
 140         }
 141         x -= 0x80 << 21
 142
 143         b = uint64(buf[i])
 144         i++
 145         x += b << 28
 146         if b&0x80 == 0 {
 147                 goto done
 148         }
 149         x -= 0x80 << 28
 150
 151         b = uint64(buf[i])
 152         i++
 153         x += b << 35
 154         if b&0x80 == 0 {
 155                 goto done
 156         }
 157         x -= 0x80 << 35
 158
 159         b = uint64(buf[i])
 160         i++
 161         x += b << 42
 162         if b&0x80 == 0 {
 163                 goto done
 164         }
 165         x -= 0x80 << 42
 166
 167         b = uint64(buf[i])
 168         i++
 169         x += b << 49
 170         if b&0x80 == 0 {
 171                 goto done
 172         }
 173         x -= 0x80 << 49
 174
 175         b = uint64(buf[i])
 176         i++
 177         x += b << 56
 178         if b&0x80 == 0 {
 179                 goto done
 180         }
 181         x -= 0x80 << 56
 182
 183         b = uint64(buf[i])
 184         i++
 185         x += b << 63
 186         if b&0x80 == 0 {
 187                 goto done
 188         }
 189         // x -= 0x80 << 63 // Always zero.
 190
 191         return 0, errOverflow
 192
 193 done:
 194         p.index = i
 195         return x, nil
 196 }
 197
 198 // DecodeFixed64 reads a 64-bit integer from the Buffer.
 199 // This is the format for the
 200 // fixed64, sfixed64, and double protocol buffer types.
 201 func (p *Buffer) DecodeFixed64() (x uint64, err error) {
 202         // x, err already 0
 203         i := p.index + 8
 204         if i < 0 || i > len(p.buf) {
 205                 err = io.ErrUnexpectedEOF
 206                 return
 207         }
 208         p.index = i
 209
 210         x = uint64(p.buf[i-8])
 211         x |= uint64(p.buf[i-7]) << 8
 212         x |= uint64(p.buf[i-6]) << 16
 213         x |= uint64(p.buf[i-5]) << 24
 214         x |= uint64(p.buf[i-4]) << 32
 215         x |= uint64(p.buf[i-3]) << 40
 216         x |= uint64(p.buf[i-2]) << 48
 217         x |= uint64(p.buf[i-1]) << 56
 218         return
 219 }
 220
 221 // DecodeFixed32 reads a 32-bit integer from the Buffer.
 222 // This is the format for the
 223 // fixed32, sfixed32, and float protocol buffer types.
 224 func (p *Buffer) DecodeFixed32() (x uint64, err error) {
 225         // x, err already 0
 226         i := p.index + 4
 227         if i < 0 || i > len(p.buf) {
 228                 err = io.ErrUnexpectedEOF
 229                 return
 230         }
 231         p.index = i
 232
 233         x = uint64(p.buf[i-4])
 234         x |= uint64(p.buf[i-3]) << 8
 235         x |= uint64(p.buf[i-2]) << 16
 236         x |= uint64(p.buf[i-1]) << 24
 237         return
 238 }
 239
 240 // DecodeZigzag64 reads a zigzag-encoded 64-bit integer
 241 // from the Buffer.
 242 // This is the format used for the sint64 protocol buffer type.
 243 func (p *Buffer) DecodeZigzag64() (x uint64, err error) {
 244         x, err = p.DecodeVarint()
 245         if err != nil {
 246                 return
 247         }
 248         x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63)
 249         return
 250 }
 251
 252 // DecodeZigzag32 reads a zigzag-encoded 32-bit integer
 253 // from  the Buffer.
 254 // This is the format used for the sint32 protocol buffer type.
 255 func (p *Buffer) DecodeZigzag32() (x uint64, err error) {
 256         x, err = p.DecodeVarint()
 257         if err != nil {
 258                 return
 259         }
 260         x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31))
 261         return
 262 }
 263
 264 // DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
 265 // This is the format used for the bytes protocol buffer
 266 // type and for embedded messages.
 267 func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) {
 268         n, err := p.DecodeVarint()
 269         if err != nil {
 270                 return nil, err
 271         }
 272
 273         nb := int(n)
 274         if nb < 0 {
 275                 return nil, fmt.Errorf("proto: bad byte length %d", nb)
 276         }
 277         end := p.index + nb
 278         if end < p.index || end > len(p.buf) {
 279                 return nil, io.ErrUnexpectedEOF
 280         }
 281
 282         if !alloc {
 283                 // todo: check if can get more uses of alloc=false
 284                 buf = p.buf[p.index:end]
 285                 p.index += nb
 286                 return
 287         }
 288
 289         buf = make([]byte, nb)
 290         copy(buf, p.buf[p.index:])
 291         p.index += nb
 292         return
 293 }
 294
 295 // DecodeStringBytes reads an encoded string from the Buffer.
 296 // This is the format used for the proto2 string type.
 297 func (p *Buffer) DecodeStringBytes() (s string, err error) {
 298         buf, err := p.DecodeRawBytes(false)
 299         if err != nil {
 300                 return
 301         }
 302         return string(buf), nil
 303 }
 304
 305 // Unmarshaler is the interface representing objects that can
 306 // unmarshal themselves.  The argument points to data that may be
 307 // overwritten, so implementations should not keep references to the
 308 // buffer.
 309 // Unmarshal implementations should not clear the receiver.
 310 // Any unmarshaled data should be merged into the receiver.
 311 // Callers of Unmarshal that do not want to retain existing data
 312 // should Reset the receiver before calling Unmarshal.
 313 type Unmarshaler interface {
 314         Unmarshal([]byte) error
 315 }
 316
 317 // newUnmarshaler is the interface representing objects that can
 318 // unmarshal themselves. The semantics are identical to Unmarshaler.
 319 //
 320 // This exists to support protoc-gen-go generated messages.
 321 // The proto package will stop type-asserting to this interface in the future.
 322 //
 323 // DO NOT DEPEND ON THIS.
 324 type newUnmarshaler interface {
 325         XXX_Unmarshal([]byte) error
 326 }
 327
 328 // Unmarshal parses the protocol buffer representation in buf and places the
 329 // decoded result in pb.  If the struct underlying pb does not match
 330 // the data in buf, the results can be unpredictable.
 331 //
 332 // Unmarshal resets pb before starting to unmarshal, so any
 333 // existing data in pb is always removed. Use UnmarshalMerge
 334 // to preserve and append to existing data.
 335 func Unmarshal(buf []byte, pb Message) error {
 336         pb.Reset()
 337         if u, ok := pb.(newUnmarshaler); ok {
 338                 return u.XXX_Unmarshal(buf)
 339         }
 340         if u, ok := pb.(Unmarshaler); ok {
 341                 return u.Unmarshal(buf)
 342         }
 343         return NewBuffer(buf).Unmarshal(pb)
 344 }
 345
 346 // UnmarshalMerge parses the protocol buffer representation in buf and
 347 // writes the decoded result to pb.  If the struct underlying pb does not match
 348 // the data in buf, the results can be unpredictable.
 349 //
 350 // UnmarshalMerge merges into existing data in pb.
 351 // Most code should use Unmarshal instead.
 352 func UnmarshalMerge(buf []byte, pb Message) error {
 353         if u, ok := pb.(newUnmarshaler); ok {
 354                 return u.XXX_Unmarshal(buf)
 355         }
 356         if u, ok := pb.(Unmarshaler); ok {
 357                 // NOTE: The history of proto have unfortunately been inconsistent
 358                 // whether Unmarshaler should or should not implicitly clear itself.
 359                 // Some implementations do, most do not.
 360                 // Thus, calling this here may or may not do what people want.
 361                 //
 362                 // See https://github.com/golang/protobuf/issues/424
 363                 return u.Unmarshal(buf)
 364         }
 365         return NewBuffer(buf).Unmarshal(pb)
 366 }
 367
 368 // DecodeMessage reads a count-delimited message from the Buffer.
 369 func (p *Buffer) DecodeMessage(pb Message) error {
 370         enc, err := p.DecodeRawBytes(false)
 371         if err != nil {
 372                 return err
 373         }
 374         return NewBuffer(enc).Unmarshal(pb)
 375 }
 376
 377 // DecodeGroup reads a tag-delimited group from the Buffer.
 378 // StartGroup tag is already consumed. This function consumes
 379 // EndGroup tag.
 380 func (p *Buffer) DecodeGroup(pb Message) error {
 381         b := p.buf[p.index:]
 382         x, y := findEndGroup(b)
 383         if x < 0 {
 384                 return io.ErrUnexpectedEOF
 385         }
 386         err := Unmarshal(b[:x], pb)
 387         p.index += y
 388         return err
 389 }
 390
 391 // Unmarshal parses the protocol buffer representation in the
 392 // Buffer and places the decoded result in pb.  If the struct
 393 // underlying pb does not match the data in the buffer, the results can be
 394 // unpredictable.
 395 //
 396 // Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
 397 func (p *Buffer) Unmarshal(pb Message) error {
 398         // If the object can unmarshal itself, let it.
 399         if u, ok := pb.(newUnmarshaler); ok {
 400                 err := u.XXX_Unmarshal(p.buf[p.index:])
 401                 p.index = len(p.buf)
 402                 return err
 403         }
 404         if u, ok := pb.(Unmarshaler); ok {
 405                 // NOTE: The history of proto have unfortunately been inconsistent
 406                 // whether Unmarshaler should or should not implicitly clear itself.
 407                 // Some implementations do, most do not.
 408                 // Thus, calling this here may or may not do what people want.
 409                 //
 410                 // See https://github.com/golang/protobuf/issues/424
 411                 err := u.Unmarshal(p.buf[p.index:])
 412                 p.index = len(p.buf)
 413                 return err
 414         }
 415
 416         // Slow workaround for messages that aren't Unmarshalers.
 417         // This includes some hand-coded .pb.go files and
 418         // bootstrap protos.
 419         // TODO: fix all of those and then add Unmarshal to
 420         // the Message interface. Then:
 421         // The cast above and code below can be deleted.
 422         // The old unmarshaler can be deleted.
 423         // Clients can call Unmarshal directly (can already do that, actually).
 424         var info InternalMessageInfo
 425         err := info.Unmarshal(pb, p.buf[p.index:])
 426         p.index = len(p.buf)
 427         return err
 428 }