Source file src/github.com/ugorji/go/codec/msgpack.go

Documentation: github.com/ugorji/go/codec

     1  // Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
     2  // Use of this source code is governed by a MIT license found in the LICENSE file.
     3  
     4  /*
     5  Msgpack-c implementation powers the c, c++, python, ruby, etc libraries.
     6  We need to maintain compatibility with it and how it encodes integer values
     7  without caring about the type.
     8  
     9  For compatibility with behaviour of msgpack-c reference implementation:
    10    - Go intX (>0) and uintX
    11         IS ENCODED AS
    12      msgpack +ve fixnum, unsigned
    13    - Go intX (<0)
    14         IS ENCODED AS
    15      msgpack -ve fixnum, signed
    16  */
    17  
    18  package codec
    19  
    20  import (
    21  	"fmt"
    22  	"io"
    23  	"math"
    24  	"net/rpc"
    25  	"reflect"
    26  	"time"
    27  	"unicode/utf8"
    28  )
    29  
    30  const (
    31  	mpPosFixNumMin byte = 0x00
    32  	mpPosFixNumMax byte = 0x7f
    33  	mpFixMapMin    byte = 0x80
    34  	mpFixMapMax    byte = 0x8f
    35  	mpFixArrayMin  byte = 0x90
    36  	mpFixArrayMax  byte = 0x9f
    37  	mpFixStrMin    byte = 0xa0
    38  	mpFixStrMax    byte = 0xbf
    39  	mpNil          byte = 0xc0
    40  	_              byte = 0xc1
    41  	mpFalse        byte = 0xc2
    42  	mpTrue         byte = 0xc3
    43  	mpFloat        byte = 0xca
    44  	mpDouble       byte = 0xcb
    45  	mpUint8        byte = 0xcc
    46  	mpUint16       byte = 0xcd
    47  	mpUint32       byte = 0xce
    48  	mpUint64       byte = 0xcf
    49  	mpInt8         byte = 0xd0
    50  	mpInt16        byte = 0xd1
    51  	mpInt32        byte = 0xd2
    52  	mpInt64        byte = 0xd3
    53  
    54  	// extensions below
    55  	mpBin8     byte = 0xc4
    56  	mpBin16    byte = 0xc5
    57  	mpBin32    byte = 0xc6
    58  	mpExt8     byte = 0xc7
    59  	mpExt16    byte = 0xc8
    60  	mpExt32    byte = 0xc9
    61  	mpFixExt1  byte = 0xd4
    62  	mpFixExt2  byte = 0xd5
    63  	mpFixExt4  byte = 0xd6
    64  	mpFixExt8  byte = 0xd7
    65  	mpFixExt16 byte = 0xd8
    66  
    67  	mpStr8  byte = 0xd9 // new
    68  	mpStr16 byte = 0xda
    69  	mpStr32 byte = 0xdb
    70  
    71  	mpArray16 byte = 0xdc
    72  	mpArray32 byte = 0xdd
    73  
    74  	mpMap16 byte = 0xde
    75  	mpMap32 byte = 0xdf
    76  
    77  	mpNegFixNumMin byte = 0xe0
    78  	mpNegFixNumMax byte = 0xff
    79  )
    80  
    81  var mpTimeExtTag int8 = -1
    82  var mpTimeExtTagU = uint8(mpTimeExtTag)
    83  
    84  var mpdescNames = map[byte]string{
    85  	mpNil:    "nil",
    86  	mpFalse:  "false",
    87  	mpTrue:   "true",
    88  	mpFloat:  "float",
    89  	mpDouble: "float",
    90  	mpUint8:  "uuint",
    91  	mpUint16: "uint",
    92  	mpUint32: "uint",
    93  	mpUint64: "uint",
    94  	mpInt8:   "int",
    95  	mpInt16:  "int",
    96  	mpInt32:  "int",
    97  	mpInt64:  "int",
    98  
    99  	mpStr8:  "string|bytes",
   100  	mpStr16: "string|bytes",
   101  	mpStr32: "string|bytes",
   102  
   103  	mpBin8:  "bytes",
   104  	mpBin16: "bytes",
   105  	mpBin32: "bytes",
   106  
   107  	mpArray16: "array",
   108  	mpArray32: "array",
   109  
   110  	mpMap16: "map",
   111  	mpMap32: "map",
   112  }
   113  
   114  func mpdesc(bd byte) (s string) {
   115  	s = mpdescNames[bd]
   116  	if s == "" {
   117  		switch {
   118  		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax,
   119  			bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
   120  			s = "int"
   121  		case bd >= mpFixStrMin && bd <= mpFixStrMax:
   122  			s = "string|bytes"
   123  		case bd >= mpFixArrayMin && bd <= mpFixArrayMax:
   124  			s = "array"
   125  		case bd >= mpFixMapMin && bd <= mpFixMapMax:
   126  			s = "map"
   127  		case bd >= mpFixExt1 && bd <= mpFixExt16,
   128  			bd >= mpExt8 && bd <= mpExt32:
   129  			s = "ext"
   130  		default:
   131  			s = "unknown"
   132  		}
   133  	}
   134  	return
   135  }
   136  
   137  // MsgpackSpecRpcMultiArgs is a special type which signifies to the MsgpackSpecRpcCodec
   138  // that the backend RPC service takes multiple arguments, which have been arranged
   139  // in sequence in the slice.
   140  //
   141  // The Codec then passes it AS-IS to the rpc service (without wrapping it in an
   142  // array of 1 element).
   143  type MsgpackSpecRpcMultiArgs []interface{}
   144  
   145  // A MsgpackContainer type specifies the different types of msgpackContainers.
   146  type msgpackContainerType struct {
   147  	fixCutoff, bFixMin, b8, b16, b32 byte
   148  	// hasFixMin, has8, has8Always bool
   149  }
   150  
   151  var (
   152  	msgpackContainerRawLegacy = msgpackContainerType{
   153  		32, mpFixStrMin, 0, mpStr16, mpStr32,
   154  	}
   155  	msgpackContainerStr = msgpackContainerType{
   156  		32, mpFixStrMin, mpStr8, mpStr16, mpStr32, // true, true, false,
   157  	}
   158  	msgpackContainerBin = msgpackContainerType{
   159  		0, 0, mpBin8, mpBin16, mpBin32, // false, true, true,
   160  	}
   161  	msgpackContainerList = msgpackContainerType{
   162  		16, mpFixArrayMin, 0, mpArray16, mpArray32, // true, false, false,
   163  	}
   164  	msgpackContainerMap = msgpackContainerType{
   165  		16, mpFixMapMin, 0, mpMap16, mpMap32, // true, false, false,
   166  	}
   167  )
   168  
   169  //---------------------------------------------
   170  
   171  type msgpackEncDriver struct {
   172  	noBuiltInTypes
   173  	encDriverNoopContainerWriter
   174  	encDriverNoState
   175  	h *MsgpackHandle
   176  	// x [8]byte
   177  	e Encoder
   178  }
   179  
   180  func (e *msgpackEncDriver) encoder() *Encoder {
   181  	return &e.e
   182  }
   183  
   184  func (e *msgpackEncDriver) EncodeNil() {
   185  	e.e.encWr.writen1(mpNil)
   186  }
   187  
   188  func (e *msgpackEncDriver) EncodeInt(i int64) {
   189  	if e.h.PositiveIntUnsigned && i >= 0 {
   190  		e.EncodeUint(uint64(i))
   191  	} else if i > math.MaxInt8 {
   192  		if i <= math.MaxInt16 {
   193  			e.e.encWr.writen1(mpInt16)
   194  			bigen.writeUint16(e.e.w(), uint16(i))
   195  		} else if i <= math.MaxInt32 {
   196  			e.e.encWr.writen1(mpInt32)
   197  			bigen.writeUint32(e.e.w(), uint32(i))
   198  		} else {
   199  			e.e.encWr.writen1(mpInt64)
   200  			bigen.writeUint64(e.e.w(), uint64(i))
   201  		}
   202  	} else if i >= -32 {
   203  		if e.h.NoFixedNum {
   204  			e.e.encWr.writen2(mpInt8, byte(i))
   205  		} else {
   206  			e.e.encWr.writen1(byte(i))
   207  		}
   208  	} else if i >= math.MinInt8 {
   209  		e.e.encWr.writen2(mpInt8, byte(i))
   210  	} else if i >= math.MinInt16 {
   211  		e.e.encWr.writen1(mpInt16)
   212  		bigen.writeUint16(e.e.w(), uint16(i))
   213  	} else if i >= math.MinInt32 {
   214  		e.e.encWr.writen1(mpInt32)
   215  		bigen.writeUint32(e.e.w(), uint32(i))
   216  	} else {
   217  		e.e.encWr.writen1(mpInt64)
   218  		bigen.writeUint64(e.e.w(), uint64(i))
   219  	}
   220  }
   221  
   222  func (e *msgpackEncDriver) EncodeUint(i uint64) {
   223  	if i <= math.MaxInt8 {
   224  		if e.h.NoFixedNum {
   225  			e.e.encWr.writen2(mpUint8, byte(i))
   226  		} else {
   227  			e.e.encWr.writen1(byte(i))
   228  		}
   229  	} else if i <= math.MaxUint8 {
   230  		e.e.encWr.writen2(mpUint8, byte(i))
   231  	} else if i <= math.MaxUint16 {
   232  		e.e.encWr.writen1(mpUint16)
   233  		bigen.writeUint16(e.e.w(), uint16(i))
   234  	} else if i <= math.MaxUint32 {
   235  		e.e.encWr.writen1(mpUint32)
   236  		bigen.writeUint32(e.e.w(), uint32(i))
   237  	} else {
   238  		e.e.encWr.writen1(mpUint64)
   239  		bigen.writeUint64(e.e.w(), uint64(i))
   240  	}
   241  }
   242  
   243  func (e *msgpackEncDriver) EncodeBool(b bool) {
   244  	if b {
   245  		e.e.encWr.writen1(mpTrue)
   246  	} else {
   247  		e.e.encWr.writen1(mpFalse)
   248  	}
   249  }
   250  
   251  func (e *msgpackEncDriver) EncodeFloat32(f float32) {
   252  	e.e.encWr.writen1(mpFloat)
   253  	bigen.writeUint32(e.e.w(), math.Float32bits(f))
   254  }
   255  
   256  func (e *msgpackEncDriver) EncodeFloat64(f float64) {
   257  	e.e.encWr.writen1(mpDouble)
   258  	bigen.writeUint64(e.e.w(), math.Float64bits(f))
   259  }
   260  
   261  func (e *msgpackEncDriver) EncodeTime(t time.Time) {
   262  	if t.IsZero() {
   263  		e.EncodeNil()
   264  		return
   265  	}
   266  	t = t.UTC()
   267  	sec, nsec := t.Unix(), uint64(t.Nanosecond())
   268  	var data64 uint64
   269  	var l = 4
   270  	if sec >= 0 && sec>>34 == 0 {
   271  		data64 = (nsec << 34) | uint64(sec)
   272  		if data64&0xffffffff00000000 != 0 {
   273  			l = 8
   274  		}
   275  	} else {
   276  		l = 12
   277  	}
   278  	if e.h.WriteExt {
   279  		e.encodeExtPreamble(mpTimeExtTagU, l)
   280  	} else {
   281  		e.writeContainerLen(msgpackContainerRawLegacy, l)
   282  	}
   283  	switch l {
   284  	case 4:
   285  		bigen.writeUint32(e.e.w(), uint32(data64))
   286  	case 8:
   287  		bigen.writeUint64(e.e.w(), data64)
   288  	case 12:
   289  		bigen.writeUint32(e.e.w(), uint32(nsec))
   290  		bigen.writeUint64(e.e.w(), uint64(sec))
   291  	}
   292  }
   293  
   294  func (e *msgpackEncDriver) EncodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
   295  	var bs0, bs []byte
   296  	if ext == SelfExt {
   297  		bs0 = e.e.blist.get(1024)
   298  		bs = bs0
   299  		e.e.sideEncode(v, basetype, &bs)
   300  	} else {
   301  		bs = ext.WriteExt(v)
   302  	}
   303  	if bs == nil {
   304  		e.EncodeNil()
   305  		goto END
   306  	}
   307  	if e.h.WriteExt {
   308  		e.encodeExtPreamble(uint8(xtag), len(bs))
   309  		e.e.encWr.writeb(bs)
   310  	} else {
   311  		e.EncodeStringBytesRaw(bs)
   312  	}
   313  END:
   314  	if ext == SelfExt {
   315  		e.e.blist.put(bs)
   316  		if !byteSliceSameData(bs0, bs) {
   317  			e.e.blist.put(bs0)
   318  		}
   319  	}
   320  }
   321  
   322  func (e *msgpackEncDriver) EncodeRawExt(re *RawExt) {
   323  	e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
   324  	e.e.encWr.writeb(re.Data)
   325  }
   326  
   327  func (e *msgpackEncDriver) encodeExtPreamble(xtag byte, l int) {
   328  	if l == 1 {
   329  		e.e.encWr.writen2(mpFixExt1, xtag)
   330  	} else if l == 2 {
   331  		e.e.encWr.writen2(mpFixExt2, xtag)
   332  	} else if l == 4 {
   333  		e.e.encWr.writen2(mpFixExt4, xtag)
   334  	} else if l == 8 {
   335  		e.e.encWr.writen2(mpFixExt8, xtag)
   336  	} else if l == 16 {
   337  		e.e.encWr.writen2(mpFixExt16, xtag)
   338  	} else if l < 256 {
   339  		e.e.encWr.writen2(mpExt8, byte(l))
   340  		e.e.encWr.writen1(xtag)
   341  	} else if l < 65536 {
   342  		e.e.encWr.writen1(mpExt16)
   343  		bigen.writeUint16(e.e.w(), uint16(l))
   344  		e.e.encWr.writen1(xtag)
   345  	} else {
   346  		e.e.encWr.writen1(mpExt32)
   347  		bigen.writeUint32(e.e.w(), uint32(l))
   348  		e.e.encWr.writen1(xtag)
   349  	}
   350  }
   351  
   352  func (e *msgpackEncDriver) WriteArrayStart(length int) {
   353  	e.writeContainerLen(msgpackContainerList, length)
   354  }
   355  
   356  func (e *msgpackEncDriver) WriteMapStart(length int) {
   357  	e.writeContainerLen(msgpackContainerMap, length)
   358  }
   359  
   360  func (e *msgpackEncDriver) EncodeString(s string) {
   361  	var ct msgpackContainerType
   362  	if e.h.WriteExt {
   363  		if e.h.StringToRaw {
   364  			ct = msgpackContainerBin
   365  		} else {
   366  			ct = msgpackContainerStr
   367  		}
   368  	} else {
   369  		ct = msgpackContainerRawLegacy
   370  	}
   371  	e.writeContainerLen(ct, len(s))
   372  	if len(s) > 0 {
   373  		e.e.encWr.writestr(s)
   374  	}
   375  }
   376  
   377  func (e *msgpackEncDriver) EncodeStringBytesRaw(bs []byte) {
   378  	if bs == nil {
   379  		e.EncodeNil()
   380  		return
   381  	}
   382  	if e.h.WriteExt {
   383  		e.writeContainerLen(msgpackContainerBin, len(bs))
   384  	} else {
   385  		e.writeContainerLen(msgpackContainerRawLegacy, len(bs))
   386  	}
   387  	if len(bs) > 0 {
   388  		e.e.encWr.writeb(bs)
   389  	}
   390  }
   391  
   392  func (e *msgpackEncDriver) writeContainerLen(ct msgpackContainerType, l int) {
   393  	if ct.fixCutoff > 0 && l < int(ct.fixCutoff) {
   394  		e.e.encWr.writen1(ct.bFixMin | byte(l))
   395  	} else if ct.b8 > 0 && l < 256 {
   396  		e.e.encWr.writen2(ct.b8, uint8(l))
   397  	} else if l < 65536 {
   398  		e.e.encWr.writen1(ct.b16)
   399  		bigen.writeUint16(e.e.w(), uint16(l))
   400  	} else {
   401  		e.e.encWr.writen1(ct.b32)
   402  		bigen.writeUint32(e.e.w(), uint32(l))
   403  	}
   404  }
   405  
   406  //---------------------------------------------
   407  
   408  type msgpackDecDriver struct {
   409  	decDriverNoopContainerReader
   410  	decDriverNoopNumberHelper
   411  	h *MsgpackHandle
   412  	bdAndBdread
   413  	_ bool
   414  	noBuiltInTypes
   415  	d Decoder
   416  }
   417  
   418  func (d *msgpackDecDriver) decoder() *Decoder {
   419  	return &d.d
   420  }
   421  
   422  // Note: This returns either a primitive (int, bool, etc) for non-containers,
   423  // or a containerType, or a specific type denoting nil or extension.
   424  // It is called when a nil interface{} is passed, leaving it up to the DecDriver
   425  // to introspect the stream and decide how best to decode.
   426  // It deciphers the value by looking at the stream first.
   427  func (d *msgpackDecDriver) DecodeNaked() {
   428  	if !d.bdRead {
   429  		d.readNextBd()
   430  	}
   431  	bd := d.bd
   432  	n := d.d.naked()
   433  	var decodeFurther bool
   434  
   435  	switch bd {
   436  	case mpNil:
   437  		n.v = valueTypeNil
   438  		d.bdRead = false
   439  	case mpFalse:
   440  		n.v = valueTypeBool
   441  		n.b = false
   442  	case mpTrue:
   443  		n.v = valueTypeBool
   444  		n.b = true
   445  
   446  	case mpFloat:
   447  		n.v = valueTypeFloat
   448  		n.f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
   449  	case mpDouble:
   450  		n.v = valueTypeFloat
   451  		n.f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
   452  
   453  	case mpUint8:
   454  		n.v = valueTypeUint
   455  		n.u = uint64(d.d.decRd.readn1())
   456  	case mpUint16:
   457  		n.v = valueTypeUint
   458  		n.u = uint64(bigen.Uint16(d.d.decRd.readn2()))
   459  	case mpUint32:
   460  		n.v = valueTypeUint
   461  		n.u = uint64(bigen.Uint32(d.d.decRd.readn4()))
   462  	case mpUint64:
   463  		n.v = valueTypeUint
   464  		n.u = uint64(bigen.Uint64(d.d.decRd.readn8()))
   465  
   466  	case mpInt8:
   467  		n.v = valueTypeInt
   468  		n.i = int64(int8(d.d.decRd.readn1()))
   469  	case mpInt16:
   470  		n.v = valueTypeInt
   471  		n.i = int64(int16(bigen.Uint16(d.d.decRd.readn2())))
   472  	case mpInt32:
   473  		n.v = valueTypeInt
   474  		n.i = int64(int32(bigen.Uint32(d.d.decRd.readn4())))
   475  	case mpInt64:
   476  		n.v = valueTypeInt
   477  		n.i = int64(int64(bigen.Uint64(d.d.decRd.readn8())))
   478  
   479  	default:
   480  		switch {
   481  		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax:
   482  			// positive fixnum (always signed)
   483  			n.v = valueTypeInt
   484  			n.i = int64(int8(bd))
   485  		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax:
   486  			// negative fixnum
   487  			n.v = valueTypeInt
   488  			n.i = int64(int8(bd))
   489  		case bd == mpStr8, bd == mpStr16, bd == mpStr32, bd >= mpFixStrMin && bd <= mpFixStrMax:
   490  			d.d.fauxUnionReadRawBytes(d.h.WriteExt)
   491  			// if d.h.WriteExt || d.h.RawToString {
   492  			// 	n.v = valueTypeString
   493  			// 	n.s = d.d.stringZC(d.DecodeStringAsBytes())
   494  			// } else {
   495  			// 	n.v = valueTypeBytes
   496  			// 	n.l = d.DecodeBytes([]byte{})
   497  			// }
   498  		case bd == mpBin8, bd == mpBin16, bd == mpBin32:
   499  			d.d.fauxUnionReadRawBytes(false)
   500  		case bd == mpArray16, bd == mpArray32, bd >= mpFixArrayMin && bd <= mpFixArrayMax:
   501  			n.v = valueTypeArray
   502  			decodeFurther = true
   503  		case bd == mpMap16, bd == mpMap32, bd >= mpFixMapMin && bd <= mpFixMapMax:
   504  			n.v = valueTypeMap
   505  			decodeFurther = true
   506  		case bd >= mpFixExt1 && bd <= mpFixExt16, bd >= mpExt8 && bd <= mpExt32:
   507  			n.v = valueTypeExt
   508  			clen := d.readExtLen()
   509  			n.u = uint64(d.d.decRd.readn1())
   510  			if n.u == uint64(mpTimeExtTagU) {
   511  				n.v = valueTypeTime
   512  				n.t = d.decodeTime(clen)
   513  			} else if d.d.bytes {
   514  				n.l = d.d.decRd.rb.readx(uint(clen))
   515  			} else {
   516  				n.l = decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, d.d.b[:])
   517  			}
   518  		default:
   519  			d.d.errorf("cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
   520  		}
   521  	}
   522  	if !decodeFurther {
   523  		d.bdRead = false
   524  	}
   525  	if n.v == valueTypeUint && d.h.SignedInteger {
   526  		n.v = valueTypeInt
   527  		n.i = int64(n.u)
   528  	}
   529  }
   530  
   531  func (d *msgpackDecDriver) nextValueBytes(v0 []byte) (v []byte) {
   532  	if !d.bdRead {
   533  		d.readNextBd()
   534  	}
   535  	v = v0
   536  	var h = decNextValueBytesHelper{d: &d.d}
   537  	var cursor = d.d.rb.c - 1
   538  	h.append1(&v, d.bd)
   539  	v = d.nextValueBytesBdReadR(v)
   540  	d.bdRead = false
   541  	h.bytesRdV(&v, cursor)
   542  	return
   543  }
   544  
   545  func (d *msgpackDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
   546  	d.readNextBd()
   547  	v = v0
   548  	var h = decNextValueBytesHelper{d: &d.d}
   549  	h.append1(&v, d.bd)
   550  	return d.nextValueBytesBdReadR(v)
   551  }
   552  
   553  func (d *msgpackDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
   554  	v = v0
   555  	var h = decNextValueBytesHelper{d: &d.d}
   556  
   557  	bd := d.bd
   558  
   559  	var clen uint
   560  
   561  	switch bd {
   562  	case mpNil, mpFalse, mpTrue: // pass
   563  	case mpUint8, mpInt8:
   564  		h.append1(&v, d.d.decRd.readn1())
   565  	case mpUint16, mpInt16:
   566  		h.appendN(&v, d.d.decRd.readx(2)...)
   567  	case mpFloat, mpUint32, mpInt32:
   568  		h.appendN(&v, d.d.decRd.readx(4)...)
   569  	case mpDouble, mpUint64, mpInt64:
   570  		h.appendN(&v, d.d.decRd.readx(8)...)
   571  	case mpStr8, mpBin8:
   572  		clen = uint(d.d.decRd.readn1())
   573  		h.append1(&v, byte(clen))
   574  		h.appendN(&v, d.d.decRd.readx(clen)...)
   575  	case mpStr16, mpBin16:
   576  		x := d.d.decRd.readn2()
   577  		h.appendN(&v, x[:]...)
   578  		clen = uint(bigen.Uint16(x))
   579  		h.appendN(&v, d.d.decRd.readx(clen)...)
   580  	case mpStr32, mpBin32:
   581  		x := d.d.decRd.readn4()
   582  		h.appendN(&v, x[:]...)
   583  		clen = uint(bigen.Uint32(x))
   584  		h.appendN(&v, d.d.decRd.readx(clen)...)
   585  	case mpFixExt1:
   586  		h.append1(&v, d.d.decRd.readn1()) // tag
   587  		h.append1(&v, d.d.decRd.readn1())
   588  	case mpFixExt2:
   589  		h.append1(&v, d.d.decRd.readn1()) // tag
   590  		h.appendN(&v, d.d.decRd.readx(2)...)
   591  	case mpFixExt4:
   592  		h.append1(&v, d.d.decRd.readn1()) // tag
   593  		h.appendN(&v, d.d.decRd.readx(4)...)
   594  	case mpFixExt8:
   595  		h.append1(&v, d.d.decRd.readn1()) // tag
   596  		h.appendN(&v, d.d.decRd.readx(8)...)
   597  	case mpFixExt16:
   598  		h.append1(&v, d.d.decRd.readn1()) // tag
   599  		h.appendN(&v, d.d.decRd.readx(16)...)
   600  	case mpExt8:
   601  		clen = uint(d.d.decRd.readn1())
   602  		h.append1(&v, uint8(clen))
   603  		h.append1(&v, d.d.decRd.readn1()) // tag
   604  		h.appendN(&v, d.d.decRd.readx(clen)...)
   605  	case mpExt16:
   606  		x := d.d.decRd.readn2()
   607  		clen = uint(bigen.Uint16(x))
   608  		h.appendN(&v, x[:]...)
   609  		h.append1(&v, d.d.decRd.readn1()) // tag
   610  		h.appendN(&v, d.d.decRd.readx(clen)...)
   611  	case mpExt32:
   612  		x := d.d.decRd.readn4()
   613  		clen = uint(bigen.Uint32(x))
   614  		h.appendN(&v, x[:]...)
   615  		h.append1(&v, d.d.decRd.readn1()) // tag
   616  		h.appendN(&v, d.d.decRd.readx(clen)...)
   617  	case mpArray16:
   618  		x := d.d.decRd.readn2()
   619  		clen = uint(bigen.Uint16(x))
   620  		h.appendN(&v, x[:]...)
   621  		for i := uint(0); i < clen; i++ {
   622  			v = d.nextValueBytesR(v)
   623  		}
   624  	case mpArray32:
   625  		x := d.d.decRd.readn4()
   626  		clen = uint(bigen.Uint32(x))
   627  		h.appendN(&v, x[:]...)
   628  		for i := uint(0); i < clen; i++ {
   629  			v = d.nextValueBytesR(v)
   630  		}
   631  	case mpMap16:
   632  		x := d.d.decRd.readn2()
   633  		clen = uint(bigen.Uint16(x))
   634  		h.appendN(&v, x[:]...)
   635  		for i := uint(0); i < clen; i++ {
   636  			v = d.nextValueBytesR(v)
   637  			v = d.nextValueBytesR(v)
   638  		}
   639  	case mpMap32:
   640  		x := d.d.decRd.readn4()
   641  		clen = uint(bigen.Uint32(x))
   642  		h.appendN(&v, x[:]...)
   643  		for i := uint(0); i < clen; i++ {
   644  			v = d.nextValueBytesR(v)
   645  			v = d.nextValueBytesR(v)
   646  		}
   647  	default:
   648  		switch {
   649  		case bd >= mpPosFixNumMin && bd <= mpPosFixNumMax: // pass
   650  		case bd >= mpNegFixNumMin && bd <= mpNegFixNumMax: // pass
   651  		case bd >= mpFixStrMin && bd <= mpFixStrMax:
   652  			clen = uint(mpFixStrMin ^ bd)
   653  			h.appendN(&v, d.d.decRd.readx(clen)...)
   654  		case bd >= mpFixArrayMin && bd <= mpFixArrayMax:
   655  			clen = uint(mpFixArrayMin ^ bd)
   656  			for i := uint(0); i < clen; i++ {
   657  				v = d.nextValueBytesR(v)
   658  			}
   659  		case bd >= mpFixMapMin && bd <= mpFixMapMax:
   660  			clen = uint(mpFixMapMin ^ bd)
   661  			for i := uint(0); i < clen; i++ {
   662  				v = d.nextValueBytesR(v)
   663  				v = d.nextValueBytesR(v)
   664  			}
   665  		default:
   666  			d.d.errorf("nextValueBytes: cannot infer value: %s: Ox%x/%d/%s", msgBadDesc, bd, bd, mpdesc(bd))
   667  		}
   668  	}
   669  	return
   670  }
   671  
   672  func (d *msgpackDecDriver) decFloat4Int32() (f float32) {
   673  	fbits := bigen.Uint32(d.d.decRd.readn4())
   674  	f = math.Float32frombits(fbits)
   675  	if !noFrac32(fbits) {
   676  		d.d.errorf("assigning integer value from float32 with a fraction: %v", f)
   677  	}
   678  	return
   679  }
   680  
   681  func (d *msgpackDecDriver) decFloat4Int64() (f float64) {
   682  	fbits := bigen.Uint64(d.d.decRd.readn8())
   683  	f = math.Float64frombits(fbits)
   684  	if !noFrac64(fbits) {
   685  		d.d.errorf("assigning integer value from float64 with a fraction: %v", f)
   686  	}
   687  	return
   688  }
   689  
   690  // int can be decoded from msgpack type: intXXX or uintXXX
   691  func (d *msgpackDecDriver) DecodeInt64() (i int64) {
   692  	if d.advanceNil() {
   693  		return
   694  	}
   695  	switch d.bd {
   696  	case mpUint8:
   697  		i = int64(uint64(d.d.decRd.readn1()))
   698  	case mpUint16:
   699  		i = int64(uint64(bigen.Uint16(d.d.decRd.readn2())))
   700  	case mpUint32:
   701  		i = int64(uint64(bigen.Uint32(d.d.decRd.readn4())))
   702  	case mpUint64:
   703  		i = int64(bigen.Uint64(d.d.decRd.readn8()))
   704  	case mpInt8:
   705  		i = int64(int8(d.d.decRd.readn1()))
   706  	case mpInt16:
   707  		i = int64(int16(bigen.Uint16(d.d.decRd.readn2())))
   708  	case mpInt32:
   709  		i = int64(int32(bigen.Uint32(d.d.decRd.readn4())))
   710  	case mpInt64:
   711  		i = int64(bigen.Uint64(d.d.decRd.readn8()))
   712  	case mpFloat:
   713  		i = int64(d.decFloat4Int32())
   714  	case mpDouble:
   715  		i = int64(d.decFloat4Int64())
   716  	default:
   717  		switch {
   718  		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
   719  			i = int64(int8(d.bd))
   720  		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
   721  			i = int64(int8(d.bd))
   722  		default:
   723  			d.d.errorf("cannot decode signed integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
   724  		}
   725  	}
   726  	d.bdRead = false
   727  	return
   728  }
   729  
   730  // uint can be decoded from msgpack type: intXXX or uintXXX
   731  func (d *msgpackDecDriver) DecodeUint64() (ui uint64) {
   732  	if d.advanceNil() {
   733  		return
   734  	}
   735  	switch d.bd {
   736  	case mpUint8:
   737  		ui = uint64(d.d.decRd.readn1())
   738  	case mpUint16:
   739  		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
   740  	case mpUint32:
   741  		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
   742  	case mpUint64:
   743  		ui = bigen.Uint64(d.d.decRd.readn8())
   744  	case mpInt8:
   745  		if i := int64(int8(d.d.decRd.readn1())); i >= 0 {
   746  			ui = uint64(i)
   747  		} else {
   748  			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
   749  		}
   750  	case mpInt16:
   751  		if i := int64(int16(bigen.Uint16(d.d.decRd.readn2()))); i >= 0 {
   752  			ui = uint64(i)
   753  		} else {
   754  			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
   755  		}
   756  	case mpInt32:
   757  		if i := int64(int32(bigen.Uint32(d.d.decRd.readn4()))); i >= 0 {
   758  			ui = uint64(i)
   759  		} else {
   760  			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
   761  		}
   762  	case mpInt64:
   763  		if i := int64(bigen.Uint64(d.d.decRd.readn8())); i >= 0 {
   764  			ui = uint64(i)
   765  		} else {
   766  			d.d.errorf("assigning negative signed value: %v, to unsigned type", i)
   767  		}
   768  	case mpFloat:
   769  		if f := d.decFloat4Int32(); f >= 0 {
   770  			ui = uint64(f)
   771  		} else {
   772  			d.d.errorf("assigning negative float value: %v, to unsigned type", f)
   773  		}
   774  	case mpDouble:
   775  		if f := d.decFloat4Int64(); f >= 0 {
   776  			ui = uint64(f)
   777  		} else {
   778  			d.d.errorf("assigning negative float value: %v, to unsigned type", f)
   779  		}
   780  	default:
   781  		switch {
   782  		case d.bd >= mpPosFixNumMin && d.bd <= mpPosFixNumMax:
   783  			ui = uint64(d.bd)
   784  		case d.bd >= mpNegFixNumMin && d.bd <= mpNegFixNumMax:
   785  			d.d.errorf("assigning negative signed value: %v, to unsigned type", int(d.bd))
   786  		default:
   787  			d.d.errorf("cannot decode unsigned integer: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
   788  		}
   789  	}
   790  	d.bdRead = false
   791  	return
   792  }
   793  
   794  // float can either be decoded from msgpack type: float, double or intX
   795  func (d *msgpackDecDriver) DecodeFloat64() (f float64) {
   796  	if d.advanceNil() {
   797  		return
   798  	}
   799  	if d.bd == mpFloat {
   800  		f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
   801  	} else if d.bd == mpDouble {
   802  		f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
   803  	} else {
   804  		f = float64(d.DecodeInt64())
   805  	}
   806  	d.bdRead = false
   807  	return
   808  }
   809  
   810  // bool can be decoded from bool, fixnum 0 or 1.
   811  func (d *msgpackDecDriver) DecodeBool() (b bool) {
   812  	if d.advanceNil() {
   813  		return
   814  	}
   815  	if d.bd == mpFalse || d.bd == 0 {
   816  		// b = false
   817  	} else if d.bd == mpTrue || d.bd == 1 {
   818  		b = true
   819  	} else {
   820  		d.d.errorf("cannot decode bool: %s: %x/%s", msgBadDesc, d.bd, mpdesc(d.bd))
   821  	}
   822  	d.bdRead = false
   823  	return
   824  }
   825  
   826  func (d *msgpackDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
   827  	d.d.decByteState = decByteStateNone
   828  	if d.advanceNil() {
   829  		return
   830  	}
   831  
   832  	bd := d.bd
   833  	var clen int
   834  	if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
   835  		clen = d.readContainerLen(msgpackContainerBin) // binary
   836  	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
   837  		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
   838  		clen = d.readContainerLen(msgpackContainerStr) // string/raw
   839  	} else if bd == mpArray16 || bd == mpArray32 ||
   840  		(bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
   841  		// check if an "array" of uint8's
   842  		if bs == nil {
   843  			d.d.decByteState = decByteStateReuseBuf
   844  			bs = d.d.b[:]
   845  		}
   846  		// bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
   847  		slen := d.ReadArrayStart()
   848  		var changed bool
   849  		if bs, changed = usableByteSlice(bs, slen); changed {
   850  			d.d.decByteState = decByteStateNone
   851  		}
   852  		for i := 0; i < len(bs); i++ {
   853  			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
   854  		}
   855  		for i := len(bs); i < slen; i++ {
   856  			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
   857  		}
   858  		return bs
   859  	} else {
   860  		d.d.errorf("invalid byte descriptor for decoding bytes, got: 0x%x", d.bd)
   861  	}
   862  
   863  	d.bdRead = false
   864  	if d.d.zerocopy() {
   865  		d.d.decByteState = decByteStateZerocopy
   866  		return d.d.decRd.rb.readx(uint(clen))
   867  	}
   868  	if bs == nil {
   869  		d.d.decByteState = decByteStateReuseBuf
   870  		bs = d.d.b[:]
   871  	}
   872  	return decByteSlice(d.d.r(), clen, d.h.MaxInitLen, bs)
   873  }
   874  
   875  func (d *msgpackDecDriver) DecodeStringAsBytes() (s []byte) {
   876  	s = d.DecodeBytes(nil)
   877  	if d.h.ValidateUnicode && !utf8.Valid(s) {
   878  		d.d.errorf("DecodeStringAsBytes: invalid UTF-8: %s", s)
   879  	}
   880  	return
   881  }
   882  
   883  func (d *msgpackDecDriver) descBd() string {
   884  	return sprintf("%v (%s)", d.bd, mpdesc(d.bd))
   885  }
   886  
   887  func (d *msgpackDecDriver) readNextBd() {
   888  	d.bd = d.d.decRd.readn1()
   889  	d.bdRead = true
   890  }
   891  
   892  func (d *msgpackDecDriver) advanceNil() (null bool) {
   893  	if !d.bdRead {
   894  		d.readNextBd()
   895  	}
   896  	if d.bd == mpNil {
   897  		d.bdRead = false
   898  		return true // null = true
   899  	}
   900  	return
   901  }
   902  
   903  func (d *msgpackDecDriver) TryNil() (v bool) {
   904  	return d.advanceNil()
   905  }
   906  
   907  func (d *msgpackDecDriver) ContainerType() (vt valueType) {
   908  	if !d.bdRead {
   909  		d.readNextBd()
   910  	}
   911  	bd := d.bd
   912  	if bd == mpNil {
   913  		d.bdRead = false
   914  		return valueTypeNil
   915  	} else if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
   916  		return valueTypeBytes
   917  	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
   918  		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
   919  		if d.h.WriteExt || d.h.RawToString { // UTF-8 string (new spec)
   920  			return valueTypeString
   921  		}
   922  		return valueTypeBytes // raw (old spec)
   923  	} else if bd == mpArray16 || bd == mpArray32 || (bd >= mpFixArrayMin && bd <= mpFixArrayMax) {
   924  		return valueTypeArray
   925  	} else if bd == mpMap16 || bd == mpMap32 || (bd >= mpFixMapMin && bd <= mpFixMapMax) {
   926  		return valueTypeMap
   927  	}
   928  	return valueTypeUnset
   929  }
   930  
   931  func (d *msgpackDecDriver) readContainerLen(ct msgpackContainerType) (clen int) {
   932  	bd := d.bd
   933  	if bd == ct.b8 {
   934  		clen = int(d.d.decRd.readn1())
   935  	} else if bd == ct.b16 {
   936  		clen = int(bigen.Uint16(d.d.decRd.readn2()))
   937  	} else if bd == ct.b32 {
   938  		clen = int(bigen.Uint32(d.d.decRd.readn4()))
   939  	} else if (ct.bFixMin & bd) == ct.bFixMin {
   940  		clen = int(ct.bFixMin ^ bd)
   941  	} else {
   942  		d.d.errorf("cannot read container length: %s: hex: %x, decimal: %d", msgBadDesc, bd, bd)
   943  	}
   944  	d.bdRead = false
   945  	return
   946  }
   947  
   948  func (d *msgpackDecDriver) ReadMapStart() int {
   949  	if d.advanceNil() {
   950  		return containerLenNil
   951  	}
   952  	return d.readContainerLen(msgpackContainerMap)
   953  }
   954  
   955  func (d *msgpackDecDriver) ReadArrayStart() int {
   956  	if d.advanceNil() {
   957  		return containerLenNil
   958  	}
   959  	return d.readContainerLen(msgpackContainerList)
   960  }
   961  
   962  func (d *msgpackDecDriver) readExtLen() (clen int) {
   963  	switch d.bd {
   964  	case mpFixExt1:
   965  		clen = 1
   966  	case mpFixExt2:
   967  		clen = 2
   968  	case mpFixExt4:
   969  		clen = 4
   970  	case mpFixExt8:
   971  		clen = 8
   972  	case mpFixExt16:
   973  		clen = 16
   974  	case mpExt8:
   975  		clen = int(d.d.decRd.readn1())
   976  	case mpExt16:
   977  		clen = int(bigen.Uint16(d.d.decRd.readn2()))
   978  	case mpExt32:
   979  		clen = int(bigen.Uint32(d.d.decRd.readn4()))
   980  	default:
   981  		d.d.errorf("decoding ext bytes: found unexpected byte: %x", d.bd)
   982  	}
   983  	return
   984  }
   985  
   986  func (d *msgpackDecDriver) DecodeTime() (t time.Time) {
   987  	// decode time from string bytes or ext
   988  	if d.advanceNil() {
   989  		return
   990  	}
   991  	bd := d.bd
   992  	var clen int
   993  	if bd == mpBin8 || bd == mpBin16 || bd == mpBin32 {
   994  		clen = d.readContainerLen(msgpackContainerBin) // binary
   995  	} else if bd == mpStr8 || bd == mpStr16 || bd == mpStr32 ||
   996  		(bd >= mpFixStrMin && bd <= mpFixStrMax) {
   997  		clen = d.readContainerLen(msgpackContainerStr) // string/raw
   998  	} else {
   999  		// expect to see mpFixExt4,-1 OR mpFixExt8,-1 OR mpExt8,12,-1
  1000  		d.bdRead = false
  1001  		b2 := d.d.decRd.readn1()
  1002  		if d.bd == mpFixExt4 && b2 == mpTimeExtTagU {
  1003  			clen = 4
  1004  		} else if d.bd == mpFixExt8 && b2 == mpTimeExtTagU {
  1005  			clen = 8
  1006  		} else if d.bd == mpExt8 && b2 == 12 && d.d.decRd.readn1() == mpTimeExtTagU {
  1007  			clen = 12
  1008  		} else {
  1009  			d.d.errorf("invalid stream for decoding time as extension: got 0x%x, 0x%x", d.bd, b2)
  1010  		}
  1011  	}
  1012  	return d.decodeTime(clen)
  1013  }
  1014  
  1015  func (d *msgpackDecDriver) decodeTime(clen int) (t time.Time) {
  1016  	d.bdRead = false
  1017  	switch clen {
  1018  	case 4:
  1019  		t = time.Unix(int64(bigen.Uint32(d.d.decRd.readn4())), 0).UTC()
  1020  	case 8:
  1021  		tv := bigen.Uint64(d.d.decRd.readn8())
  1022  		t = time.Unix(int64(tv&0x00000003ffffffff), int64(tv>>34)).UTC()
  1023  	case 12:
  1024  		nsec := bigen.Uint32(d.d.decRd.readn4())
  1025  		sec := bigen.Uint64(d.d.decRd.readn8())
  1026  		t = time.Unix(int64(sec), int64(nsec)).UTC()
  1027  	default:
  1028  		d.d.errorf("invalid length of bytes for decoding time - expecting 4 or 8 or 12, got %d", clen)
  1029  	}
  1030  	return
  1031  }
  1032  
  1033  func (d *msgpackDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
  1034  	if xtag > 0xff {
  1035  		d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
  1036  	}
  1037  	if d.advanceNil() {
  1038  		return
  1039  	}
  1040  	xbs, realxtag1, zerocopy := d.decodeExtV(ext != nil, uint8(xtag))
  1041  	realxtag := uint64(realxtag1)
  1042  	if ext == nil {
  1043  		re := rv.(*RawExt)
  1044  		re.Tag = realxtag
  1045  		re.setData(xbs, zerocopy)
  1046  	} else if ext == SelfExt {
  1047  		d.d.sideDecode(rv, basetype, xbs)
  1048  	} else {
  1049  		ext.ReadExt(rv, xbs)
  1050  	}
  1051  }
  1052  
  1053  func (d *msgpackDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xtag byte, zerocopy bool) {
  1054  	xbd := d.bd
  1055  	if xbd == mpBin8 || xbd == mpBin16 || xbd == mpBin32 {
  1056  		xbs = d.DecodeBytes(nil)
  1057  	} else if xbd == mpStr8 || xbd == mpStr16 || xbd == mpStr32 ||
  1058  		(xbd >= mpFixStrMin && xbd <= mpFixStrMax) {
  1059  		xbs = d.DecodeStringAsBytes()
  1060  	} else {
  1061  		clen := d.readExtLen()
  1062  		xtag = d.d.decRd.readn1()
  1063  		if verifyTag && xtag != tag {
  1064  			d.d.errorf("wrong extension tag - got %b, expecting %v", xtag, tag)
  1065  		}
  1066  		if d.d.bytes {
  1067  			xbs = d.d.decRd.rb.readx(uint(clen))
  1068  			zerocopy = true
  1069  		} else {
  1070  			xbs = decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, d.d.b[:])
  1071  		}
  1072  	}
  1073  	d.bdRead = false
  1074  	return
  1075  }
  1076  
  1077  //--------------------------------------------------
  1078  
  1079  // MsgpackHandle is a Handle for the Msgpack Schema-Free Encoding Format.
  1080  type MsgpackHandle struct {
  1081  	binaryEncodingType
  1082  	BasicHandle
  1083  
  1084  	// NoFixedNum says to output all signed integers as 2-bytes, never as 1-byte fixednum.
  1085  	NoFixedNum bool
  1086  
  1087  	// WriteExt controls whether the new spec is honored.
  1088  	//
  1089  	// With WriteExt=true, we can encode configured extensions with extension tags
  1090  	// and encode string/[]byte/extensions in a way compatible with the new spec
  1091  	// but incompatible with the old spec.
  1092  	//
  1093  	// For compatibility with the old spec, set WriteExt=false.
  1094  	//
  1095  	// With WriteExt=false:
  1096  	//    configured extensions are serialized as raw bytes (not msgpack extensions).
  1097  	//    reserved byte descriptors like Str8 and those enabling the new msgpack Binary type
  1098  	//    are not encoded.
  1099  	WriteExt bool
  1100  
  1101  	// PositiveIntUnsigned says to encode positive integers as unsigned.
  1102  	PositiveIntUnsigned bool
  1103  }
  1104  
  1105  // Name returns the name of the handle: msgpack
  1106  func (h *MsgpackHandle) Name() string { return "msgpack" }
  1107  
  1108  func (h *MsgpackHandle) desc(bd byte) string { return mpdesc(bd) }
  1109  
  1110  func (h *MsgpackHandle) newEncDriver() encDriver {
  1111  	var e = &msgpackEncDriver{h: h}
  1112  	e.e.e = e
  1113  	e.e.init(h)
  1114  	e.reset()
  1115  	return e
  1116  }
  1117  
  1118  func (h *MsgpackHandle) newDecDriver() decDriver {
  1119  	d := &msgpackDecDriver{h: h}
  1120  	d.d.d = d
  1121  	d.d.init(h)
  1122  	d.reset()
  1123  	return d
  1124  }
  1125  
  1126  //--------------------------------------------------
  1127  
  1128  type msgpackSpecRpcCodec struct {
  1129  	rpcCodec
  1130  }
  1131  
  1132  // /////////////// Spec RPC Codec ///////////////////
  1133  func (c *msgpackSpecRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error {
  1134  	// WriteRequest can write to both a Go service, and other services that do
  1135  	// not abide by the 1 argument rule of a Go service.
  1136  	// We discriminate based on if the body is a MsgpackSpecRpcMultiArgs
  1137  	var bodyArr []interface{}
  1138  	if m, ok := body.(MsgpackSpecRpcMultiArgs); ok {
  1139  		bodyArr = ([]interface{})(m)
  1140  	} else {
  1141  		bodyArr = []interface{}{body}
  1142  	}
  1143  	r2 := []interface{}{0, uint32(r.Seq), r.ServiceMethod, bodyArr}
  1144  	return c.write(r2)
  1145  }
  1146  
  1147  func (c *msgpackSpecRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
  1148  	var moe interface{}
  1149  	if r.Error != "" {
  1150  		moe = r.Error
  1151  	}
  1152  	if moe != nil && body != nil {
  1153  		body = nil
  1154  	}
  1155  	r2 := []interface{}{1, uint32(r.Seq), moe, body}
  1156  	return c.write(r2)
  1157  }
  1158  
  1159  func (c *msgpackSpecRpcCodec) ReadResponseHeader(r *rpc.Response) error {
  1160  	return c.parseCustomHeader(1, &r.Seq, &r.Error)
  1161  }
  1162  
  1163  func (c *msgpackSpecRpcCodec) ReadRequestHeader(r *rpc.Request) error {
  1164  	return c.parseCustomHeader(0, &r.Seq, &r.ServiceMethod)
  1165  }
  1166  
  1167  func (c *msgpackSpecRpcCodec) ReadRequestBody(body interface{}) error {
  1168  	if body == nil { // read and discard
  1169  		return c.read(nil)
  1170  	}
  1171  	bodyArr := []interface{}{body}
  1172  	return c.read(&bodyArr)
  1173  }
  1174  
  1175  func (c *msgpackSpecRpcCodec) parseCustomHeader(expectTypeByte byte, msgid *uint64, methodOrError *string) (err error) {
  1176  	if cls := c.cls.load(); cls.closed {
  1177  		return io.ErrUnexpectedEOF
  1178  	}
  1179  
  1180  	// We read the response header by hand
  1181  	// so that the body can be decoded on its own from the stream at a later time.
  1182  
  1183  	const fia byte = 0x94 //four item array descriptor value
  1184  
  1185  	var ba [1]byte
  1186  	var n int
  1187  	for {
  1188  		n, err = c.r.Read(ba[:])
  1189  		if err != nil {
  1190  			return
  1191  		}
  1192  		if n == 1 {
  1193  			break
  1194  		}
  1195  	}
  1196  
  1197  	var b = ba[0]
  1198  	if b != fia {
  1199  		err = fmt.Errorf("not array - %s %x/%s", msgBadDesc, b, mpdesc(b))
  1200  	} else {
  1201  		err = c.read(&b)
  1202  		if err == nil {
  1203  			if b != expectTypeByte {
  1204  				err = fmt.Errorf("%s - expecting %v but got %x/%s", msgBadDesc, expectTypeByte, b, mpdesc(b))
  1205  			} else {
  1206  				err = c.read(msgid)
  1207  				if err == nil {
  1208  					err = c.read(methodOrError)
  1209  				}
  1210  			}
  1211  		}
  1212  	}
  1213  	return
  1214  }
  1215  
  1216  //--------------------------------------------------
  1217  
  1218  // msgpackSpecRpc is the implementation of Rpc that uses custom communication protocol
  1219  // as defined in the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
  1220  type msgpackSpecRpc struct{}
  1221  
  1222  // MsgpackSpecRpc implements Rpc using the communication protocol defined in
  1223  // the msgpack spec at https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md .
  1224  //
  1225  // See GoRpc documentation, for information on buffering for better performance.
  1226  var MsgpackSpecRpc msgpackSpecRpc
  1227  
  1228  func (x msgpackSpecRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
  1229  	return &msgpackSpecRpcCodec{newRPCCodec(conn, h)}
  1230  }
  1231  
  1232  func (x msgpackSpecRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec {
  1233  	return &msgpackSpecRpcCodec{newRPCCodec(conn, h)}
  1234  }
  1235  
  1236  var _ decDriver = (*msgpackDecDriver)(nil)
  1237  var _ encDriver = (*msgpackEncDriver)(nil)
  1238  

View as plain text