Source file src/github.com/ugorji/go/codec/cbor.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  package codec
     5  
     6  import (
     7  	"math"
     8  	"reflect"
     9  	"time"
    10  	"unicode/utf8"
    11  )
    12  
    13  // major
    14  const (
    15  	cborMajorUint byte = iota
    16  	cborMajorNegInt
    17  	cborMajorBytes
    18  	cborMajorString
    19  	cborMajorArray
    20  	cborMajorMap
    21  	cborMajorTag
    22  	cborMajorSimpleOrFloat
    23  )
    24  
    25  // simple
    26  const (
    27  	cborBdFalse byte = 0xf4 + iota
    28  	cborBdTrue
    29  	cborBdNil
    30  	cborBdUndefined
    31  	cborBdExt
    32  	cborBdFloat16
    33  	cborBdFloat32
    34  	cborBdFloat64
    35  )
    36  
    37  // indefinite
    38  const (
    39  	cborBdIndefiniteBytes  byte = 0x5f
    40  	cborBdIndefiniteString byte = 0x7f
    41  	cborBdIndefiniteArray  byte = 0x9f
    42  	cborBdIndefiniteMap    byte = 0xbf
    43  	cborBdBreak            byte = 0xff
    44  )
    45  
    46  // These define some in-stream descriptors for
    47  // manual encoding e.g. when doing explicit indefinite-length
    48  const (
    49  	CborStreamBytes  byte = 0x5f
    50  	CborStreamString byte = 0x7f
    51  	CborStreamArray  byte = 0x9f
    52  	CborStreamMap    byte = 0xbf
    53  	CborStreamBreak  byte = 0xff
    54  )
    55  
    56  // base values
    57  const (
    58  	cborBaseUint   byte = 0x00
    59  	cborBaseNegInt byte = 0x20
    60  	cborBaseBytes  byte = 0x40
    61  	cborBaseString byte = 0x60
    62  	cborBaseArray  byte = 0x80
    63  	cborBaseMap    byte = 0xa0
    64  	cborBaseTag    byte = 0xc0
    65  	cborBaseSimple byte = 0xe0
    66  )
    67  
    68  // const (
    69  // 	cborSelfDesrTag  byte = 0xd9
    70  // 	cborSelfDesrTag2 byte = 0xd9
    71  // 	cborSelfDesrTag3 byte = 0xf7
    72  // )
    73  
    74  var (
    75  	cbordescSimpleNames = map[byte]string{
    76  		cborBdNil:     "nil",
    77  		cborBdFalse:   "false",
    78  		cborBdTrue:    "true",
    79  		cborBdFloat16: "float",
    80  		cborBdFloat32: "float",
    81  		cborBdFloat64: "float",
    82  		cborBdBreak:   "break",
    83  	}
    84  	cbordescIndefNames = map[byte]string{
    85  		cborBdIndefiniteBytes:  "bytes*",
    86  		cborBdIndefiniteString: "string*",
    87  		cborBdIndefiniteArray:  "array*",
    88  		cborBdIndefiniteMap:    "map*",
    89  	}
    90  	cbordescMajorNames = map[byte]string{
    91  		cborMajorUint:          "(u)int",
    92  		cborMajorNegInt:        "int",
    93  		cborMajorBytes:         "bytes",
    94  		cborMajorString:        "string",
    95  		cborMajorArray:         "array",
    96  		cborMajorMap:           "map",
    97  		cborMajorTag:           "tag",
    98  		cborMajorSimpleOrFloat: "simple",
    99  	}
   100  )
   101  
   102  func cbordesc(bd byte) (s string) {
   103  	bm := bd >> 5
   104  	if bm == cborMajorSimpleOrFloat {
   105  		s = cbordescSimpleNames[bd]
   106  	} else {
   107  		s = cbordescMajorNames[bm]
   108  		if s == "" {
   109  			s = cbordescIndefNames[bd]
   110  		}
   111  	}
   112  	if s == "" {
   113  		s = "unknown"
   114  	}
   115  	return
   116  }
   117  
   118  // -------------------
   119  
   120  type cborEncDriver struct {
   121  	noBuiltInTypes
   122  	encDriverNoState
   123  	encDriverNoopContainerWriter
   124  	h *CborHandle
   125  
   126  	// scratch buffer for: encode time, numbers, etc
   127  	//
   128  	// RFC3339Nano uses 35 chars: 2006-01-02T15:04:05.999999999Z07:00
   129  	b [40]byte
   130  
   131  	e Encoder
   132  }
   133  
   134  func (e *cborEncDriver) encoder() *Encoder {
   135  	return &e.e
   136  }
   137  
   138  func (e *cborEncDriver) EncodeNil() {
   139  	e.e.encWr.writen1(cborBdNil)
   140  }
   141  
   142  func (e *cborEncDriver) EncodeBool(b bool) {
   143  	if b {
   144  		e.e.encWr.writen1(cborBdTrue)
   145  	} else {
   146  		e.e.encWr.writen1(cborBdFalse)
   147  	}
   148  }
   149  
   150  func (e *cborEncDriver) EncodeFloat32(f float32) {
   151  	b := math.Float32bits(f)
   152  	if e.h.OptimumSize {
   153  		if h := floatToHalfFloatBits(b); halfFloatToFloatBits(h) == b {
   154  			e.e.encWr.writen1(cborBdFloat16)
   155  			bigen.writeUint16(e.e.w(), h)
   156  			return
   157  		}
   158  	}
   159  	e.e.encWr.writen1(cborBdFloat32)
   160  	bigen.writeUint32(e.e.w(), b)
   161  }
   162  
   163  func (e *cborEncDriver) EncodeFloat64(f float64) {
   164  	if e.h.OptimumSize {
   165  		if f32 := float32(f); float64(f32) == f {
   166  			e.EncodeFloat32(f32)
   167  			return
   168  		}
   169  	}
   170  	e.e.encWr.writen1(cborBdFloat64)
   171  	bigen.writeUint64(e.e.w(), math.Float64bits(f))
   172  }
   173  
   174  func (e *cborEncDriver) encUint(v uint64, bd byte) {
   175  	if v <= 0x17 {
   176  		e.e.encWr.writen1(byte(v) + bd)
   177  	} else if v <= math.MaxUint8 {
   178  		e.e.encWr.writen2(bd+0x18, uint8(v))
   179  	} else if v <= math.MaxUint16 {
   180  		e.e.encWr.writen1(bd + 0x19)
   181  		bigen.writeUint16(e.e.w(), uint16(v))
   182  	} else if v <= math.MaxUint32 {
   183  		e.e.encWr.writen1(bd + 0x1a)
   184  		bigen.writeUint32(e.e.w(), uint32(v))
   185  	} else { // if v <= math.MaxUint64 {
   186  		e.e.encWr.writen1(bd + 0x1b)
   187  		bigen.writeUint64(e.e.w(), v)
   188  	}
   189  }
   190  
   191  func (e *cborEncDriver) EncodeInt(v int64) {
   192  	if v < 0 {
   193  		e.encUint(uint64(-1-v), cborBaseNegInt)
   194  	} else {
   195  		e.encUint(uint64(v), cborBaseUint)
   196  	}
   197  }
   198  
   199  func (e *cborEncDriver) EncodeUint(v uint64) {
   200  	e.encUint(v, cborBaseUint)
   201  }
   202  
   203  func (e *cborEncDriver) encLen(bd byte, length int) {
   204  	e.encUint(uint64(length), bd)
   205  }
   206  
   207  func (e *cborEncDriver) EncodeTime(t time.Time) {
   208  	if t.IsZero() {
   209  		e.EncodeNil()
   210  	} else if e.h.TimeRFC3339 {
   211  		e.encUint(0, cborBaseTag)
   212  		e.encStringBytesS(cborBaseString, stringView(fmtTime(t, time.RFC3339Nano, e.b[:0])))
   213  	} else {
   214  		e.encUint(1, cborBaseTag)
   215  		t = t.UTC().Round(time.Microsecond)
   216  		sec, nsec := t.Unix(), uint64(t.Nanosecond())
   217  		if nsec == 0 {
   218  			e.EncodeInt(sec)
   219  		} else {
   220  			e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
   221  		}
   222  	}
   223  }
   224  
   225  func (e *cborEncDriver) EncodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
   226  	e.encUint(uint64(xtag), cborBaseTag)
   227  	if ext == SelfExt {
   228  		e.e.encodeValue(baseRV(rv), e.h.fnNoExt(basetype))
   229  	} else if v := ext.ConvertExt(rv); v == nil {
   230  		e.EncodeNil()
   231  	} else {
   232  		e.e.encode(v)
   233  	}
   234  }
   235  
   236  func (e *cborEncDriver) EncodeRawExt(re *RawExt) {
   237  	e.encUint(uint64(re.Tag), cborBaseTag)
   238  	// only encodes re.Value (never re.Data)
   239  	if re.Value != nil {
   240  		e.e.encode(re.Value)
   241  	} else {
   242  		e.EncodeNil()
   243  	}
   244  }
   245  
   246  func (e *cborEncDriver) WriteArrayStart(length int) {
   247  	if e.h.IndefiniteLength {
   248  		e.e.encWr.writen1(cborBdIndefiniteArray)
   249  	} else {
   250  		e.encLen(cborBaseArray, length)
   251  	}
   252  }
   253  
   254  func (e *cborEncDriver) WriteMapStart(length int) {
   255  	if e.h.IndefiniteLength {
   256  		e.e.encWr.writen1(cborBdIndefiniteMap)
   257  	} else {
   258  		e.encLen(cborBaseMap, length)
   259  	}
   260  }
   261  
   262  func (e *cborEncDriver) WriteMapEnd() {
   263  	if e.h.IndefiniteLength {
   264  		e.e.encWr.writen1(cborBdBreak)
   265  	}
   266  }
   267  
   268  func (e *cborEncDriver) WriteArrayEnd() {
   269  	if e.h.IndefiniteLength {
   270  		e.e.encWr.writen1(cborBdBreak)
   271  	}
   272  }
   273  
   274  func (e *cborEncDriver) EncodeString(v string) {
   275  	bb := cborBaseString
   276  	if e.h.StringToRaw {
   277  		bb = cborBaseBytes
   278  	}
   279  	e.encStringBytesS(bb, v)
   280  }
   281  
   282  func (e *cborEncDriver) EncodeStringBytesRaw(v []byte) {
   283  	if v == nil {
   284  		e.EncodeNil()
   285  	} else {
   286  		e.encStringBytesS(cborBaseBytes, stringView(v))
   287  	}
   288  }
   289  
   290  func (e *cborEncDriver) encStringBytesS(bb byte, v string) {
   291  	if e.h.IndefiniteLength {
   292  		if bb == cborBaseBytes {
   293  			e.e.encWr.writen1(cborBdIndefiniteBytes)
   294  		} else {
   295  			e.e.encWr.writen1(cborBdIndefiniteString)
   296  		}
   297  		var vlen uint = uint(len(v))
   298  		blen := vlen / 4
   299  		if blen == 0 {
   300  			blen = 64
   301  		} else if blen > 1024 {
   302  			blen = 1024
   303  		}
   304  		for i := uint(0); i < vlen; {
   305  			var v2 string
   306  			i2 := i + blen
   307  			if i2 >= i && i2 < vlen {
   308  				v2 = v[i:i2]
   309  			} else {
   310  				v2 = v[i:]
   311  			}
   312  			e.encLen(bb, len(v2))
   313  			e.e.encWr.writestr(v2)
   314  			i = i2
   315  		}
   316  		e.e.encWr.writen1(cborBdBreak)
   317  	} else {
   318  		e.encLen(bb, len(v))
   319  		e.e.encWr.writestr(v)
   320  	}
   321  }
   322  
   323  // ----------------------
   324  
   325  type cborDecDriver struct {
   326  	decDriverNoopContainerReader
   327  	decDriverNoopNumberHelper
   328  	h *CborHandle
   329  	bdAndBdread
   330  	st bool // skip tags
   331  	_  bool // found nil
   332  	noBuiltInTypes
   333  	d Decoder
   334  }
   335  
   336  func (d *cborDecDriver) decoder() *Decoder {
   337  	return &d.d
   338  }
   339  
   340  func (d *cborDecDriver) descBd() string {
   341  	return sprintf("%v (%s)", d.bd, cbordesc(d.bd))
   342  }
   343  
   344  func (d *cborDecDriver) readNextBd() {
   345  	d.bd = d.d.decRd.readn1()
   346  	d.bdRead = true
   347  }
   348  
   349  func (d *cborDecDriver) advanceNil() (null bool) {
   350  	if !d.bdRead {
   351  		d.readNextBd()
   352  	}
   353  	if d.bd == cborBdNil || d.bd == cborBdUndefined {
   354  		d.bdRead = false
   355  		return true // null = true
   356  	}
   357  	return
   358  }
   359  
   360  func (d *cborDecDriver) TryNil() bool {
   361  	return d.advanceNil()
   362  }
   363  
   364  // skipTags is called to skip any tags in the stream.
   365  //
   366  // Since any value can be tagged, then we should call skipTags
   367  // before any value is decoded.
   368  //
   369  // By definition, skipTags should not be called before
   370  // checking for break, or nil or undefined.
   371  func (d *cborDecDriver) skipTags() {
   372  	for d.bd>>5 == cborMajorTag {
   373  		d.decUint()
   374  		d.bd = d.d.decRd.readn1()
   375  	}
   376  }
   377  
   378  func (d *cborDecDriver) ContainerType() (vt valueType) {
   379  	if !d.bdRead {
   380  		d.readNextBd()
   381  	}
   382  	if d.st {
   383  		d.skipTags()
   384  	}
   385  	if d.bd == cborBdNil {
   386  		d.bdRead = false // always consume nil after seeing it in container type
   387  		return valueTypeNil
   388  	}
   389  	major := d.bd >> 5
   390  	if major == cborMajorBytes {
   391  		return valueTypeBytes
   392  	} else if major == cborMajorString {
   393  		return valueTypeString
   394  	} else if major == cborMajorArray {
   395  		return valueTypeArray
   396  	} else if major == cborMajorMap {
   397  		return valueTypeMap
   398  	}
   399  	return valueTypeUnset
   400  }
   401  
   402  func (d *cborDecDriver) CheckBreak() (v bool) {
   403  	if !d.bdRead {
   404  		d.readNextBd()
   405  	}
   406  	if d.bd == cborBdBreak {
   407  		d.bdRead = false
   408  		v = true
   409  	}
   410  	return
   411  }
   412  
   413  func (d *cborDecDriver) decUint() (ui uint64) {
   414  	v := d.bd & 0x1f
   415  	if v <= 0x17 {
   416  		ui = uint64(v)
   417  	} else if v == 0x18 {
   418  		ui = uint64(d.d.decRd.readn1())
   419  	} else if v == 0x19 {
   420  		ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
   421  	} else if v == 0x1a {
   422  		ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
   423  	} else if v == 0x1b {
   424  		ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
   425  	} else {
   426  		d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
   427  	}
   428  	return
   429  }
   430  
   431  func (d *cborDecDriver) decLen() int {
   432  	return int(d.decUint())
   433  }
   434  
   435  func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte, major byte) []byte {
   436  	d.bdRead = false
   437  	for !d.CheckBreak() {
   438  		chunkMajor := d.bd >> 5
   439  		if chunkMajor != major {
   440  			d.d.errorf("malformed indefinite string/bytes %x (%s); contains chunk with major type %v, expected %v",
   441  				d.bd, cbordesc(d.bd), chunkMajor, major)
   442  		}
   443  		n := uint(d.decLen())
   444  		oldLen := uint(len(bs))
   445  		newLen := oldLen + n
   446  		if newLen > uint(cap(bs)) {
   447  			bs2 := make([]byte, newLen, 2*uint(cap(bs))+n)
   448  			copy(bs2, bs)
   449  			bs = bs2
   450  		} else {
   451  			bs = bs[:newLen]
   452  		}
   453  		d.d.decRd.readb(bs[oldLen:newLen])
   454  		if d.h.ValidateUnicode && major == cborMajorString && !utf8.Valid(bs[oldLen:newLen]) {
   455  			d.d.errorf("indefinite-length text string contains chunk that is not a valid utf-8 sequence: 0x%x", bs[oldLen:newLen])
   456  		}
   457  		d.bdRead = false
   458  	}
   459  	d.bdRead = false
   460  	return bs
   461  }
   462  
   463  func (d *cborDecDriver) decFloat() (f float64, ok bool) {
   464  	ok = true
   465  	switch d.bd {
   466  	case cborBdFloat16:
   467  		f = float64(math.Float32frombits(halfFloatToFloatBits(bigen.Uint16(d.d.decRd.readn2()))))
   468  	case cborBdFloat32:
   469  		f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
   470  	case cborBdFloat64:
   471  		f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
   472  	default:
   473  		ok = false
   474  	}
   475  	return
   476  }
   477  
   478  func (d *cborDecDriver) decInteger() (ui uint64, neg, ok bool) {
   479  	ok = true
   480  	switch d.bd >> 5 {
   481  	case cborMajorUint:
   482  		ui = d.decUint()
   483  	case cborMajorNegInt:
   484  		ui = d.decUint()
   485  		neg = true
   486  	default:
   487  		ok = false
   488  	}
   489  	return
   490  }
   491  
   492  func (d *cborDecDriver) DecodeInt64() (i int64) {
   493  	if d.advanceNil() {
   494  		return
   495  	}
   496  	if d.st {
   497  		d.skipTags()
   498  	}
   499  	i = decNegintPosintFloatNumberHelper{&d.d}.int64(d.decInteger())
   500  	d.bdRead = false
   501  	return
   502  }
   503  
   504  func (d *cborDecDriver) DecodeUint64() (ui uint64) {
   505  	if d.advanceNil() {
   506  		return
   507  	}
   508  	if d.st {
   509  		d.skipTags()
   510  	}
   511  	ui = decNegintPosintFloatNumberHelper{&d.d}.uint64(d.decInteger())
   512  	d.bdRead = false
   513  	return
   514  }
   515  
   516  func (d *cborDecDriver) DecodeFloat64() (f float64) {
   517  	if d.advanceNil() {
   518  		return
   519  	}
   520  	if d.st {
   521  		d.skipTags()
   522  	}
   523  	f = decNegintPosintFloatNumberHelper{&d.d}.float64(d.decFloat())
   524  	d.bdRead = false
   525  	return
   526  }
   527  
   528  // bool can be decoded from bool only (single byte).
   529  func (d *cborDecDriver) DecodeBool() (b bool) {
   530  	if d.advanceNil() {
   531  		return
   532  	}
   533  	if d.st {
   534  		d.skipTags()
   535  	}
   536  	if d.bd == cborBdTrue {
   537  		b = true
   538  	} else if d.bd == cborBdFalse {
   539  	} else {
   540  		d.d.errorf("not bool - %s %x/%s", msgBadDesc, d.bd, cbordesc(d.bd))
   541  	}
   542  	d.bdRead = false
   543  	return
   544  }
   545  
   546  func (d *cborDecDriver) ReadMapStart() (length int) {
   547  	if d.advanceNil() {
   548  		return containerLenNil
   549  	}
   550  	if d.st {
   551  		d.skipTags()
   552  	}
   553  	d.bdRead = false
   554  	if d.bd == cborBdIndefiniteMap {
   555  		return containerLenUnknown
   556  	}
   557  	if d.bd>>5 != cborMajorMap {
   558  		d.d.errorf("error reading map; got major type: %x, expected %x/%s", d.bd>>5, cborMajorMap, cbordesc(d.bd))
   559  	}
   560  	return d.decLen()
   561  }
   562  
   563  func (d *cborDecDriver) ReadArrayStart() (length int) {
   564  	if d.advanceNil() {
   565  		return containerLenNil
   566  	}
   567  	if d.st {
   568  		d.skipTags()
   569  	}
   570  	d.bdRead = false
   571  	if d.bd == cborBdIndefiniteArray {
   572  		return containerLenUnknown
   573  	}
   574  	if d.bd>>5 != cborMajorArray {
   575  		d.d.errorf("invalid array; got major type: %x, expect: %x/%s", d.bd>>5, cborMajorArray, cbordesc(d.bd))
   576  	}
   577  	return d.decLen()
   578  }
   579  
   580  func (d *cborDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
   581  	d.d.decByteState = decByteStateNone
   582  	if d.advanceNil() {
   583  		return
   584  	}
   585  	if d.st {
   586  		d.skipTags()
   587  	}
   588  	if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
   589  		d.bdRead = false
   590  		if bs == nil {
   591  			d.d.decByteState = decByteStateReuseBuf
   592  			return d.decAppendIndefiniteBytes(d.d.b[:0], d.bd>>5)
   593  		}
   594  		return d.decAppendIndefiniteBytes(bs[:0], d.bd>>5)
   595  	}
   596  	if d.bd == cborBdIndefiniteArray {
   597  		d.bdRead = false
   598  		if bs == nil {
   599  			d.d.decByteState = decByteStateReuseBuf
   600  			bs = d.d.b[:0]
   601  		} else {
   602  			bs = bs[:0]
   603  		}
   604  		for !d.CheckBreak() {
   605  			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
   606  		}
   607  		return bs
   608  	}
   609  	if d.bd>>5 == cborMajorArray {
   610  		d.bdRead = false
   611  		if bs == nil {
   612  			d.d.decByteState = decByteStateReuseBuf
   613  			bs = d.d.b[:]
   614  		}
   615  		slen := d.decLen()
   616  		var changed bool
   617  		if bs, changed = usableByteSlice(bs, slen); changed {
   618  			d.d.decByteState = decByteStateNone
   619  		}
   620  		for i := 0; i < len(bs); i++ {
   621  			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
   622  		}
   623  		for i := len(bs); i < slen; i++ {
   624  			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
   625  		}
   626  		return bs
   627  	}
   628  	clen := d.decLen()
   629  	d.bdRead = false
   630  	if d.d.zerocopy() {
   631  		d.d.decByteState = decByteStateZerocopy
   632  		return d.d.decRd.rb.readx(uint(clen))
   633  	}
   634  	if bs == nil {
   635  		d.d.decByteState = decByteStateReuseBuf
   636  		bs = d.d.b[:]
   637  	}
   638  	return decByteSlice(d.d.r(), clen, d.h.MaxInitLen, bs)
   639  }
   640  
   641  func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
   642  	s = d.DecodeBytes(nil)
   643  	if d.h.ValidateUnicode && !utf8.Valid(s) {
   644  		d.d.errorf("DecodeStringAsBytes: invalid UTF-8: %s", s)
   645  	}
   646  	return
   647  }
   648  
   649  func (d *cborDecDriver) DecodeTime() (t time.Time) {
   650  	if d.advanceNil() {
   651  		return
   652  	}
   653  	if d.bd>>5 != cborMajorTag {
   654  		d.d.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
   655  	}
   656  	xtag := d.decUint()
   657  	d.bdRead = false
   658  	return d.decodeTime(xtag)
   659  }
   660  
   661  func (d *cborDecDriver) decodeTime(xtag uint64) (t time.Time) {
   662  	switch xtag {
   663  	case 0:
   664  		var err error
   665  		t, err = time.Parse(time.RFC3339, stringView(d.DecodeStringAsBytes()))
   666  		d.d.onerror(err)
   667  	case 1:
   668  		f1, f2 := math.Modf(d.DecodeFloat64())
   669  		t = time.Unix(int64(f1), int64(f2*1e9))
   670  	default:
   671  		d.d.errorf("invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
   672  	}
   673  	t = t.UTC().Round(time.Microsecond)
   674  	return
   675  }
   676  
   677  func (d *cborDecDriver) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
   678  	if d.advanceNil() {
   679  		return
   680  	}
   681  	if d.bd>>5 != cborMajorTag {
   682  		d.d.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
   683  	}
   684  	realxtag := d.decUint()
   685  	d.bdRead = false
   686  	if ext == nil {
   687  		re := rv.(*RawExt)
   688  		re.Tag = realxtag
   689  		d.d.decode(&re.Value)
   690  	} else if xtag != realxtag {
   691  		d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", realxtag, xtag)
   692  	} else if ext == SelfExt {
   693  		d.d.decodeValue(baseRV(rv), d.h.fnNoExt(basetype))
   694  	} else {
   695  		d.d.interfaceExtConvertAndDecode(rv, ext)
   696  	}
   697  	d.bdRead = false
   698  }
   699  
   700  func (d *cborDecDriver) DecodeNaked() {
   701  	if !d.bdRead {
   702  		d.readNextBd()
   703  	}
   704  
   705  	n := d.d.naked()
   706  	var decodeFurther bool
   707  
   708  	switch d.bd >> 5 {
   709  	case cborMajorUint:
   710  		if d.h.SignedInteger {
   711  			n.v = valueTypeInt
   712  			n.i = d.DecodeInt64()
   713  		} else {
   714  			n.v = valueTypeUint
   715  			n.u = d.DecodeUint64()
   716  		}
   717  	case cborMajorNegInt:
   718  		n.v = valueTypeInt
   719  		n.i = d.DecodeInt64()
   720  	case cborMajorBytes:
   721  		d.d.fauxUnionReadRawBytes(false)
   722  	case cborMajorString:
   723  		n.v = valueTypeString
   724  		n.s = d.d.stringZC(d.DecodeStringAsBytes())
   725  	case cborMajorArray:
   726  		n.v = valueTypeArray
   727  		decodeFurther = true
   728  	case cborMajorMap:
   729  		n.v = valueTypeMap
   730  		decodeFurther = true
   731  	case cborMajorTag:
   732  		n.v = valueTypeExt
   733  		n.u = d.decUint()
   734  		n.l = nil
   735  		if n.u == 0 || n.u == 1 {
   736  			d.bdRead = false
   737  			n.v = valueTypeTime
   738  			n.t = d.decodeTime(n.u)
   739  		} else if d.st && d.h.getExtForTag(n.u) == nil {
   740  			// d.skipTags() // no need to call this - tags already skipped
   741  			d.bdRead = false
   742  			d.DecodeNaked()
   743  			return // return when done (as true recursive function)
   744  		}
   745  	case cborMajorSimpleOrFloat:
   746  		switch d.bd {
   747  		case cborBdNil, cborBdUndefined:
   748  			n.v = valueTypeNil
   749  		case cborBdFalse:
   750  			n.v = valueTypeBool
   751  			n.b = false
   752  		case cborBdTrue:
   753  			n.v = valueTypeBool
   754  			n.b = true
   755  		case cborBdFloat16, cborBdFloat32, cborBdFloat64:
   756  			n.v = valueTypeFloat
   757  			n.f = d.DecodeFloat64()
   758  		default:
   759  			d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
   760  		}
   761  	default: // should never happen
   762  		d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
   763  	}
   764  	if !decodeFurther {
   765  		d.bdRead = false
   766  	}
   767  }
   768  
   769  func (d *cborDecDriver) uintBytes() (v []byte, ui uint64) {
   770  	// this is only used by nextValueBytes, so it's ok to
   771  	// use readx and bigenstd here.
   772  	switch vv := d.bd & 0x1f; vv {
   773  	case 0x18:
   774  		v = d.d.decRd.readx(1)
   775  		ui = uint64(v[0])
   776  	case 0x19:
   777  		v = d.d.decRd.readx(2)
   778  		ui = uint64(bigenstd.Uint16(v))
   779  	case 0x1a:
   780  		v = d.d.decRd.readx(4)
   781  		ui = uint64(bigenstd.Uint32(v))
   782  	case 0x1b:
   783  		v = d.d.decRd.readx(8)
   784  		ui = uint64(bigenstd.Uint64(v))
   785  	default:
   786  		if vv > 0x1b {
   787  			d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
   788  		}
   789  		ui = uint64(vv)
   790  	}
   791  	return
   792  }
   793  
   794  func (d *cborDecDriver) nextValueBytes(v0 []byte) (v []byte) {
   795  	if !d.bdRead {
   796  		d.readNextBd()
   797  	}
   798  	v = v0
   799  	var h = decNextValueBytesHelper{d: &d.d}
   800  	var cursor = d.d.rb.c - 1
   801  	h.append1(&v, d.bd)
   802  	v = d.nextValueBytesBdReadR(v)
   803  	d.bdRead = false
   804  	h.bytesRdV(&v, cursor)
   805  	return
   806  }
   807  
   808  func (d *cborDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
   809  	d.readNextBd()
   810  	v = v0
   811  	var h = decNextValueBytesHelper{d: &d.d}
   812  	h.append1(&v, d.bd)
   813  	return d.nextValueBytesBdReadR(v)
   814  }
   815  
   816  func (d *cborDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
   817  	v = v0
   818  	var h = decNextValueBytesHelper{d: &d.d}
   819  
   820  	var bs []byte
   821  	var ui uint64
   822  
   823  	switch d.bd >> 5 {
   824  	case cborMajorUint, cborMajorNegInt:
   825  		bs, _ = d.uintBytes()
   826  		h.appendN(&v, bs...)
   827  	case cborMajorString, cborMajorBytes:
   828  		if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
   829  			for {
   830  				d.readNextBd()
   831  				h.append1(&v, d.bd)
   832  				if d.bd == cborBdBreak {
   833  					break
   834  				}
   835  				bs, ui = d.uintBytes()
   836  				h.appendN(&v, bs...)
   837  				h.appendN(&v, d.d.decRd.readx(uint(ui))...)
   838  			}
   839  		} else {
   840  			bs, ui = d.uintBytes()
   841  			h.appendN(&v, bs...)
   842  			h.appendN(&v, d.d.decRd.readx(uint(ui))...)
   843  		}
   844  	case cborMajorArray:
   845  		if d.bd == cborBdIndefiniteArray {
   846  			for {
   847  				d.readNextBd()
   848  				h.append1(&v, d.bd)
   849  				if d.bd == cborBdBreak {
   850  					break
   851  				}
   852  				v = d.nextValueBytesBdReadR(v)
   853  			}
   854  		} else {
   855  			bs, ui = d.uintBytes()
   856  			h.appendN(&v, bs...)
   857  			for i := uint64(0); i < ui; i++ {
   858  				v = d.nextValueBytesR(v)
   859  			}
   860  		}
   861  	case cborMajorMap:
   862  		if d.bd == cborBdIndefiniteMap {
   863  			for {
   864  				d.readNextBd()
   865  				h.append1(&v, d.bd)
   866  				if d.bd == cborBdBreak {
   867  					break
   868  				}
   869  				v = d.nextValueBytesBdReadR(v)
   870  				v = d.nextValueBytesR(v)
   871  			}
   872  		} else {
   873  			bs, ui = d.uintBytes()
   874  			h.appendN(&v, bs...)
   875  			for i := uint64(0); i < ui; i++ {
   876  				v = d.nextValueBytesR(v)
   877  				v = d.nextValueBytesR(v)
   878  			}
   879  		}
   880  	case cborMajorTag:
   881  		bs, _ = d.uintBytes()
   882  		h.appendN(&v, bs...)
   883  		v = d.nextValueBytesR(v)
   884  	case cborMajorSimpleOrFloat:
   885  		switch d.bd {
   886  		case cborBdNil, cborBdUndefined, cborBdFalse, cborBdTrue: // pass
   887  		case cborBdFloat16:
   888  			h.appendN(&v, d.d.decRd.readx(2)...)
   889  		case cborBdFloat32:
   890  			h.appendN(&v, d.d.decRd.readx(4)...)
   891  		case cborBdFloat64:
   892  			h.appendN(&v, d.d.decRd.readx(8)...)
   893  		default:
   894  			d.d.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
   895  		}
   896  	default: // should never happen
   897  		d.d.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
   898  	}
   899  	return
   900  }
   901  
   902  // -------------------------
   903  
   904  // CborHandle is a Handle for the CBOR encoding format,
   905  // defined at http://tools.ietf.org/html/rfc7049 and documented further at http://cbor.io .
   906  //
   907  // CBOR is comprehensively supported, including support for:
   908  //   - indefinite-length arrays/maps/bytes/strings
   909  //   - (extension) tags in range 0..0xffff (0 .. 65535)
   910  //   - half, single and double-precision floats
   911  //   - all numbers (1, 2, 4 and 8-byte signed and unsigned integers)
   912  //   - nil, true, false, ...
   913  //   - arrays and maps, bytes and text strings
   914  //
   915  // None of the optional extensions (with tags) defined in the spec are supported out-of-the-box.
   916  // Users can implement them as needed (using SetExt), including spec-documented ones:
   917  //   - timestamp, BigNum, BigFloat, Decimals,
   918  //   - Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
   919  type CborHandle struct {
   920  	binaryEncodingType
   921  	// noElemSeparators
   922  	BasicHandle
   923  
   924  	// IndefiniteLength=true, means that we encode using indefinitelength
   925  	IndefiniteLength bool
   926  
   927  	// TimeRFC3339 says to encode time.Time using RFC3339 format.
   928  	// If unset, we encode time.Time using seconds past epoch.
   929  	TimeRFC3339 bool
   930  
   931  	// SkipUnexpectedTags says to skip over any tags for which extensions are
   932  	// not defined. This is in keeping with the cbor spec on "Optional Tagging of Items".
   933  	//
   934  	// Furthermore, this allows the skipping over of the Self Describing Tag 0xd9d9f7.
   935  	SkipUnexpectedTags bool
   936  }
   937  
   938  // Name returns the name of the handle: cbor
   939  func (h *CborHandle) Name() string { return "cbor" }
   940  
   941  func (h *CborHandle) desc(bd byte) string { return cbordesc(bd) }
   942  
   943  func (h *CborHandle) newEncDriver() encDriver {
   944  	var e = &cborEncDriver{h: h}
   945  	e.e.e = e
   946  	e.e.init(h)
   947  	e.reset()
   948  	return e
   949  }
   950  
   951  func (h *CborHandle) newDecDriver() decDriver {
   952  	d := &cborDecDriver{h: h, st: h.SkipUnexpectedTags}
   953  	d.d.d = d
   954  	d.d.cbor = true
   955  	d.d.init(h)
   956  	d.reset()
   957  	return d
   958  }
   959  
   960  func (d *cborDecDriver) reset() {
   961  	d.bdAndBdread.reset()
   962  	d.st = d.h.SkipUnexpectedTags
   963  }
   964  
   965  var _ decDriver = (*cborDecDriver)(nil)
   966  var _ encDriver = (*cborEncDriver)(nil)
   967  

View as plain text