12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232 |
- // 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"
- )
- 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) {
- return d.DecodeBytes(nil)
- }
- 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.EOF
- }
- // 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)
|