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 190 return 0, errOverflow 191 192 done: 193 p.index = i 194 return x, nil 195 } 196 197 // DecodeFixed64 reads a 64-bit integer from the Buffer. 198 // This is the format for the 199 // fixed64, sfixed64, and double protocol buffer types. 200 func (p *Buffer) DecodeFixed64() (x uint64, err error) { 201 // x, err already 0 202 i := p.index + 8 203 if i < 0 || i > len(p.buf) { 204 err = io.ErrUnexpectedEOF 205 return 206 } 207 p.index = i 208 209 x = uint64(p.buf[i-8]) 210 x |= uint64(p.buf[i-7]) << 8 211 x |= uint64(p.buf[i-6]) << 16 212 x |= uint64(p.buf[i-5]) << 24 213 x |= uint64(p.buf[i-4]) << 32 214 x |= uint64(p.buf[i-3]) << 40 215 x |= uint64(p.buf[i-2]) << 48 216 x |= uint64(p.buf[i-1]) << 56 217 return 218 } 219 220 // DecodeFixed32 reads a 32-bit integer from the Buffer. 221 // This is the format for the 222 // fixed32, sfixed32, and float protocol buffer types. 223 func (p *Buffer) DecodeFixed32() (x uint64, err error) { 224 // x, err already 0 225 i := p.index + 4 226 if i < 0 || i > len(p.buf) { 227 err = io.ErrUnexpectedEOF 228 return 229 } 230 p.index = i 231 232 x = uint64(p.buf[i-4]) 233 x |= uint64(p.buf[i-3]) << 8 234 x |= uint64(p.buf[i-2]) << 16 235 x |= uint64(p.buf[i-1]) << 24 236 return 237 } 238 239 // DecodeZigzag64 reads a zigzag-encoded 64-bit integer 240 // from the Buffer. 241 // This is the format used for the sint64 protocol buffer type. 242 func (p *Buffer) DecodeZigzag64() (x uint64, err error) { 243 x, err = p.DecodeVarint() 244 if err != nil { 245 return 246 } 247 x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) 248 return 249 } 250 251 // DecodeZigzag32 reads a zigzag-encoded 32-bit integer 252 // from the Buffer. 253 // This is the format used for the sint32 protocol buffer type. 254 func (p *Buffer) DecodeZigzag32() (x uint64, err error) { 255 x, err = p.DecodeVarint() 256 if err != nil { 257 return 258 } 259 x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) 260 return 261 } 262 263 // DecodeRawBytes reads a count-delimited byte buffer from the Buffer. 264 // This is the format used for the bytes protocol buffer 265 // type and for embedded messages. 266 func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { 267 n, err := p.DecodeVarint() 268 if err != nil { 269 return nil, err 270 } 271 272 nb := int(n) 273 if nb < 0 { 274 return nil, fmt.Errorf("proto: bad byte length %d", nb) 275 } 276 end := p.index + nb 277 if end < p.index || end > len(p.buf) { 278 return nil, io.ErrUnexpectedEOF 279 } 280 281 if !alloc { 282 // todo: check if can get more uses of alloc=false 283 buf = p.buf[p.index:end] 284 p.index += nb 285 return 286 } 287 288 buf = make([]byte, nb) 289 copy(buf, p.buf[p.index:]) 290 p.index += nb 291 return 292 } 293 294 // DecodeStringBytes reads an encoded string from the Buffer. 295 // This is the format used for the proto2 string type. 296 func (p *Buffer) DecodeStringBytes() (s string, err error) { 297 buf, err := p.DecodeRawBytes(false) 298 if err != nil { 299 return 300 } 301 return string(buf), nil 302 } 303 304 // Unmarshaler is the interface representing objects that can 305 // unmarshal themselves. The argument points to data that may be 306 // overwritten, so implementations should not keep references to the 307 // buffer. 308 // Unmarshal implementations should not clear the receiver. 309 // Any unmarshaled data should be merged into the receiver. 310 // Callers of Unmarshal that do not want to retain existing data 311 // should Reset the receiver before calling Unmarshal. 312 type Unmarshaler interface { 313 Unmarshal([]byte) error 314 } 315 316 // newUnmarshaler is the interface representing objects that can 317 // unmarshal themselves. The semantics are identical to Unmarshaler. 318 // 319 // This exists to support protoc-gen-go generated messages. 320 // The proto package will stop type-asserting to this interface in the future. 321 // 322 // DO NOT DEPEND ON THIS. 323 type newUnmarshaler interface { 324 XXX_Unmarshal([]byte) error 325 } 326 327 // Unmarshal parses the protocol buffer representation in buf and places the 328 // decoded result in pb. If the struct underlying pb does not match 329 // the data in buf, the results can be unpredictable. 330 // 331 // Unmarshal resets pb before starting to unmarshal, so any 332 // existing data in pb is always removed. Use UnmarshalMerge 333 // to preserve and append to existing data. 334 func Unmarshal(buf []byte, pb Message) error { 335 pb.Reset() 336 if u, ok := pb.(newUnmarshaler); ok { 337 return u.XXX_Unmarshal(buf) 338 } 339 if u, ok := pb.(Unmarshaler); ok { 340 return u.Unmarshal(buf) 341 } 342 return NewBuffer(buf).Unmarshal(pb) 343 } 344 345 // UnmarshalMerge parses the protocol buffer representation in buf and 346 // writes the decoded result to pb. If the struct underlying pb does not match 347 // the data in buf, the results can be unpredictable. 348 // 349 // UnmarshalMerge merges into existing data in pb. 350 // Most code should use Unmarshal instead. 351 func UnmarshalMerge(buf []byte, pb Message) error { 352 if u, ok := pb.(newUnmarshaler); ok { 353 return u.XXX_Unmarshal(buf) 354 } 355 if u, ok := pb.(Unmarshaler); ok { 356 // NOTE: The history of proto have unfortunately been inconsistent 357 // whether Unmarshaler should or should not implicitly clear itself. 358 // Some implementations do, most do not. 359 // Thus, calling this here may or may not do what people want. 360 // 361 // See https://github.com/golang/protobuf/issues/424 362 return u.Unmarshal(buf) 363 } 364 return NewBuffer(buf).Unmarshal(pb) 365 } 366 367 // DecodeMessage reads a count-delimited message from the Buffer. 368 func (p *Buffer) DecodeMessage(pb Message) error { 369 enc, err := p.DecodeRawBytes(false) 370 if err != nil { 371 return err 372 } 373 return NewBuffer(enc).Unmarshal(pb) 374 } 375 376 // DecodeGroup reads a tag-delimited group from the Buffer. 377 // StartGroup tag is already consumed. This function consumes 378 // EndGroup tag. 379 func (p *Buffer) DecodeGroup(pb Message) error { 380 b := p.buf[p.index:] 381 x, y := findEndGroup(b) 382 if x < 0 { 383 return io.ErrUnexpectedEOF 384 } 385 err := Unmarshal(b[:x], pb) 386 p.index += y 387 return err 388 } 389 390 // Unmarshal parses the protocol buffer representation in the 391 // Buffer and places the decoded result in pb. If the struct 392 // underlying pb does not match the data in the buffer, the results can be 393 // unpredictable. 394 // 395 // Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal. 396 func (p *Buffer) Unmarshal(pb Message) error { 397 // If the object can unmarshal itself, let it. 398 if u, ok := pb.(newUnmarshaler); ok { 399 err := u.XXX_Unmarshal(p.buf[p.index:]) 400 p.index = len(p.buf) 401 return err 402 } 403 if u, ok := pb.(Unmarshaler); ok { 404 // NOTE: The history of proto have unfortunately been inconsistent 405 // whether Unmarshaler should or should not implicitly clear itself. 406 // Some implementations do, most do not. 407 // Thus, calling this here may or may not do what people want. 408 // 409 // See https://github.com/golang/protobuf/issues/424 410 err := u.Unmarshal(p.buf[p.index:]) 411 p.index = len(p.buf) 412 return err 413 } 414 415 // Slow workaround for messages that aren't Unmarshalers. 416 // This includes some hand-coded .pb.go files and 417 // bootstrap protos. 418 // TODO: fix all of those and then add Unmarshal to 419 // the Message interface. Then: 420 // The cast above and code below can be deleted. 421 // The old unmarshaler can be deleted. 422 // Clients can call Unmarshal directly (can already do that, actually). 423 var info InternalMessageInfo 424 err := info.Unmarshal(pb, p.buf[p.index:]) 425 p.index = len(p.buf) 426 return err 427 } 428