summaryrefslogtreecommitdiff
path: root/vendor/github.com/ugorji/go/codec/msgpack.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/ugorji/go/codec/msgpack.go')
-rw-r--r--vendor/github.com/ugorji/go/codec/msgpack.go1237
1 files changed, 0 insertions, 1237 deletions
diff --git a/vendor/github.com/ugorji/go/codec/msgpack.go b/vendor/github.com/ugorji/go/codec/msgpack.go
deleted file mode 100644
index c0861df5e..000000000
--- a/vendor/github.com/ugorji/go/codec/msgpack.go
+++ /dev/null
@@ -1,1237 +0,0 @@
-// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-/*
-Msgpack-c implementation powers the c, c++, python, ruby, etc libraries.
-We need to maintain compatibility with it and how it encodes integer values
-without caring about the type.
-
-For compatibility with behaviour of msgpack-c reference implementation:
- - Go intX (>0) and uintX
- IS ENCODED AS
- msgpack +ve fixnum, unsigned
- - Go intX (<0)
- IS ENCODED AS
- msgpack -ve fixnum, signed
-*/
-
-package codec
-
-import (
- "fmt"
- "io"
- "math"
- "net/rpc"
- "reflect"
- "time"
- "unicode/utf8"
-)
-
-const (
- mpPosFixNumMin byte = 0x00
- mpPosFixNumMax byte = 0x7f
- mpFixMapMin byte = 0x80
- mpFixMapMax byte = 0x8f
- mpFixArrayMin byte = 0x90
- mpFixArrayMax byte = 0x9f
- mpFixStrMin byte = 0xa0
- mpFixStrMax byte = 0xbf
- mpNil byte = 0xc0
- _ byte = 0xc1
- mpFalse byte = 0xc2
- mpTrue byte = 0xc3
- mpFloat byte = 0xca
- mpDouble byte = 0xcb
- mpUint8 byte = 0xcc
- mpUint16 byte = 0xcd
- mpUint32 byte = 0xce
- mpUint64 byte = 0xcf
- mpInt8 byte = 0xd0
- mpInt16 byte = 0xd1
- mpInt32 byte = 0xd2
- mpInt64 byte = 0xd3
-
- // extensions below
- mpBin8 byte = 0xc4
- mpBin16 byte = 0xc5
- mpBin32 byte = 0xc6
- mpExt8 byte = 0xc7
- mpExt16 byte = 0xc8
- mpExt32 byte = 0xc9
- mpFixExt1 byte = 0xd4
- mpFixExt2 byte = 0xd5
- mpFixExt4 byte = 0xd6
- mpFixExt8 byte = 0xd7
- mpFixExt16 byte = 0xd8
-
- mpStr8 byte = 0xd9 // new
- mpStr16 byte = 0xda
- mpStr32 byte = 0xdb
-
- mpArray16 byte = 0xdc
- mpArray32 byte = 0xdd
-
- mpMap16 byte = 0xde
- mpMap32 byte = 0xdf
-
- mpNegFixNumMin byte = 0xe0
- mpNegFixNumMax byte = 0xff
-)
-
-var mpTimeExtTag int8 = -1
-var mpTimeExtTagU = uint8(mpTimeExtTag)
-
-var mpdescNames = map[byte]string{
- mpNil: "nil",
- mpFalse: "false",
- mpTrue: "true",
- mpFloat: "float",
- mpDouble: "float",
- mpUint8: "uuint",
- mpUint16: "uint",
- mpUint32: "uint",
- mpUint64: "uint",
- mpInt8: "int",
- mpInt16: "int",
- mpInt32: "int",
- mpInt64: "int",
-
- mpStr8: "string|bytes",
- mpStr16: "string|bytes",
- mpStr32: "string|bytes",
-
- mpBin8: "bytes",
- mpBin16: "bytes",
- mpBin32: "bytes",
-
- mpArray16: "array",
- mpArray32: "array",
-
- mpMap16: "map",
- mpMap32: "map",
-}
-
-func mpdesc(bd byte) (s string) {
- s = mpdescNames[bd]
- if s == "" {
- switch {
- case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax,
- bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
- s = "int"
- case bd >= mpFixStrMin && bd <= mpFixStrMax:
- s = "string|bytes"
- case bd >= mpFixArrayMin && bd <= mpFixArrayMax:
- s = "array"
- case bd >= mpFixMapMin && bd <= mpFixMapMax:
- s = "map"
- case bd >= mpFixExt1 && bd <= mpFixExt16,
- bd >= mpExt8 && bd <= mpExt32:
- s = "ext"
- default:
- s = "unknown"
- }
- }
- return
-}
-
-// MsgpackSpecRpcMultiArgs is a special type which signifies to the MsgpackSpecRpcCodec
-// that the backend RPC service takes multiple arguments, which have been arranged
-// in sequence in the slice.
-//
-// The Codec then passes it AS-IS to the rpc service (without wrapping it in an
-// array of 1 element).
-type MsgpackSpecRpcMultiArgs []interface{}
-
-// A MsgpackContainer type specifies the different types of msgpackContainers.
-type msgpackContainerType struct {
- fixCutoff, bFixMin, b8, b16, b32 byte
- // hasFixMin, has8, has8Always bool
-}
-
-var (
- msgpackContainerRawLegacy = msgpackContainerType{
- 32, mpFixStrMin, 0, mpStr16, mpStr32,
- }
- msgpackContainerStr = msgpackContainerType{
- 32, mpFixStrMin, mpStr8, mpStr16, mpStr32, // true, true, false,
- }
- msgpackContainerBin = msgpackContainerType{
- 0, 0, mpBin8, mpBin16, mpBin32, // false, true, true,
- }
- msgpackContainerList = msgpackContainerType{
- 16, mpFixArrayMin, 0, mpArray16, mpArray32, // true, false, false,
- }
- msgpackContainerMap = msgpackContainerType{
- 16, mpFixMapMin, 0, mpMap16, mpMap32, // true, false, false,
- }
-)
-
-//---------------------------------------------
-
-type msgpackEncDriver struct {
- noBuiltInTypes
- encDriverNoopContainerWriter
- encDriverNoState
- h *MsgpackHandle
- // x [8]byte
- e Encoder
-}
-
-func (e *msgpackEncDriver) encoder() *Encoder {
- return &e.e
-}
-
-func (e *msgpackEncDriver) EncodeNil() {
- e.e.encWr.writen1(mpNil)
-}
-
-func (e *msgpackEncDriver) EncodeInt(i int64) {
- if e.h.PositiveIntUnsigned && i >= 0 {
- e.EncodeUint(uint64(i))
- } else if i > math.MaxInt8 {
- if i <= math.MaxInt16 {
- e.e.encWr.writen1(mpInt16)
- bigen.writeUint16(e.e.w(), uint16(i))
- } else if i <= math.MaxInt32 {
- e.e.encWr.writen1(mpInt32)
- bigen.writeUint32(e.e.w(), uint32(i))
- } else {
- e.e.encWr.writen1(mpInt64)
- bigen.writeUint64(e.e.w(), uint64(i))
- }
- } else if i >= -32 {
- if e.h.NoFixedNum {
- e.e.encWr.writen2(mpInt8, byte(i))
- } else {
- e.e.encWr.writen1(byte(i))
- }
- } else if i >= math.MinInt8 {
- e.e.encWr.writen2(mpInt8, byte(i))
- } else if i >= math.MinInt16 {
- e.e.encWr.writen1(mpInt16)
- bigen.writeUint16(e.e.w(), uint16(i))
- } else if i >= math.MinInt32 {
- e.e.encWr.writen1(mpInt32)
- bigen.writeUint32(e.e.w(), uint32(i))
- } else {
- e.e.encWr.writen1(mpInt64)
- bigen.writeUint64(e.e.w(), uint64(i))
- }
-}
-
-func (e *msgpackEncDriver) EncodeUint(i uint64) {
- if i <= math.MaxInt8 {
- if e.h.NoFixedNum {
- e.e.encWr.writen2(mpUint8, byte(i))
- } else {
- e.e.encWr.writen1(byte(i))
- }
- } else if i <= math.MaxUint8 {
- e.e.encWr.writen2(mpUint8, byte(i))
- } else if i <= math.MaxUint16 {
- e.e.encWr.writen1(mpUint16)
- bigen.writeUint16(e.e.w(), uint16(i))
- } else if i <= math.MaxUint32 {
- e.e.encWr.writen1(mpUint32)
- bigen.writeUint32(e.e.w(), uint32(i))
- } else {
- e.e.encWr.writen1(mpUint64)
- bigen.writeUint64(e.e.w(), uint64(i))
- }
-}
-
-func (e *msgpackEncDriver) EncodeBool(b bool) {
- if b {
- e.e.encWr.writen1(mpTrue)
- } else {
- e.e.encWr.writen1(mpFalse)
- }
-}
-
-func (e *msgpackEncDriver) EncodeFloat32(f float32) {
- e.e.encWr.writen1(mpFloat)
- bigen.writeUint32(e.e.w(), math.Float32bits(f))
-}
-
-func (e *msgpackEncDriver) EncodeFloat64(f float64) {
- e.e.encWr.writen1(mpDouble)
- bigen.writeUint64(e.e.w(), math.Float64bits(f))
-}
-
-func (e *msgpackEncDriver) EncodeTime(t time.Time) {
- if t.IsZero() {
- e.EncodeNil()
- return
- }
- t = t.UTC()
- sec, nsec := t.Unix(), uint64(t.Nanosecond())
- var data64 uint64
- var l = 4
- if sec >= 0 && sec>>34 == 0 {
- data64 = (nsec << 34) | uint64(sec)
- if data64&0xffffffff00000000 != 0 {
- l = 8
- }
- } else {
- l = 12
- }
- if e.h.WriteExt {
- e.encodeExtPreamble(mpTimeExtTagU, l)
- } else {
- e.writeContainerLen(msgpackContainerRawLegacy, l)
- }
- switch l {
- case 4:
- bigen.writeUint32(e.e.w(), uint32(data64))
- case 8:
- bigen.writeUint64(e.e.w(), data64)
- case 12:
- bigen.writeUint32(e.e.w(), uint32(nsec))
- bigen.writeUint64(e.e.w(), uint64(sec))
- }
-}
-
-func (e *msgpackEncDriver) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
- var bs0, bs []byte
- if ext == SelfExt {
- bs0 = e.e.blist.get(1024)
- bs = bs0
- e.e.sideEncode(v, basetype, &bs)
- } else {
- bs = ext.WriteExt(v)
- }
- if bs == nil {
- e.EncodeNil()
- goto END
- }
- if e.h.WriteExt {
- e.encodeExtPreamble(uint8(xtag), len(bs))
- e.e.encWr.writeb(bs)
- } else {
- e.EncodeStringBytesRaw(bs)
- }
-END:
- if ext == SelfExt {
- e.e.blist.put(bs)
- if !byteSliceSameData(bs0, bs) {
- e.e.blist.put(bs0)
- }
- }
-}
-
-func (e *msgpackEncDriver) EncodeRawExt(re *RawExt) {
- e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
- e.e.encWr.writeb(re.Data)
-}
-
-func (e *msgpackEncDriver) encodeExtPreamble(xtag byte, l int) {
- if l == 1 {
- e.e.encWr.writen2(mpFixExt1, xtag)
- } else if l == 2 {
- e.e.encWr.writen2(mpFixExt2, xtag)
- } else if l == 4 {
- e.e.encWr.writen2(mpFixExt4, xtag)
- } else if l == 8 {
- e.e.encWr.writen2(mpFixExt8, xtag)
- } else if l == 16 {
- e.e.encWr.writen2(mpFixExt16, xtag)
- } else if l < 256 {
- e.e.encWr.writen2(mpExt8, byte(l))
- e.e.encWr.writen1(xtag)
- } else if l < 65536 {
- e.e.encWr.writen1(mpExt16)
- bigen.writeUint16(e.e.w(), uint16(l))
- e.e.encWr.writen1(xtag)
- } else {
- e.e.encWr.writen1(mpExt32)
- bigen.writeUint32(e.e.w(), uint32(l))
- e.e.encWr.writen1(xtag)
- }
-}
-
-func (e *msgpackEncDriver) WriteArrayStart(length int) {
- e.writeContainerLen(msgpackContainerList, length)
-}
-
-func (e *msgpackEncDriver) WriteMapStart(length int) {
- e.writeContainerLen(msgpackContainerMap, length)
-}
-
-func (e *msgpackEncDriver) EncodeString(s string) {
- var ct msgpackContainerType
- if e.h.WriteExt {
- if e.h.StringToRaw {
- ct = msgpackContainerBin
- } else {
- ct = msgpackContainerStr
- }
- } else {
- ct = msgpackContainerRawLegacy
- }
- e.writeContainerLen(ct, len(s))
- if len(s) > 0 {
- e.e.encWr.writestr(s)
- }
-}
-
-func (e *msgpackEncDriver) EncodeStringBytesRaw(bs []byte) {
- if bs == nil {
- e.EncodeNil()
- return
- }
- if e.h.WriteExt {
- e.writeContainerLen(msgpackContainerBin, len(bs))
- } else {
- e.writeContainerLen(msgpackContainerRawLegacy, len(bs))
- }
- if len(bs) > 0 {
- e.e.encWr.writeb(bs)
- }
-}
-
-func (e *msgpackEncDriver) writeContainerLen(ct msgpackContainerType, l int) {
- if ct.fixCutoff > 0 && l < int(ct.fixCutoff) {
- e.e.encWr.writen1(ct.bFixMin | byte(l))
- } else if ct.b8 > 0 && l < 256 {
- e.e.encWr.writen2(ct.b8, uint8(l))
- } else if l < 65536 {
- e.e.encWr.writen1(ct.b16)
- bigen.writeUint16(e.e.w(), uint16(l))
- } else {
- e.e.encWr.writen1(ct.b32)
- bigen.writeUint32(e.e.w(), uint32(l))
- }
-}
-
-//---------------------------------------------
-
-type msgpackDecDriver struct {
- decDriverNoopContainerReader
- decDriverNoopNumberHelper
- h *MsgpackHandle
- bdAndBdread
- _ bool
- noBuiltInTypes
- d Decoder
-}
-
-func (d *msgpackDecDriver) decoder() *Decoder {
- return &d.d
-}
-
-// Note: This returns either a primitive (int, bool, etc) for non-containers,
-// or a containerType, or a specific type denoting nil or extension.
-// It is called when a nil interface{} is passed, leaving it up to the DecDriver
-// to introspect the stream and decide how best to decode.
-// It deciphers the value by looking at the stream first.
-func (d *msgpackDecDriver) DecodeNaked() {
- if !d.bdRead {
- d.readNextBd()
- }
- bd := d.bd
- n := d.d.naked()
- var decodeFurther bool
-
- switch bd {
- case mpNil:
- n.v = valueTypeNil
- d.bdRead = false
- case mpFalse:
- n.v = valueTypeBool
- n.b = false
- case mpTrue:
- n.v = valueTypeBool
- n.b = true
-
- case mpFloat:
- n.v = valueTypeFloat
- n.f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
- case mpDouble:
- n.v = valueTypeFloat
- n.f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
-
- case mpUint8:
- n.v = valueTypeUint
- n.u = uint64(d.d.decRd.readn1())
- case mpUint16:
- n.v = valueTypeUint
- n.u = uint64(bigen.Uint16(d.d.decRd.readn2()))
- case mpUint32:
- n.v = valueTypeUint
- n.u = uint64(bigen.Uint32(d.d.decRd.readn4()))
- case mpUint64:
- n.v = valueTypeUint
- n.u = uint64(bigen.Uint64(d.d.decRd.readn8()))
-
- case mpInt8:
- n.v = valueTypeInt
- n.i = int64(int8(d.d.decRd.readn1()))
- case mpInt16:
- n.v = valueTypeInt
- n.i = int64(int16(bigen.Uint16(d.d.decRd.readn2())))
- case mpInt32:
- n.v = valueTypeInt
- n.i = int64(int32(bigen.Uint32(d.d.decRd.readn4())))
- case mpInt64:
- n.v = valueTypeInt
- n.i = int64(int64(bigen.Uint64(d.d.decRd.readn8())))
-
- default:
- switch {
- case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
- // positive fixnum (always signed)
- n.v = valueTypeInt
- n.i = int64(int8(bd))
- case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
- // negative fixnum
- n.v = valueTypeInt
- n.i = int64(int8(bd))
- case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax:
- d.d.fauxUnionReadRawBytes(d.h.WriteExt)
- // if d.h.WriteExt || d.h.RawToString {
- // n.v = valueTypeString
- // n.s = d.d.stringZC(d.DecodeStringAsBytes())
- // } else {
- // n.v = valueTypeBytes
- // n.l = d.DecodeBytes([]byte{})
- // }
- case bd == mpBin8, bd == mpBin16, bd == mpBin32:
- d.d.fauxUnionReadRawBytes(false)
- case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax:
- n.v = valueTypeArray
- decodeFurther = true
- case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax:
- n.v = valueTypeMap
- decodeFurther = true
- case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32:
- n.v = valueTypeExt
- clen := d.readExtLen()
- n.u = uint64(d.d.decRd.readn1())
- if n.u == uint64(mpTimeExtTagU) {
- n.v = valueTypeTime
- n.t = d.decodeTime(clen)
- } else if d.d.bytes {
- n.l = d.d.decRd.rb.readx(uint(clen))
- } else {
- n.l = decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, d.d.b[:])
- }
- default:
- d.d.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
- }
- }
- if !decodeFurther {
- d.bdRead = false
- }
- if n.v == valueTypeUint && d.h.SignedInteger {
- n.v = valueTypeInt
- n.i = int64(n.u)
- }
-}
-
-func (d *msgpackDecDriver) nextValueBytes(v0 []byte) (v []byte) {
- if !d.bdRead {
- d.readNextBd()
- }
- v = v0
- var h = decNextValueBytesHelper{d: &d.d}
- var cursor = d.d.rb.c - 1
- h.append1(&v, d.bd)
- v = d.nextValueBytesBdReadR(v)
- d.bdRead = false
- h.bytesRdV(&v, cursor)
- return
-}
-
-func (d *msgpackDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
- d.readNextBd()
- v = v0
- var h = decNextValueBytesHelper{d: &d.d}
- h.append1(&v, d.bd)
- return d.nextValueBytesBdReadR(v)
-}
-
-func (d *msgpackDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
- v = v0
- var h = decNextValueBytesHelper{d: &d.d}
-
- bd := d.bd
-
- var clen uint
-
- switch bd {
- case mpNil, mpFalse, mpTrue: // pass
- case mpUint8, mpInt8:
- h.append1(&v, d.d.decRd.readn1())
- case mpUint16, mpInt16:
- h.appendN(&v, d.d.decRd.readx(2)...)
- case mpFloat, mpUint32, mpInt32:
- h.appendN(&v, d.d.decRd.readx(4)...)
- case mpDouble, mpUint64, mpInt64:
- h.appendN(&v, d.d.decRd.readx(8)...)
- case mpStr8, mpBin8:
- clen = uint(d.d.decRd.readn1())
- h.append1(&v, byte(clen))
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case mpStr16, mpBin16:
- x := d.d.decRd.readn2()
- h.appendN(&v, x[:]...)
- clen = uint(bigen.Uint16(x))
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case mpStr32, mpBin32:
- x := d.d.decRd.readn4()
- h.appendN(&v, x[:]...)
- clen = uint(bigen.Uint32(x))
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case mpFixExt1:
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.append1(&v, d.d.decRd.readn1())
- case mpFixExt2:
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(2)...)
- case mpFixExt4:
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(4)...)
- case mpFixExt8:
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(8)...)
- case mpFixExt16:
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(16)...)
- case mpExt8:
- clen = uint(d.d.decRd.readn1())
- h.append1(&v, uint8(clen))
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case mpExt16:
- x := d.d.decRd.readn2()
- clen = uint(bigen.Uint16(x))
- h.appendN(&v, x[:]...)
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case mpExt32:
- x := d.d.decRd.readn4()
- clen = uint(bigen.Uint32(x))
- h.appendN(&v, x[:]...)
- h.append1(&v, d.d.decRd.readn1()) // tag
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case mpArray16:
- x := d.d.decRd.readn2()
- clen = uint(bigen.Uint16(x))
- h.appendN(&v, x[:]...)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- }
- case mpArray32:
- x := d.d.decRd.readn4()
- clen = uint(bigen.Uint32(x))
- h.appendN(&v, x[:]...)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- }
- case mpMap16:
- x := d.d.decRd.readn2()
- clen = uint(bigen.Uint16(x))
- h.appendN(&v, x[:]...)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- v = d.nextValueBytesR(v)
- }
- case mpMap32:
- x := d.d.decRd.readn4()
- clen = uint(bigen.Uint32(x))
- h.appendN(&v, x[:]...)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- v = d.nextValueBytesR(v)
- }
- default:
- switch {
- case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: // pass
- case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: // pass
- case bd >= mpFixStrMin && bd <= mpFixStrMax:
- clen = uint(mpFixStrMin ^ bd)
- h.appendN(&v, d.d.decRd.readx(clen)...)
- case bd >= mpFixArrayMin && bd <= mpFixArrayMax:
- clen = uint(mpFixArrayMin ^ bd)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- }
- case bd >= mpFixMapMin && bd <= mpFixMapMax:
- clen = uint(mpFixMapMin ^ bd)
- for i := uint(0); i < clen; i++ {
- v = d.nextValueBytesR(v)
- v = d.nextValueBytesR(v)
- }
- default:
- d.d.errorf("nextValueBytes: cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
- }
- }
- return
-}
-
-func (d *msgpackDecDriver) decFloat4Int32() (f float32) {
- fbits := bigen.Uint32(d.d.decRd.readn4())
- f = math.Float32frombits(fbits)
- if !noFrac32(fbits) {
- d.d.errorf("assigning integer value from float32 with a fraction: %v", f)
- }
- return
-}
-
-func (d *msgpackDecDriver) decFloat4Int64() (f float64) {
- fbits := bigen.Uint64(d.d.decRd.readn8())
- f = math.Float64frombits(fbits)
- if !noFrac64(fbits) {
- d.d.errorf("assigning integer value from float64 with a fraction: %v", f)
- }
- return
-}
-
-// int can be decoded from msgpack type: intXXX or uintXXX
-func (d *msgpackDecDriver) DecodeInt64() (i int64) {
- if d.advanceNil() {
- return
- }
- switch d.bd {
- case mpUint8:
- i = int64(uint64(d.d.decRd.readn1()))
- case mpUint16:
- i = int64(uint64(bigen.Uint16(d.d.decRd.readn2())))
- case mpUint32:
- i = int64(uint64(bigen.Uint32(d.d.decRd.readn4())))
- case mpUint64:
- i = int64(bigen.Uint64(d.d.decRd.readn8()))
- case mpInt8:
- i = int64(int8(d.d.decRd.readn1()))
- case mpInt16:
- i = int64(int16(bigen.Uint16(d.d.decRd.readn2())))
- case mpInt32:
- i = int64(int32(bigen.Uint32(d.d.decRd.readn4())))
- case mpInt64:
- i = int64(bigen.Uint64(d.d.decRd.readn8()))
- case mpFloat:
- i = int64(d.decFloat4Int32())
- case mpDouble:
- i = int64(d.decFloat4Int64())
- default:
- switch {
- case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
- i = int64(int8(d.bd))
- case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
- i = int64(int8(d.bd))
- default:
- d.d.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
- }
- }
- d.bdRead = false
- return
-}
-
-// uint can be decoded from msgpack type: intXXX or uintXXX
-func (d *msgpackDecDriver) DecodeUint64() (ui uint64) {
- if d.advanceNil() {
- return
- }
- switch d.bd {
- case mpUint8:
- ui = uint64(d.d.decRd.readn1())
- case mpUint16:
- ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
- case mpUint32:
- ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
- case mpUint64:
- ui = bigen.Uint64(d.d.decRd.readn8())
- case mpInt8:
- if i := int64(int8(d.d.decRd.readn1())); i >= 0 {
- ui = uint64(i)
- } else {
- d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
- }
- case mpInt16:
- if i := int64(int16(bigen.Uint16(d.d.decRd.readn2()))); i >= 0 {
- ui = uint64(i)
- } else {
- d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
- }
- case mpInt32:
- if i := int64(int32(bigen.Uint32(d.d.decRd.readn4()))); i >= 0 {
- ui = uint64(i)
- } else {
- d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
- }
- case mpInt64:
- if i := int64(bigen.Uint64(d.d.decRd.readn8())); i >= 0 {
- ui = uint64(i)
- } else {
- d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
- }
- case mpFloat:
- if f := d.decFloat4Int32(); f >= 0 {
- ui = uint64(f)
- } else {
- d.d.errorf("assigning negative float value: %v, to unsigned type", f)
- }
- case mpDouble:
- if f := d.decFloat4Int64(); f >= 0 {
- ui = uint64(f)
- } else {
- d.d.errorf("assigning negative float value: %v, to unsigned type", f)
- }
- default:
- switch {
- case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
- ui = uint64(d.bd)
- case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
- d.d.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd))
- default:
- d.d.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
- }
- }
- d.bdRead = false
- return
-}
-
-// float can either be decoded from msgpack type: float, double or intX
-func (d *msgpackDecDriver) DecodeFloat64() (f float64) {
- if d.advanceNil() {
- return
- }
- if d.bd == mpFloat {
- f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
- } else if d.bd == mpDouble {
- f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
- } else {
- f = float64(d.DecodeInt64())
- }
- d.bdRead = false
- return
-}
-
-// bool can be decoded from bool, fixnum 0 or 1.
-func (d *msgpackDecDriver) DecodeBool() (b bool) {
- if d.advanceNil() {
- return
- }
- if d.bd == mpFalse || d.bd == 0 {
- // b = false
- } else if d.bd == mpTrue || d.bd == 1 {
- b = true
- } else {
- d.d.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
- }
- d.bdRead = false
- return
-}
-
-func (d *msgpackDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
- d.d.decByteState = decByteStateNone
- if d.advanceNil() {
- return
- }
-
- bd := d.bd
- var clen int
- if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
- clen = d.readContainerLen(msgpackContainerBin) // binary
- } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
- (bd >= mpFixStrMin && bd <= mpFixStrMax) {
- clen = d.readContainerLen(msgpackContainerStr) // string/raw
- } else if bd == mpArray16 || bd == mpArray32 ||
- (bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
- // check if an "array" of uint8's
- if bs == nil {
- d.d.decByteState = decByteStateReuseBuf
- bs = d.d.b[:]
- }
- // bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
- slen := d.ReadArrayStart()
- var changed bool
- if bs, changed = usableByteSlice(bs, slen); changed {
- d.d.decByteState = decByteStateNone
- }
- for i := 0; i < len(bs); i++ {
- bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
- }
- for i := len(bs); i < slen; i++ {
- bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
- }
- return bs
- } else {
- d.d.errorf("invalid byte descriptor for decoding bytes, got: 0x%x", d.bd)
- }
-
- d.bdRead = false
- if d.d.zerocopy() {
- d.d.decByteState = decByteStateZerocopy
- return d.d.decRd.rb.readx(uint(clen))
- }
- if bs == nil {
- d.d.decByteState = decByteStateReuseBuf
- bs = d.d.b[:]
- }
- return decByteSlice(d.d.r(), clen, d.h.MaxInitLen, bs)
-}
-
-func (d *msgpackDecDriver) DecodeStringAsBytes() (s []byte) {
- s = d.DecodeBytes(nil)
- if d.h.ValidateUnicode && !utf8.Valid(s) {
- d.d.errorf("DecodeStringAsBytes: invalid UTF-8: %s", s)
- }
- return
-}
-
-func (d *msgpackDecDriver) descBd() string {
- return sprintf("%v (%s)", d.bd, mpdesc(d.bd))
-}
-
-func (d *msgpackDecDriver) readNextBd() {
- d.bd = d.d.decRd.readn1()
- d.bdRead = true
-}
-
-func (d *msgpackDecDriver) advanceNil() (null bool) {
- if !d.bdRead {
- d.readNextBd()
- }
- if d.bd == mpNil {
- d.bdRead = false
- return true // null = true
- }
- return
-}
-
-func (d *msgpackDecDriver) TryNil() (v bool) {
- return d.advanceNil()
-}
-
-func (d *msgpackDecDriver) ContainerType() (vt valueType) {
- if !d.bdRead {
- d.readNextBd()
- }
- bd := d.bd
- if bd == mpNil {
- d.bdRead = false
- return valueTypeNil
- } else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
- return valueTypeBytes
- } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
- (bd >= mpFixStrMin && bd <= mpFixStrMax) {
- if d.h.WriteExt || d.h.RawToString { // UTF-8 string (new spec)
- return valueTypeString
- }
- return valueTypeBytes // raw (old spec)
- } else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
- return valueTypeArray
- } else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) {
- return valueTypeMap
- }
- return valueTypeUnset
-}
-
-func (d *msgpackDecDriver) readContainerLen(ct msgpackContainerType) (clen int) {
- bd := d.bd
- if bd == ct.b8 {
- clen = int(d.d.decRd.readn1())
- } else if bd == ct.b16 {
- clen = int(bigen.Uint16(d.d.decRd.readn2()))
- } else if bd == ct.b32 {
- clen = int(bigen.Uint32(d.d.decRd.readn4()))
- } else if (ct.bFixMin & bd) == ct.bFixMin {
- clen = int(ct.bFixMin ^ bd)
- } else {
- d.d.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd)
- }
- d.bdRead = false
- return
-}
-
-func (d *msgpackDecDriver) ReadMapStart() int {
- if d.advanceNil() {
- return containerLenNil
- }
- return d.readContainerLen(msgpackContainerMap)
-}
-
-func (d *msgpackDecDriver) ReadArrayStart() int {
- if d.advanceNil() {
- return containerLenNil
- }
- return d.readContainerLen(msgpackContainerList)
-}
-
-func (d *msgpackDecDriver) readExtLen() (clen int) {
- switch d.bd {
- case mpFixExt1:
- clen = 1
- case mpFixExt2:
- clen = 2
- case mpFixExt4:
- clen = 4
- case mpFixExt8:
- clen = 8
- case mpFixExt16:
- clen = 16
- case mpExt8:
- clen = int(d.d.decRd.readn1())
- case mpExt16:
- clen = int(bigen.Uint16(d.d.decRd.readn2()))
- case mpExt32:
- clen = int(bigen.Uint32(d.d.decRd.readn4()))
- default:
- d.d.errorf("decoding ext bytes: found unexpected byte: %x", d.bd)
- }
- return
-}
-
-func (d *msgpackDecDriver) DecodeTime() (t time.Time) {
- // decode time from string bytes or ext
- if d.advanceNil() {
- return
- }
- bd := d.bd
- var clen int
- if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
- clen = d.readContainerLen(msgpackContainerBin) // binary
- } else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
- (bd >= mpFixStrMin && bd <= mpFixStrMax) {
- clen = d.readContainerLen(msgpackContainerStr) // string/raw
- } else {
- // expect to see mpFixExt4,-1 OR mpFixExt8,-1 OR mpExt8,12,-1
- d.bdRead = false
- b2 := d.d.decRd.readn1()
- if d.bd == mpFixExt4 && b2 == mpTimeExtTagU {
- clen = 4
- } else if d.bd == mpFixExt8 && b2 == mpTimeExtTagU {
- clen = 8
- } else if d.bd == mpExt8 && b2 == 12 && d.d.decRd.readn1() == mpTimeExtTagU {
- clen = 12
- } else {
- d.d.errorf("invalid stream for decoding time as extension: got 0x%x, 0x%x", d.bd, b2)
- }
- }
- return d.decodeTime(clen)
-}
-
-func (d *msgpackDecDriver) decodeTime(clen int) (t time.Time) {
- d.bdRead = false
- switch clen {
- case 4:
- t = time.Unix(int64(bigen.Uint32(d.d.decRd.readn4())), 0).UTC()
- case 8:
- tv := bigen.Uint64(d.d.decRd.readn8())
- t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC()
- case 12:
- nsec := bigen.Uint32(d.d.decRd.readn4())
- sec := bigen.Uint64(d.d.decRd.readn8())
- t = time.Unix(int64(sec), int64(nsec)).UTC()
- default:
- d.d.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen)
- }
- return
-}
-
-func (d *msgpackDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
- if xtag > 0xff {
- d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
- }
- if d.advanceNil() {
- return
- }
- xbs, realxtag1, zerocopy := d.decodeExtV(ext != nil, uint8(xtag))
- realxtag := uint64(realxtag1)
- if ext == nil {
- re := rv.(*RawExt)
- re.Tag = realxtag
- re.setData(xbs, zerocopy)
- } else if ext == SelfExt {
- d.d.sideDecode(rv, basetype, xbs)
- } else {
- ext.ReadExt(rv, xbs)
- }
-}
-
-func (d *msgpackDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xtag byte, zerocopy bool) {
- xbd := d.bd
- if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 {
- xbs = d.DecodeBytes(nil)
- } else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 ||
- (xbd >= mpFixStrMin && xbd <= mpFixStrMax) {
- xbs = d.DecodeStringAsBytes()
- } else {
- clen := d.readExtLen()
- xtag = d.d.decRd.readn1()
- if verifyTag && xtag != tag {
- d.d.errorf("wrong extension tag - got %b, expecting %v", xtag, tag)
- }
- if d.d.bytes {
- xbs = d.d.decRd.rb.readx(uint(clen))
- zerocopy = true
- } else {
- xbs = decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, d.d.b[:])
- }
- }
- d.bdRead = false
- return
-}
-
-//--------------------------------------------------
-
-// MsgpackHandle is a Handle for the Msgpack Schema-Free Encoding Format.
-type MsgpackHandle struct {
- binaryEncodingType
- BasicHandle
-
- // NoFixedNum says to output all signed integers as 2-bytes, never as 1-byte fixednum.
- NoFixedNum bool
-
- // WriteExt controls whether the new spec is honored.
- //
- // With WriteExt=true, we can encode configured extensions with extension tags
- // and encode string/[]byte/extensions in a way compatible with the new spec
- // but incompatible with the old spec.
- //
- // For compatibility with the old spec, set WriteExt=false.
- //
- // With WriteExt=false:
- // configured extensions are serialized as raw bytes (not msgpack extensions).
- // reserved byte descriptors like Str8 and those enabling the new msgpack Binary type
- // are not encoded.
- WriteExt bool
-
- // PositiveIntUnsigned says to encode positive integers as unsigned.
- PositiveIntUnsigned bool
-}
-
-// Name returns the name of the handle: msgpack
-func (h *MsgpackHandle) Name() string { return "msgpack" }
-
-func (h *MsgpackHandle) desc(bd byte) string { return mpdesc(bd) }
-
-func (h *MsgpackHandle) newEncDriver() encDriver {
- var e = &msgpackEncDriver{h: h}
- e.e.e = e
- e.e.init(h)
- e.reset()
- return e
-}
-
-func (h *MsgpackHandle) newDecDriver() decDriver {
- d := &msgpackDecDriver{h: h}
- d.d.d = d
- d.d.init(h)
- d.reset()
- return d
-}
-
-//--------------------------------------------------
-
-type msgpackSpecRpcCodec struct {
- rpcCodec
-}
-
-// /////////////// Spec RPC Codec ///////////////////
-func (c *msgpackSpecRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error {
- // WriteRequest can write to both a Go service, and other services that do
- // not abide by the 1 argument rule of a Go service.
- // We discriminate based on if the body is a MsgpackSpecRpcMultiArgs
- var bodyArr []interface{}
- if m, ok := body.(MsgpackSpecRpcMultiArgs); ok {
- bodyArr = ([]interface{})(m)
- } else {
- bodyArr = []interface{}{body}
- }
- r2 := []interface{}{0, uint32(r.Seq), r.ServiceMethod, bodyArr}
- return c.write(r2)
-}
-
-func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
- var moe interface{}
- if r.Error != "" {
- moe = r.Error
- }
- if moe != nil && body != nil {
- body = nil
- }
- r2 := []interface{}{1, uint32(r.Seq), moe, body}
- return c.write(r2)
-}
-
-func (c *msgpackSpecRpcCodec) ReadResponseHeader(r *rpc.Response) error {
- return c.parseCustomHeader(1, &r.Seq, &r.Error)
-}
-
-func (c *msgpackSpecRpcCodec) ReadRequestHeader(r *rpc.Request) error {
- return c.parseCustomHeader(0, &r.Seq, &r.ServiceMethod)
-}
-
-func (c *msgpackSpecRpcCodec) ReadRequestBody(body interface{}) error {
- if body == nil { // read and discard
- return c.read(nil)
- }
- bodyArr := []interface{}{body}
- return c.read(&bodyArr)
-}
-
-func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint64, methodOrError *string) (err error) {
- if cls := c.cls.load(); cls.closed {
- return io.ErrUnexpectedEOF
- }
-
- // We read the response header by hand
- // so that the body can be decoded on its own from the stream at a later time.
-
- const fia byte = 0x94 //four item array descriptor value
-
- var ba [1]byte
- var n int
- for {
- n, err = c.r.Read(ba[:])
- if err != nil {
- return
- }
- if n == 1 {
- break
- }
- }
-
- var b = ba[0]
- if b != fia {
- err = fmt.Errorf("not array - %s %x/%s", msgBadDesc, b, mpdesc(b))
- } else {
- err = c.read(&b)
- if err == nil {
- if b != expectTypeByte {
- err = fmt.Errorf("%s - expecting %v but got %x/%s", msgBadDesc, expectTypeByte, b, mpdesc(b))
- } else {
- err = c.read(msgid)
- if err == nil {
- err = c.read(methodOrError)
- }
- }
- }
- }
- return
-}
-
-//--------------------------------------------------
-
-// msgpackSpecRpc is the implementation of Rpc that uses custom communication protocol
-// as defined in the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
-type msgpackSpecRpc struct{}
-
-// MsgpackSpecRpc implements Rpc using the communication protocol defined in
-// the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md .
-//
-// See GoRpc documentation, for information on buffering for better performance.
-var MsgpackSpecRpc msgpackSpecRpc
-
-func (x msgpackSpecRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
- return &msgpackSpecRpcCodec{newRPCCodec(conn, h)}
-}
-
-func (x msgpackSpecRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec {
- return &msgpackSpecRpcCodec{newRPCCodec(conn, h)}
-}
-
-var _ decDriver = (*msgpackDecDriver)(nil)
-var _ encDriver = (*msgpackEncDriver)(nil)
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 07:32:00 +0000