1package msgp 2 3import ( 4 "io" 5 "math" 6 "sync" 7 "time" 8 9 "github.com/philhofer/fwd" 10) 11 12// where we keep old *Readers 13var readerPool = sync.Pool{New: func() interface{} { return &Reader{} }} 14 15// Type is a MessagePack wire type, 16// including this package's built-in 17// extension types. 18type Type byte 19 20// MessagePack Types 21// 22// The zero value of Type 23// is InvalidType. 24const ( 25 InvalidType Type = iota 26 27 // MessagePack built-in types 28 29 StrType 30 BinType 31 MapType 32 ArrayType 33 Float64Type 34 Float32Type 35 BoolType 36 IntType 37 UintType 38 NilType 39 ExtensionType 40 41 // pseudo-types provided 42 // by extensions 43 44 Complex64Type 45 Complex128Type 46 TimeType 47 48 _maxtype 49) 50 51// String implements fmt.Stringer 52func (t Type) String() string { 53 switch t { 54 case StrType: 55 return "str" 56 case BinType: 57 return "bin" 58 case MapType: 59 return "map" 60 case ArrayType: 61 return "array" 62 case Float64Type: 63 return "float64" 64 case Float32Type: 65 return "float32" 66 case BoolType: 67 return "bool" 68 case UintType: 69 return "uint" 70 case IntType: 71 return "int" 72 case ExtensionType: 73 return "ext" 74 case NilType: 75 return "nil" 76 default: 77 return "<invalid>" 78 } 79} 80 81func freeR(m *Reader) { 82 readerPool.Put(m) 83} 84 85// Unmarshaler is the interface fulfilled 86// by objects that know how to unmarshal 87// themselves from MessagePack. 88// UnmarshalMsg unmarshals the object 89// from binary, returing any leftover 90// bytes and any errors encountered. 91type Unmarshaler interface { 92 UnmarshalMsg([]byte) ([]byte, error) 93} 94 95// Decodable is the interface fulfilled 96// by objects that know how to read 97// themselves from a *Reader. 98type Decodable interface { 99 DecodeMsg(*Reader) error 100} 101 102// Decode decodes 'd' from 'r'. 103func Decode(r io.Reader, d Decodable) error { 104 rd := NewReader(r) 105 err := d.DecodeMsg(rd) 106 freeR(rd) 107 return err 108} 109 110// NewReader returns a *Reader that 111// reads from the provided reader. The 112// reader will be buffered. 113func NewReader(r io.Reader) *Reader { 114 p := readerPool.Get().(*Reader) 115 if p.R == nil { 116 p.R = fwd.NewReader(r) 117 } else { 118 p.R.Reset(r) 119 } 120 return p 121} 122 123// NewReaderSize returns a *Reader with a buffer of the given size. 124// (This is vastly preferable to passing the decoder a reader that is already buffered.) 125func NewReaderSize(r io.Reader, sz int) *Reader { 126 return &Reader{R: fwd.NewReaderSize(r, sz)} 127} 128 129// Reader wraps an io.Reader and provides 130// methods to read MessagePack-encoded values 131// from it. Readers are buffered. 132type Reader struct { 133 // R is the buffered reader 134 // that the Reader uses 135 // to decode MessagePack. 136 // The Reader itself 137 // is stateless; all the 138 // buffering is done 139 // within R. 140 R *fwd.Reader 141 scratch []byte 142} 143 144// Read implements `io.Reader` 145func (m *Reader) Read(p []byte) (int, error) { 146 return m.R.Read(p) 147} 148 149// CopyNext reads the next object from m without decoding it and writes it to w. 150// It avoids unnecessary copies internally. 151func (m *Reader) CopyNext(w io.Writer) (int64, error) { 152 sz, o, err := getNextSize(m.R) 153 if err != nil { 154 return 0, err 155 } 156 157 var n int64 158 // Opportunistic optimization: if we can fit the whole thing in the m.R 159 // buffer, then just get a pointer to that, and pass it to w.Write, 160 // avoiding an allocation. 161 if int(sz) <= m.R.BufferSize() { 162 var nn int 163 var buf []byte 164 buf, err = m.R.Next(int(sz)) 165 if err != nil { 166 if err == io.ErrUnexpectedEOF { 167 err = ErrShortBytes 168 } 169 return 0, err 170 } 171 nn, err = w.Write(buf) 172 n += int64(nn) 173 } else { 174 // Fall back to io.CopyN. 175 // May avoid allocating if w is a ReaderFrom (e.g. bytes.Buffer) 176 n, err = io.CopyN(w, m.R, int64(sz)) 177 if err == io.ErrUnexpectedEOF { 178 err = ErrShortBytes 179 } 180 } 181 if err != nil { 182 return n, err 183 } else if n < int64(sz) { 184 return n, io.ErrShortWrite 185 } 186 187 // for maps and slices, read elements 188 for x := uintptr(0); x < o; x++ { 189 var n2 int64 190 n2, err = m.CopyNext(w) 191 if err != nil { 192 return n, err 193 } 194 n += n2 195 } 196 return n, nil 197} 198 199// ReadFull implements `io.ReadFull` 200func (m *Reader) ReadFull(p []byte) (int, error) { 201 return m.R.ReadFull(p) 202} 203 204// Reset resets the underlying reader. 205func (m *Reader) Reset(r io.Reader) { m.R.Reset(r) } 206 207// Buffered returns the number of bytes currently in the read buffer. 208func (m *Reader) Buffered() int { return m.R.Buffered() } 209 210// BufferSize returns the capacity of the read buffer. 211func (m *Reader) BufferSize() int { return m.R.BufferSize() } 212 213// NextType returns the next object type to be decoded. 214func (m *Reader) NextType() (Type, error) { 215 p, err := m.R.Peek(1) 216 if err != nil { 217 return InvalidType, err 218 } 219 t := getType(p[0]) 220 if t == InvalidType { 221 return t, InvalidPrefixError(p[0]) 222 } 223 if t == ExtensionType { 224 v, err := m.peekExtensionType() 225 if err != nil { 226 return InvalidType, err 227 } 228 switch v { 229 case Complex64Extension: 230 return Complex64Type, nil 231 case Complex128Extension: 232 return Complex128Type, nil 233 case TimeExtension: 234 return TimeType, nil 235 } 236 } 237 return t, nil 238} 239 240// IsNil returns whether or not 241// the next byte is a null messagepack byte 242func (m *Reader) IsNil() bool { 243 p, err := m.R.Peek(1) 244 return err == nil && p[0] == mnil 245} 246 247// getNextSize returns the size of the next object on the wire. 248// returns (obj size, obj elements, error) 249// only maps and arrays have non-zero obj elements 250// for maps and arrays, obj size does not include elements 251// 252// use uintptr b/c it's guaranteed to be large enough 253// to hold whatever we can fit in memory. 254func getNextSize(r *fwd.Reader) (uintptr, uintptr, error) { 255 b, err := r.Peek(1) 256 if err != nil { 257 return 0, 0, err 258 } 259 lead := b[0] 260 spec := &sizes[lead] 261 size, mode := spec.size, spec.extra 262 if size == 0 { 263 return 0, 0, InvalidPrefixError(lead) 264 } 265 if mode >= 0 { 266 return uintptr(size), uintptr(mode), nil 267 } 268 b, err = r.Peek(int(size)) 269 if err != nil { 270 return 0, 0, err 271 } 272 switch mode { 273 case extra8: 274 return uintptr(size) + uintptr(b[1]), 0, nil 275 case extra16: 276 return uintptr(size) + uintptr(big.Uint16(b[1:])), 0, nil 277 case extra32: 278 return uintptr(size) + uintptr(big.Uint32(b[1:])), 0, nil 279 case map16v: 280 return uintptr(size), 2 * uintptr(big.Uint16(b[1:])), nil 281 case map32v: 282 return uintptr(size), 2 * uintptr(big.Uint32(b[1:])), nil 283 case array16v: 284 return uintptr(size), uintptr(big.Uint16(b[1:])), nil 285 case array32v: 286 return uintptr(size), uintptr(big.Uint32(b[1:])), nil 287 default: 288 return 0, 0, fatal 289 } 290} 291 292// Skip skips over the next object, regardless of 293// its type. If it is an array or map, the whole array 294// or map will be skipped. 295func (m *Reader) Skip() error { 296 var ( 297 v uintptr // bytes 298 o uintptr // objects 299 err error 300 p []byte 301 ) 302 303 // we can use the faster 304 // method if we have enough 305 // buffered data 306 if m.R.Buffered() >= 5 { 307 p, err = m.R.Peek(5) 308 if err != nil { 309 return err 310 } 311 v, o, err = getSize(p) 312 if err != nil { 313 return err 314 } 315 } else { 316 v, o, err = getNextSize(m.R) 317 if err != nil { 318 return err 319 } 320 } 321 322 // 'v' is always non-zero 323 // if err == nil 324 _, err = m.R.Skip(int(v)) 325 if err != nil { 326 return err 327 } 328 329 // for maps and slices, skip elements 330 for x := uintptr(0); x < o; x++ { 331 err = m.Skip() 332 if err != nil { 333 return err 334 } 335 } 336 return nil 337} 338 339// ReadMapHeader reads the next object 340// as a map header and returns the size 341// of the map and the number of bytes written. 342// It will return a TypeError{} if the next 343// object is not a map. 344func (m *Reader) ReadMapHeader() (sz uint32, err error) { 345 var p []byte 346 var lead byte 347 p, err = m.R.Peek(1) 348 if err != nil { 349 return 350 } 351 lead = p[0] 352 if isfixmap(lead) { 353 sz = uint32(rfixmap(lead)) 354 _, err = m.R.Skip(1) 355 return 356 } 357 switch lead { 358 case mmap16: 359 p, err = m.R.Next(3) 360 if err != nil { 361 return 362 } 363 sz = uint32(big.Uint16(p[1:])) 364 return 365 case mmap32: 366 p, err = m.R.Next(5) 367 if err != nil { 368 return 369 } 370 sz = big.Uint32(p[1:]) 371 return 372 default: 373 err = badPrefix(MapType, lead) 374 return 375 } 376} 377 378// ReadMapKey reads either a 'str' or 'bin' field from 379// the reader and returns the value as a []byte. It uses 380// scratch for storage if it is large enough. 381func (m *Reader) ReadMapKey(scratch []byte) ([]byte, error) { 382 out, err := m.ReadStringAsBytes(scratch) 383 if err != nil { 384 if tperr, ok := err.(TypeError); ok && tperr.Encoded == BinType { 385 return m.ReadBytes(scratch) 386 } 387 return nil, err 388 } 389 return out, nil 390} 391 392// MapKeyPtr returns a []byte pointing to the contents 393// of a valid map key. The key cannot be empty, and it 394// must be shorter than the total buffer size of the 395// *Reader. Additionally, the returned slice is only 396// valid until the next *Reader method call. Users 397// should exercise extreme care when using this 398// method; writing into the returned slice may 399// corrupt future reads. 400func (m *Reader) ReadMapKeyPtr() ([]byte, error) { 401 p, err := m.R.Peek(1) 402 if err != nil { 403 return nil, err 404 } 405 lead := p[0] 406 var read int 407 if isfixstr(lead) { 408 read = int(rfixstr(lead)) 409 m.R.Skip(1) 410 goto fill 411 } 412 switch lead { 413 case mstr8, mbin8: 414 p, err = m.R.Next(2) 415 if err != nil { 416 return nil, err 417 } 418 read = int(p[1]) 419 case mstr16, mbin16: 420 p, err = m.R.Next(3) 421 if err != nil { 422 return nil, err 423 } 424 read = int(big.Uint16(p[1:])) 425 case mstr32, mbin32: 426 p, err = m.R.Next(5) 427 if err != nil { 428 return nil, err 429 } 430 read = int(big.Uint32(p[1:])) 431 default: 432 return nil, badPrefix(StrType, lead) 433 } 434fill: 435 if read == 0 { 436 return nil, ErrShortBytes 437 } 438 return m.R.Next(read) 439} 440 441// ReadArrayHeader reads the next object as an 442// array header and returns the size of the array 443// and the number of bytes read. 444func (m *Reader) ReadArrayHeader() (sz uint32, err error) { 445 var lead byte 446 var p []byte 447 p, err = m.R.Peek(1) 448 if err != nil { 449 return 450 } 451 lead = p[0] 452 if isfixarray(lead) { 453 sz = uint32(rfixarray(lead)) 454 _, err = m.R.Skip(1) 455 return 456 } 457 switch lead { 458 case marray16: 459 p, err = m.R.Next(3) 460 if err != nil { 461 return 462 } 463 sz = uint32(big.Uint16(p[1:])) 464 return 465 466 case marray32: 467 p, err = m.R.Next(5) 468 if err != nil { 469 return 470 } 471 sz = big.Uint32(p[1:]) 472 return 473 474 default: 475 err = badPrefix(ArrayType, lead) 476 return 477 } 478} 479 480// ReadNil reads a 'nil' MessagePack byte from the reader 481func (m *Reader) ReadNil() error { 482 p, err := m.R.Peek(1) 483 if err != nil { 484 return err 485 } 486 if p[0] != mnil { 487 return badPrefix(NilType, p[0]) 488 } 489 _, err = m.R.Skip(1) 490 return err 491} 492 493// ReadFloat64 reads a float64 from the reader. 494// (If the value on the wire is encoded as a float32, 495// it will be up-cast to a float64.) 496func (m *Reader) ReadFloat64() (f float64, err error) { 497 var p []byte 498 p, err = m.R.Peek(9) 499 if err != nil { 500 // we'll allow a coversion from float32 to float64, 501 // since we don't lose any precision 502 if err == io.EOF && len(p) > 0 && p[0] == mfloat32 { 503 ef, err := m.ReadFloat32() 504 return float64(ef), err 505 } 506 return 507 } 508 if p[0] != mfloat64 { 509 // see above 510 if p[0] == mfloat32 { 511 ef, err := m.ReadFloat32() 512 return float64(ef), err 513 } 514 err = badPrefix(Float64Type, p[0]) 515 return 516 } 517 f = math.Float64frombits(getMuint64(p)) 518 _, err = m.R.Skip(9) 519 return 520} 521 522// ReadFloat32 reads a float32 from the reader 523func (m *Reader) ReadFloat32() (f float32, err error) { 524 var p []byte 525 p, err = m.R.Peek(5) 526 if err != nil { 527 return 528 } 529 if p[0] != mfloat32 { 530 err = badPrefix(Float32Type, p[0]) 531 return 532 } 533 f = math.Float32frombits(getMuint32(p)) 534 _, err = m.R.Skip(5) 535 return 536} 537 538// ReadBool reads a bool from the reader 539func (m *Reader) ReadBool() (b bool, err error) { 540 var p []byte 541 p, err = m.R.Peek(1) 542 if err != nil { 543 return 544 } 545 switch p[0] { 546 case mtrue: 547 b = true 548 case mfalse: 549 default: 550 err = badPrefix(BoolType, p[0]) 551 return 552 } 553 _, err = m.R.Skip(1) 554 return 555} 556 557// ReadInt64 reads an int64 from the reader 558func (m *Reader) ReadInt64() (i int64, err error) { 559 var p []byte 560 var lead byte 561 p, err = m.R.Peek(1) 562 if err != nil { 563 return 564 } 565 lead = p[0] 566 567 if isfixint(lead) { 568 i = int64(rfixint(lead)) 569 _, err = m.R.Skip(1) 570 return 571 } else if isnfixint(lead) { 572 i = int64(rnfixint(lead)) 573 _, err = m.R.Skip(1) 574 return 575 } 576 577 switch lead { 578 case mint8: 579 p, err = m.R.Next(2) 580 if err != nil { 581 return 582 } 583 i = int64(getMint8(p)) 584 return 585 586 case muint8: 587 p, err = m.R.Next(2) 588 if err != nil { 589 return 590 } 591 i = int64(getMuint8(p)) 592 return 593 594 case mint16: 595 p, err = m.R.Next(3) 596 if err != nil { 597 return 598 } 599 i = int64(getMint16(p)) 600 return 601 602 case muint16: 603 p, err = m.R.Next(3) 604 if err != nil { 605 return 606 } 607 i = int64(getMuint16(p)) 608 return 609 610 case mint32: 611 p, err = m.R.Next(5) 612 if err != nil { 613 return 614 } 615 i = int64(getMint32(p)) 616 return 617 618 case muint32: 619 p, err = m.R.Next(5) 620 if err != nil { 621 return 622 } 623 i = int64(getMuint32(p)) 624 return 625 626 case mint64: 627 p, err = m.R.Next(9) 628 if err != nil { 629 return 630 } 631 i = getMint64(p) 632 return 633 634 case muint64: 635 p, err = m.R.Next(9) 636 if err != nil { 637 return 638 } 639 u := getMuint64(p) 640 if u > math.MaxInt64 { 641 err = UintOverflow{Value: u, FailedBitsize: 64} 642 return 643 } 644 i = int64(u) 645 return 646 647 default: 648 err = badPrefix(IntType, lead) 649 return 650 } 651} 652 653// ReadInt32 reads an int32 from the reader 654func (m *Reader) ReadInt32() (i int32, err error) { 655 var in int64 656 in, err = m.ReadInt64() 657 if in > math.MaxInt32 || in < math.MinInt32 { 658 err = IntOverflow{Value: in, FailedBitsize: 32} 659 return 660 } 661 i = int32(in) 662 return 663} 664 665// ReadInt16 reads an int16 from the reader 666func (m *Reader) ReadInt16() (i int16, err error) { 667 var in int64 668 in, err = m.ReadInt64() 669 if in > math.MaxInt16 || in < math.MinInt16 { 670 err = IntOverflow{Value: in, FailedBitsize: 16} 671 return 672 } 673 i = int16(in) 674 return 675} 676 677// ReadInt8 reads an int8 from the reader 678func (m *Reader) ReadInt8() (i int8, err error) { 679 var in int64 680 in, err = m.ReadInt64() 681 if in > math.MaxInt8 || in < math.MinInt8 { 682 err = IntOverflow{Value: in, FailedBitsize: 8} 683 return 684 } 685 i = int8(in) 686 return 687} 688 689// ReadInt reads an int from the reader 690func (m *Reader) ReadInt() (i int, err error) { 691 if smallint { 692 var in int32 693 in, err = m.ReadInt32() 694 i = int(in) 695 return 696 } 697 var in int64 698 in, err = m.ReadInt64() 699 i = int(in) 700 return 701} 702 703// ReadUint64 reads a uint64 from the reader 704func (m *Reader) ReadUint64() (u uint64, err error) { 705 var p []byte 706 var lead byte 707 p, err = m.R.Peek(1) 708 if err != nil { 709 return 710 } 711 lead = p[0] 712 if isfixint(lead) { 713 u = uint64(rfixint(lead)) 714 _, err = m.R.Skip(1) 715 return 716 } 717 switch lead { 718 case mint8: 719 p, err = m.R.Next(2) 720 if err != nil { 721 return 722 } 723 v := int64(getMint8(p)) 724 if v < 0 { 725 err = UintBelowZero{Value: v} 726 return 727 } 728 u = uint64(v) 729 return 730 731 case muint8: 732 p, err = m.R.Next(2) 733 if err != nil { 734 return 735 } 736 u = uint64(getMuint8(p)) 737 return 738 739 case mint16: 740 p, err = m.R.Next(3) 741 if err != nil { 742 return 743 } 744 v := int64(getMint16(p)) 745 if v < 0 { 746 err = UintBelowZero{Value: v} 747 return 748 } 749 u = uint64(v) 750 return 751 752 case muint16: 753 p, err = m.R.Next(3) 754 if err != nil { 755 return 756 } 757 u = uint64(getMuint16(p)) 758 return 759 760 case mint32: 761 p, err = m.R.Next(5) 762 if err != nil { 763 return 764 } 765 v := int64(getMint32(p)) 766 if v < 0 { 767 err = UintBelowZero{Value: v} 768 return 769 } 770 u = uint64(v) 771 return 772 773 case muint32: 774 p, err = m.R.Next(5) 775 if err != nil { 776 return 777 } 778 u = uint64(getMuint32(p)) 779 return 780 781 case mint64: 782 p, err = m.R.Next(9) 783 if err != nil { 784 return 785 } 786 v := int64(getMint64(p)) 787 if v < 0 { 788 err = UintBelowZero{Value: v} 789 return 790 } 791 u = uint64(v) 792 return 793 794 case muint64: 795 p, err = m.R.Next(9) 796 if err != nil { 797 return 798 } 799 u = getMuint64(p) 800 return 801 802 default: 803 if isnfixint(lead) { 804 err = UintBelowZero{Value: int64(rnfixint(lead))} 805 } else { 806 err = badPrefix(UintType, lead) 807 } 808 return 809 810 } 811} 812 813// ReadUint32 reads a uint32 from the reader 814func (m *Reader) ReadUint32() (u uint32, err error) { 815 var in uint64 816 in, err = m.ReadUint64() 817 if in > math.MaxUint32 { 818 err = UintOverflow{Value: in, FailedBitsize: 32} 819 return 820 } 821 u = uint32(in) 822 return 823} 824 825// ReadUint16 reads a uint16 from the reader 826func (m *Reader) ReadUint16() (u uint16, err error) { 827 var in uint64 828 in, err = m.ReadUint64() 829 if in > math.MaxUint16 { 830 err = UintOverflow{Value: in, FailedBitsize: 16} 831 return 832 } 833 u = uint16(in) 834 return 835} 836 837// ReadUint8 reads a uint8 from the reader 838func (m *Reader) ReadUint8() (u uint8, err error) { 839 var in uint64 840 in, err = m.ReadUint64() 841 if in > math.MaxUint8 { 842 err = UintOverflow{Value: in, FailedBitsize: 8} 843 return 844 } 845 u = uint8(in) 846 return 847} 848 849// ReadUint reads a uint from the reader 850func (m *Reader) ReadUint() (u uint, err error) { 851 if smallint { 852 var un uint32 853 un, err = m.ReadUint32() 854 u = uint(un) 855 return 856 } 857 var un uint64 858 un, err = m.ReadUint64() 859 u = uint(un) 860 return 861} 862 863// ReadByte is analogous to ReadUint8. 864// 865// NOTE: this is *not* an implementation 866// of io.ByteReader. 867func (m *Reader) ReadByte() (b byte, err error) { 868 var in uint64 869 in, err = m.ReadUint64() 870 if in > math.MaxUint8 { 871 err = UintOverflow{Value: in, FailedBitsize: 8} 872 return 873 } 874 b = byte(in) 875 return 876} 877 878// ReadBytes reads a MessagePack 'bin' object 879// from the reader and returns its value. It may 880// use 'scratch' for storage if it is non-nil. 881func (m *Reader) ReadBytes(scratch []byte) (b []byte, err error) { 882 var p []byte 883 var lead byte 884 p, err = m.R.Peek(2) 885 if err != nil { 886 return 887 } 888 lead = p[0] 889 var read int64 890 switch lead { 891 case mbin8: 892 read = int64(p[1]) 893 m.R.Skip(2) 894 case mbin16: 895 p, err = m.R.Next(3) 896 if err != nil { 897 return 898 } 899 read = int64(big.Uint16(p[1:])) 900 case mbin32: 901 p, err = m.R.Next(5) 902 if err != nil { 903 return 904 } 905 read = int64(big.Uint32(p[1:])) 906 default: 907 err = badPrefix(BinType, lead) 908 return 909 } 910 if int64(cap(scratch)) < read { 911 b = make([]byte, read) 912 } else { 913 b = scratch[0:read] 914 } 915 _, err = m.R.ReadFull(b) 916 return 917} 918 919// ReadBytesHeader reads the size header 920// of a MessagePack 'bin' object. The user 921// is responsible for dealing with the next 922// 'sz' bytes from the reader in an application-specific 923// way. 924func (m *Reader) ReadBytesHeader() (sz uint32, err error) { 925 var p []byte 926 p, err = m.R.Peek(1) 927 if err != nil { 928 return 929 } 930 switch p[0] { 931 case mbin8: 932 p, err = m.R.Next(2) 933 if err != nil { 934 return 935 } 936 sz = uint32(p[1]) 937 return 938 case mbin16: 939 p, err = m.R.Next(3) 940 if err != nil { 941 return 942 } 943 sz = uint32(big.Uint16(p[1:])) 944 return 945 case mbin32: 946 p, err = m.R.Next(5) 947 if err != nil { 948 return 949 } 950 sz = uint32(big.Uint32(p[1:])) 951 return 952 default: 953 err = badPrefix(BinType, p[0]) 954 return 955 } 956} 957 958// ReadExactBytes reads a MessagePack 'bin'-encoded 959// object off of the wire into the provided slice. An 960// ArrayError will be returned if the object is not 961// exactly the length of the input slice. 962func (m *Reader) ReadExactBytes(into []byte) error { 963 p, err := m.R.Peek(2) 964 if err != nil { 965 return err 966 } 967 lead := p[0] 968 var read int64 // bytes to read 969 var skip int // prefix size to skip 970 switch lead { 971 case mbin8: 972 read = int64(p[1]) 973 skip = 2 974 case mbin16: 975 p, err = m.R.Peek(3) 976 if err != nil { 977 return err 978 } 979 read = int64(big.Uint16(p[1:])) 980 skip = 3 981 case mbin32: 982 p, err = m.R.Peek(5) 983 if err != nil { 984 return err 985 } 986 read = int64(big.Uint32(p[1:])) 987 skip = 5 988 default: 989 return badPrefix(BinType, lead) 990 } 991 if read != int64(len(into)) { 992 return ArrayError{Wanted: uint32(len(into)), Got: uint32(read)} 993 } 994 m.R.Skip(skip) 995 _, err = m.R.ReadFull(into) 996 return err 997} 998 999// ReadStringAsBytes reads a MessagePack 'str' (utf-8) string 1000// and returns its value as bytes. It may use 'scratch' for storage 1001// if it is non-nil. 1002func (m *Reader) ReadStringAsBytes(scratch []byte) (b []byte, err error) { 1003 var p []byte 1004 var lead byte 1005 p, err = m.R.Peek(1) 1006 if err != nil { 1007 return 1008 } 1009 lead = p[0] 1010 var read int64 1011 1012 if isfixstr(lead) { 1013 read = int64(rfixstr(lead)) 1014 m.R.Skip(1) 1015 goto fill 1016 } 1017 1018 switch lead { 1019 case mstr8: 1020 p, err = m.R.Next(2) 1021 if err != nil { 1022 return 1023 } 1024 read = int64(uint8(p[1])) 1025 case mstr16: 1026 p, err = m.R.Next(3) 1027 if err != nil { 1028 return 1029 } 1030 read = int64(big.Uint16(p[1:])) 1031 case mstr32: 1032 p, err = m.R.Next(5) 1033 if err != nil { 1034 return 1035 } 1036 read = int64(big.Uint32(p[1:])) 1037 default: 1038 err = badPrefix(StrType, lead) 1039 return 1040 } 1041fill: 1042 if int64(cap(scratch)) < read { 1043 b = make([]byte, read) 1044 } else { 1045 b = scratch[0:read] 1046 } 1047 _, err = m.R.ReadFull(b) 1048 return 1049} 1050 1051// ReadStringHeader reads a string header 1052// off of the wire. The user is then responsible 1053// for dealing with the next 'sz' bytes from 1054// the reader in an application-specific manner. 1055func (m *Reader) ReadStringHeader() (sz uint32, err error) { 1056 var p []byte 1057 p, err = m.R.Peek(1) 1058 if err != nil { 1059 return 1060 } 1061 lead := p[0] 1062 if isfixstr(lead) { 1063 sz = uint32(rfixstr(lead)) 1064 m.R.Skip(1) 1065 return 1066 } 1067 switch lead { 1068 case mstr8: 1069 p, err = m.R.Next(2) 1070 if err != nil { 1071 return 1072 } 1073 sz = uint32(p[1]) 1074 return 1075 case mstr16: 1076 p, err = m.R.Next(3) 1077 if err != nil { 1078 return 1079 } 1080 sz = uint32(big.Uint16(p[1:])) 1081 return 1082 case mstr32: 1083 p, err = m.R.Next(5) 1084 if err != nil { 1085 return 1086 } 1087 sz = big.Uint32(p[1:]) 1088 return 1089 default: 1090 err = badPrefix(StrType, lead) 1091 return 1092 } 1093} 1094 1095// ReadString reads a utf-8 string from the reader 1096func (m *Reader) ReadString() (s string, err error) { 1097 var p []byte 1098 var lead byte 1099 var read int64 1100 p, err = m.R.Peek(1) 1101 if err != nil { 1102 return 1103 } 1104 lead = p[0] 1105 1106 if isfixstr(lead) { 1107 read = int64(rfixstr(lead)) 1108 m.R.Skip(1) 1109 goto fill 1110 } 1111 1112 switch lead { 1113 case mstr8: 1114 p, err = m.R.Next(2) 1115 if err != nil { 1116 return 1117 } 1118 read = int64(uint8(p[1])) 1119 case mstr16: 1120 p, err = m.R.Next(3) 1121 if err != nil { 1122 return 1123 } 1124 read = int64(big.Uint16(p[1:])) 1125 case mstr32: 1126 p, err = m.R.Next(5) 1127 if err != nil { 1128 return 1129 } 1130 read = int64(big.Uint32(p[1:])) 1131 default: 1132 err = badPrefix(StrType, lead) 1133 return 1134 } 1135fill: 1136 if read == 0 { 1137 s, err = "", nil 1138 return 1139 } 1140 // reading into the memory 1141 // that will become the string 1142 // itself has vastly superior 1143 // worst-case performance, because 1144 // the reader buffer doesn't have 1145 // to be large enough to hold the string. 1146 // the idea here is to make it more 1147 // difficult for someone malicious 1148 // to cause the system to run out of 1149 // memory by sending very large strings. 1150 // 1151 // NOTE: this works because the argument 1152 // passed to (*fwd.Reader).ReadFull escapes 1153 // to the heap; its argument may, in turn, 1154 // be passed to the underlying reader, and 1155 // thus escape analysis *must* conclude that 1156 // 'out' escapes. 1157 out := make([]byte, read) 1158 _, err = m.R.ReadFull(out) 1159 if err != nil { 1160 return 1161 } 1162 s = UnsafeString(out) 1163 return 1164} 1165 1166// ReadComplex64 reads a complex64 from the reader 1167func (m *Reader) ReadComplex64() (f complex64, err error) { 1168 var p []byte 1169 p, err = m.R.Peek(10) 1170 if err != nil { 1171 return 1172 } 1173 if p[0] != mfixext8 { 1174 err = badPrefix(Complex64Type, p[0]) 1175 return 1176 } 1177 if int8(p[1]) != Complex64Extension { 1178 err = errExt(int8(p[1]), Complex64Extension) 1179 return 1180 } 1181 f = complex(math.Float32frombits(big.Uint32(p[2:])), 1182 math.Float32frombits(big.Uint32(p[6:]))) 1183 _, err = m.R.Skip(10) 1184 return 1185} 1186 1187// ReadComplex128 reads a complex128 from the reader 1188func (m *Reader) ReadComplex128() (f complex128, err error) { 1189 var p []byte 1190 p, err = m.R.Peek(18) 1191 if err != nil { 1192 return 1193 } 1194 if p[0] != mfixext16 { 1195 err = badPrefix(Complex128Type, p[0]) 1196 return 1197 } 1198 if int8(p[1]) != Complex128Extension { 1199 err = errExt(int8(p[1]), Complex128Extension) 1200 return 1201 } 1202 f = complex(math.Float64frombits(big.Uint64(p[2:])), 1203 math.Float64frombits(big.Uint64(p[10:]))) 1204 _, err = m.R.Skip(18) 1205 return 1206} 1207 1208// ReadMapStrIntf reads a MessagePack map into a map[string]interface{}. 1209// (You must pass a non-nil map into the function.) 1210func (m *Reader) ReadMapStrIntf(mp map[string]interface{}) (err error) { 1211 var sz uint32 1212 sz, err = m.ReadMapHeader() 1213 if err != nil { 1214 return 1215 } 1216 for key := range mp { 1217 delete(mp, key) 1218 } 1219 for i := uint32(0); i < sz; i++ { 1220 var key string 1221 var val interface{} 1222 key, err = m.ReadString() 1223 if err != nil { 1224 return 1225 } 1226 val, err = m.ReadIntf() 1227 if err != nil { 1228 return 1229 } 1230 mp[key] = val 1231 } 1232 return 1233} 1234 1235// ReadTime reads a time.Time object from the reader. 1236// The returned time's location will be set to time.Local. 1237func (m *Reader) ReadTime() (t time.Time, err error) { 1238 var p []byte 1239 p, err = m.R.Peek(15) 1240 if err != nil { 1241 return 1242 } 1243 if p[0] != mext8 || p[1] != 12 { 1244 err = badPrefix(TimeType, p[0]) 1245 return 1246 } 1247 if int8(p[2]) != TimeExtension { 1248 err = errExt(int8(p[2]), TimeExtension) 1249 return 1250 } 1251 sec, nsec := getUnix(p[3:]) 1252 t = time.Unix(sec, int64(nsec)).Local() 1253 _, err = m.R.Skip(15) 1254 return 1255} 1256 1257// ReadIntf reads out the next object as a raw interface{}. 1258// Arrays are decoded as []interface{}, and maps are decoded 1259// as map[string]interface{}. Integers are decoded as int64 1260// and unsigned integers are decoded as uint64. 1261func (m *Reader) ReadIntf() (i interface{}, err error) { 1262 var t Type 1263 t, err = m.NextType() 1264 if err != nil { 1265 return 1266 } 1267 switch t { 1268 case BoolType: 1269 i, err = m.ReadBool() 1270 return 1271 1272 case IntType: 1273 i, err = m.ReadInt64() 1274 return 1275 1276 case UintType: 1277 i, err = m.ReadUint64() 1278 return 1279 1280 case BinType: 1281 i, err = m.ReadBytes(nil) 1282 return 1283 1284 case StrType: 1285 i, err = m.ReadString() 1286 return 1287 1288 case Complex64Type: 1289 i, err = m.ReadComplex64() 1290 return 1291 1292 case Complex128Type: 1293 i, err = m.ReadComplex128() 1294 return 1295 1296 case TimeType: 1297 i, err = m.ReadTime() 1298 return 1299 1300 case ExtensionType: 1301 var t int8 1302 t, err = m.peekExtensionType() 1303 if err != nil { 1304 return 1305 } 1306 f, ok := extensionReg[t] 1307 if ok { 1308 e := f() 1309 err = m.ReadExtension(e) 1310 i = e 1311 return 1312 } 1313 var e RawExtension 1314 e.Type = t 1315 err = m.ReadExtension(&e) 1316 i = &e 1317 return 1318 1319 case MapType: 1320 mp := make(map[string]interface{}) 1321 err = m.ReadMapStrIntf(mp) 1322 i = mp 1323 return 1324 1325 case NilType: 1326 err = m.ReadNil() 1327 i = nil 1328 return 1329 1330 case Float32Type: 1331 i, err = m.ReadFloat32() 1332 return 1333 1334 case Float64Type: 1335 i, err = m.ReadFloat64() 1336 return 1337 1338 case ArrayType: 1339 var sz uint32 1340 sz, err = m.ReadArrayHeader() 1341 1342 if err != nil { 1343 return 1344 } 1345 out := make([]interface{}, int(sz)) 1346 for j := range out { 1347 out[j], err = m.ReadIntf() 1348 if err != nil { 1349 return 1350 } 1351 } 1352 i = out 1353 return 1354 1355 default: 1356 return nil, fatal // unreachable 1357 } 1358} 1359