http urls monitor.

cbor.go 17KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757
  1. // Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
  2. // Use of this source code is governed by a MIT license found in the LICENSE file.
  3. package codec
  4. import (
  5. "math"
  6. "reflect"
  7. "time"
  8. )
  9. const (
  10. cborMajorUint byte = iota
  11. cborMajorNegInt
  12. cborMajorBytes
  13. cborMajorText
  14. cborMajorArray
  15. cborMajorMap
  16. cborMajorTag
  17. cborMajorOther
  18. )
  19. const (
  20. cborBdFalse byte = 0xf4 + iota
  21. cborBdTrue
  22. cborBdNil
  23. cborBdUndefined
  24. cborBdExt
  25. cborBdFloat16
  26. cborBdFloat32
  27. cborBdFloat64
  28. )
  29. const (
  30. cborBdIndefiniteBytes byte = 0x5f
  31. cborBdIndefiniteString = 0x7f
  32. cborBdIndefiniteArray = 0x9f
  33. cborBdIndefiniteMap = 0xbf
  34. cborBdBreak = 0xff
  35. )
  36. // These define some in-stream descriptors for
  37. // manual encoding e.g. when doing explicit indefinite-length
  38. const (
  39. CborStreamBytes byte = 0x5f
  40. CborStreamString = 0x7f
  41. CborStreamArray = 0x9f
  42. CborStreamMap = 0xbf
  43. CborStreamBreak = 0xff
  44. )
  45. const (
  46. cborBaseUint byte = 0x00
  47. cborBaseNegInt = 0x20
  48. cborBaseBytes = 0x40
  49. cborBaseString = 0x60
  50. cborBaseArray = 0x80
  51. cborBaseMap = 0xa0
  52. cborBaseTag = 0xc0
  53. cborBaseSimple = 0xe0
  54. )
  55. func cbordesc(bd byte) string {
  56. switch bd {
  57. case cborBdNil:
  58. return "nil"
  59. case cborBdFalse:
  60. return "false"
  61. case cborBdTrue:
  62. return "true"
  63. case cborBdFloat16, cborBdFloat32, cborBdFloat64:
  64. return "float"
  65. case cborBdIndefiniteBytes:
  66. return "bytes*"
  67. case cborBdIndefiniteString:
  68. return "string*"
  69. case cborBdIndefiniteArray:
  70. return "array*"
  71. case cborBdIndefiniteMap:
  72. return "map*"
  73. default:
  74. switch {
  75. case bd >= cborBaseUint && bd < cborBaseNegInt:
  76. return "(u)int"
  77. case bd >= cborBaseNegInt && bd < cborBaseBytes:
  78. return "int"
  79. case bd >= cborBaseBytes && bd < cborBaseString:
  80. return "bytes"
  81. case bd >= cborBaseString && bd < cborBaseArray:
  82. return "string"
  83. case bd >= cborBaseArray && bd < cborBaseMap:
  84. return "array"
  85. case bd >= cborBaseMap && bd < cborBaseTag:
  86. return "map"
  87. case bd >= cborBaseTag && bd < cborBaseSimple:
  88. return "ext"
  89. default:
  90. return "unknown"
  91. }
  92. }
  93. }
  94. // -------------------
  95. type cborEncDriver struct {
  96. noBuiltInTypes
  97. encDriverNoopContainerWriter
  98. e *Encoder
  99. w encWriter
  100. h *CborHandle
  101. x [8]byte
  102. // _ [3]uint64 // padding
  103. }
  104. func (e *cborEncDriver) EncodeNil() {
  105. e.w.writen1(cborBdNil)
  106. }
  107. func (e *cborEncDriver) EncodeBool(b bool) {
  108. if b {
  109. e.w.writen1(cborBdTrue)
  110. } else {
  111. e.w.writen1(cborBdFalse)
  112. }
  113. }
  114. func (e *cborEncDriver) EncodeFloat32(f float32) {
  115. e.w.writen1(cborBdFloat32)
  116. bigenHelper{e.x[:4], e.w}.writeUint32(math.Float32bits(f))
  117. }
  118. func (e *cborEncDriver) EncodeFloat64(f float64) {
  119. e.w.writen1(cborBdFloat64)
  120. bigenHelper{e.x[:8], e.w}.writeUint64(math.Float64bits(f))
  121. }
  122. func (e *cborEncDriver) encUint(v uint64, bd byte) {
  123. if v <= 0x17 {
  124. e.w.writen1(byte(v) + bd)
  125. } else if v <= math.MaxUint8 {
  126. e.w.writen2(bd+0x18, uint8(v))
  127. } else if v <= math.MaxUint16 {
  128. e.w.writen1(bd + 0x19)
  129. bigenHelper{e.x[:2], e.w}.writeUint16(uint16(v))
  130. } else if v <= math.MaxUint32 {
  131. e.w.writen1(bd + 0x1a)
  132. bigenHelper{e.x[:4], e.w}.writeUint32(uint32(v))
  133. } else { // if v <= math.MaxUint64 {
  134. e.w.writen1(bd + 0x1b)
  135. bigenHelper{e.x[:8], e.w}.writeUint64(v)
  136. }
  137. }
  138. func (e *cborEncDriver) EncodeInt(v int64) {
  139. if v < 0 {
  140. e.encUint(uint64(-1-v), cborBaseNegInt)
  141. } else {
  142. e.encUint(uint64(v), cborBaseUint)
  143. }
  144. }
  145. func (e *cborEncDriver) EncodeUint(v uint64) {
  146. e.encUint(v, cborBaseUint)
  147. }
  148. func (e *cborEncDriver) encLen(bd byte, length int) {
  149. e.encUint(uint64(length), bd)
  150. }
  151. func (e *cborEncDriver) EncodeTime(t time.Time) {
  152. if t.IsZero() {
  153. e.EncodeNil()
  154. } else if e.h.TimeRFC3339 {
  155. e.encUint(0, cborBaseTag)
  156. e.EncodeString(cUTF8, t.Format(time.RFC3339Nano))
  157. } else {
  158. e.encUint(1, cborBaseTag)
  159. t = t.UTC().Round(time.Microsecond)
  160. sec, nsec := t.Unix(), uint64(t.Nanosecond())
  161. if nsec == 0 {
  162. e.EncodeInt(sec)
  163. } else {
  164. e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
  165. }
  166. }
  167. }
  168. func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext, en *Encoder) {
  169. e.encUint(uint64(xtag), cborBaseTag)
  170. if v := ext.ConvertExt(rv); v == nil {
  171. e.EncodeNil()
  172. } else {
  173. en.encode(v)
  174. }
  175. }
  176. func (e *cborEncDriver) EncodeRawExt(re *RawExt, en *Encoder) {
  177. e.encUint(uint64(re.Tag), cborBaseTag)
  178. // only encodes re.Value (never re.Data)
  179. // if false && re.Data != nil {
  180. // en.encode(re.Data)
  181. // } else if re.Value != nil {
  182. if re.Value != nil {
  183. en.encode(re.Value)
  184. } else {
  185. e.EncodeNil()
  186. }
  187. }
  188. func (e *cborEncDriver) WriteArrayStart(length int) {
  189. if e.h.IndefiniteLength {
  190. e.w.writen1(cborBdIndefiniteArray)
  191. } else {
  192. e.encLen(cborBaseArray, length)
  193. }
  194. }
  195. func (e *cborEncDriver) WriteMapStart(length int) {
  196. if e.h.IndefiniteLength {
  197. e.w.writen1(cborBdIndefiniteMap)
  198. } else {
  199. e.encLen(cborBaseMap, length)
  200. }
  201. }
  202. func (e *cborEncDriver) WriteMapEnd() {
  203. if e.h.IndefiniteLength {
  204. e.w.writen1(cborBdBreak)
  205. }
  206. }
  207. func (e *cborEncDriver) WriteArrayEnd() {
  208. if e.h.IndefiniteLength {
  209. e.w.writen1(cborBdBreak)
  210. }
  211. }
  212. func (e *cborEncDriver) EncodeString(c charEncoding, v string) {
  213. e.encStringBytesS(cborBaseString, v)
  214. }
  215. func (e *cborEncDriver) EncodeStringBytes(c charEncoding, v []byte) {
  216. if v == nil {
  217. e.EncodeNil()
  218. } else if c == cRAW {
  219. e.encStringBytesS(cborBaseBytes, stringView(v))
  220. } else {
  221. e.encStringBytesS(cborBaseString, stringView(v))
  222. }
  223. }
  224. func (e *cborEncDriver) encStringBytesS(bb byte, v string) {
  225. if e.h.IndefiniteLength {
  226. if bb == cborBaseBytes {
  227. e.w.writen1(cborBdIndefiniteBytes)
  228. } else {
  229. e.w.writen1(cborBdIndefiniteString)
  230. }
  231. blen := len(v) / 4
  232. if blen == 0 {
  233. blen = 64
  234. } else if blen > 1024 {
  235. blen = 1024
  236. }
  237. for i := 0; i < len(v); {
  238. var v2 string
  239. i2 := i + blen
  240. if i2 < len(v) {
  241. v2 = v[i:i2]
  242. } else {
  243. v2 = v[i:]
  244. }
  245. e.encLen(bb, len(v2))
  246. e.w.writestr(v2)
  247. i = i2
  248. }
  249. e.w.writen1(cborBdBreak)
  250. } else {
  251. e.encLen(bb, len(v))
  252. e.w.writestr(v)
  253. }
  254. }
  255. // ----------------------
  256. type cborDecDriver struct {
  257. d *Decoder
  258. h *CborHandle
  259. r decReader
  260. br bool // bytes reader
  261. bdRead bool
  262. bd byte
  263. noBuiltInTypes
  264. // decNoSeparator
  265. decDriverNoopContainerReader
  266. // _ [3]uint64 // padding
  267. }
  268. func (d *cborDecDriver) readNextBd() {
  269. d.bd = d.r.readn1()
  270. d.bdRead = true
  271. }
  272. func (d *cborDecDriver) uncacheRead() {
  273. if d.bdRead {
  274. d.r.unreadn1()
  275. d.bdRead = false
  276. }
  277. }
  278. func (d *cborDecDriver) ContainerType() (vt valueType) {
  279. if !d.bdRead {
  280. d.readNextBd()
  281. }
  282. if d.bd == cborBdNil {
  283. return valueTypeNil
  284. } else if d.bd == cborBdIndefiniteBytes || (d.bd >= cborBaseBytes && d.bd < cborBaseString) {
  285. return valueTypeBytes
  286. } else if d.bd == cborBdIndefiniteString || (d.bd >= cborBaseString && d.bd < cborBaseArray) {
  287. return valueTypeString
  288. } else if d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) {
  289. return valueTypeArray
  290. } else if d.bd == cborBdIndefiniteMap || (d.bd >= cborBaseMap && d.bd < cborBaseTag) {
  291. return valueTypeMap
  292. }
  293. // else {
  294. // d.d.errorf("isContainerType: unsupported parameter: %v", vt)
  295. // }
  296. return valueTypeUnset
  297. }
  298. func (d *cborDecDriver) TryDecodeAsNil() bool {
  299. if !d.bdRead {
  300. d.readNextBd()
  301. }
  302. // treat Nil and Undefined as nil values
  303. if d.bd == cborBdNil || d.bd == cborBdUndefined {
  304. d.bdRead = false
  305. return true
  306. }
  307. return false
  308. }
  309. func (d *cborDecDriver) CheckBreak() bool {
  310. if !d.bdRead {
  311. d.readNextBd()
  312. }
  313. if d.bd == cborBdBreak {
  314. d.bdRead = false
  315. return true
  316. }
  317. return false
  318. }
  319. func (d *cborDecDriver) decUint() (ui uint64) {
  320. v := d.bd & 0x1f
  321. if v <= 0x17 {
  322. ui = uint64(v)
  323. } else {
  324. if v == 0x18 {
  325. ui = uint64(d.r.readn1())
  326. } else if v == 0x19 {
  327. ui = uint64(bigen.Uint16(d.r.readx(2)))
  328. } else if v == 0x1a {
  329. ui = uint64(bigen.Uint32(d.r.readx(4)))
  330. } else if v == 0x1b {
  331. ui = uint64(bigen.Uint64(d.r.readx(8)))
  332. } else {
  333. d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
  334. return
  335. }
  336. }
  337. return
  338. }
  339. func (d *cborDecDriver) decCheckInteger() (neg bool) {
  340. if !d.bdRead {
  341. d.readNextBd()
  342. }
  343. major := d.bd >> 5
  344. if major == cborMajorUint {
  345. } else if major == cborMajorNegInt {
  346. neg = true
  347. } else {
  348. d.d.errorf("not an integer - invalid major %v from descriptor %x/%s", major, d.bd, cbordesc(d.bd))
  349. return
  350. }
  351. return
  352. }
  353. func (d *cborDecDriver) DecodeInt64() (i int64) {
  354. neg := d.decCheckInteger()
  355. ui := d.decUint()
  356. // check if this number can be converted to an int without overflow
  357. if neg {
  358. i = -(chkOvf.SignedIntV(ui + 1))
  359. } else {
  360. i = chkOvf.SignedIntV(ui)
  361. }
  362. d.bdRead = false
  363. return
  364. }
  365. func (d *cborDecDriver) DecodeUint64() (ui uint64) {
  366. if d.decCheckInteger() {
  367. d.d.errorf("assigning negative signed value to unsigned type")
  368. return
  369. }
  370. ui = d.decUint()
  371. d.bdRead = false
  372. return
  373. }
  374. func (d *cborDecDriver) DecodeFloat64() (f float64) {
  375. if !d.bdRead {
  376. d.readNextBd()
  377. }
  378. if bd := d.bd; bd == cborBdFloat16 {
  379. f = float64(math.Float32frombits(halfFloatToFloatBits(bigen.Uint16(d.r.readx(2)))))
  380. } else if bd == cborBdFloat32 {
  381. f = float64(math.Float32frombits(bigen.Uint32(d.r.readx(4))))
  382. } else if bd == cborBdFloat64 {
  383. f = math.Float64frombits(bigen.Uint64(d.r.readx(8)))
  384. } else if bd >= cborBaseUint && bd < cborBaseBytes {
  385. f = float64(d.DecodeInt64())
  386. } else {
  387. d.d.errorf("float only valid from float16/32/64 - invalid descriptor %x/%s", bd, cbordesc(bd))
  388. return
  389. }
  390. d.bdRead = false
  391. return
  392. }
  393. // bool can be decoded from bool only (single byte).
  394. func (d *cborDecDriver) DecodeBool() (b bool) {
  395. if !d.bdRead {
  396. d.readNextBd()
  397. }
  398. if bd := d.bd; bd == cborBdTrue {
  399. b = true
  400. } else if bd == cborBdFalse {
  401. } else {
  402. d.d.errorf("not bool - %s %x/%s", msgBadDesc, d.bd, cbordesc(d.bd))
  403. return
  404. }
  405. d.bdRead = false
  406. return
  407. }
  408. func (d *cborDecDriver) ReadMapStart() (length int) {
  409. if !d.bdRead {
  410. d.readNextBd()
  411. }
  412. d.bdRead = false
  413. if d.bd == cborBdIndefiniteMap {
  414. return -1
  415. }
  416. return d.decLen()
  417. }
  418. func (d *cborDecDriver) ReadArrayStart() (length int) {
  419. if !d.bdRead {
  420. d.readNextBd()
  421. }
  422. d.bdRead = false
  423. if d.bd == cborBdIndefiniteArray {
  424. return -1
  425. }
  426. return d.decLen()
  427. }
  428. func (d *cborDecDriver) decLen() int {
  429. return int(d.decUint())
  430. }
  431. func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte) []byte {
  432. d.bdRead = false
  433. for {
  434. if d.CheckBreak() {
  435. break
  436. }
  437. if major := d.bd >> 5; major != cborMajorBytes && major != cborMajorText {
  438. d.d.errorf("expect bytes/string major type in indefinite string/bytes;"+
  439. " got major %v from descriptor %x/%x", major, d.bd, cbordesc(d.bd))
  440. return nil
  441. }
  442. n := d.decLen()
  443. oldLen := len(bs)
  444. newLen := oldLen + n
  445. if newLen > cap(bs) {
  446. bs2 := make([]byte, newLen, 2*cap(bs)+n)
  447. copy(bs2, bs)
  448. bs = bs2
  449. } else {
  450. bs = bs[:newLen]
  451. }
  452. d.r.readb(bs[oldLen:newLen])
  453. // bs = append(bs, d.r.readn()...)
  454. d.bdRead = false
  455. }
  456. d.bdRead = false
  457. return bs
  458. }
  459. func (d *cborDecDriver) DecodeBytes(bs []byte, zerocopy bool) (bsOut []byte) {
  460. if !d.bdRead {
  461. d.readNextBd()
  462. }
  463. if d.bd == cborBdNil || d.bd == cborBdUndefined {
  464. d.bdRead = false
  465. return nil
  466. }
  467. if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
  468. d.bdRead = false
  469. if bs == nil {
  470. if zerocopy {
  471. return d.decAppendIndefiniteBytes(d.d.b[:0])
  472. }
  473. return d.decAppendIndefiniteBytes(zeroByteSlice)
  474. }
  475. return d.decAppendIndefiniteBytes(bs[:0])
  476. }
  477. // check if an "array" of uint8's (see ContainerType for how to infer if an array)
  478. if d.bd == cborBdIndefiniteArray || (d.bd >= cborBaseArray && d.bd < cborBaseMap) {
  479. bsOut, _ = fastpathTV.DecSliceUint8V(bs, true, d.d)
  480. return
  481. }
  482. clen := d.decLen()
  483. d.bdRead = false
  484. if zerocopy {
  485. if d.br {
  486. return d.r.readx(clen)
  487. } else if len(bs) == 0 {
  488. bs = d.d.b[:]
  489. }
  490. }
  491. return decByteSlice(d.r, clen, d.h.MaxInitLen, bs)
  492. }
  493. func (d *cborDecDriver) DecodeString() (s string) {
  494. return string(d.DecodeBytes(d.d.b[:], true))
  495. }
  496. func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
  497. return d.DecodeBytes(d.d.b[:], true)
  498. }
  499. func (d *cborDecDriver) DecodeTime() (t time.Time) {
  500. if !d.bdRead {
  501. d.readNextBd()
  502. }
  503. if d.bd == cborBdNil || d.bd == cborBdUndefined {
  504. d.bdRead = false
  505. return
  506. }
  507. xtag := d.decUint()
  508. d.bdRead = false
  509. return d.decodeTime(xtag)
  510. }
  511. func (d *cborDecDriver) decodeTime(xtag uint64) (t time.Time) {
  512. if !d.bdRead {
  513. d.readNextBd()
  514. }
  515. switch xtag {
  516. case 0:
  517. var err error
  518. if t, err = time.Parse(time.RFC3339, stringView(d.DecodeStringAsBytes())); err != nil {
  519. d.d.errorv(err)
  520. }
  521. case 1:
  522. // decode an int64 or a float, and infer time.Time from there.
  523. // for floats, round to microseconds, as that is what is guaranteed to fit well.
  524. switch {
  525. case d.bd == cborBdFloat16, d.bd == cborBdFloat32:
  526. f1, f2 := math.Modf(d.DecodeFloat64())
  527. t = time.Unix(int64(f1), int64(f2*1e9))
  528. case d.bd == cborBdFloat64:
  529. f1, f2 := math.Modf(d.DecodeFloat64())
  530. t = time.Unix(int64(f1), int64(f2*1e9))
  531. case d.bd >= cborBaseUint && d.bd < cborBaseNegInt,
  532. d.bd >= cborBaseNegInt && d.bd < cborBaseBytes:
  533. t = time.Unix(d.DecodeInt64(), 0)
  534. default:
  535. d.d.errorf("time.Time can only be decoded from a number (or RFC3339 string)")
  536. }
  537. default:
  538. d.d.errorf("invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
  539. }
  540. t = t.UTC().Round(time.Microsecond)
  541. return
  542. }
  543. func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) (realxtag uint64) {
  544. if !d.bdRead {
  545. d.readNextBd()
  546. }
  547. u := d.decUint()
  548. d.bdRead = false
  549. realxtag = u
  550. if ext == nil {
  551. re := rv.(*RawExt)
  552. re.Tag = realxtag
  553. d.d.decode(&re.Value)
  554. } else if xtag != realxtag {
  555. d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", realxtag, xtag)
  556. return
  557. } else {
  558. var v interface{}
  559. d.d.decode(&v)
  560. ext.UpdateExt(rv, v)
  561. }
  562. d.bdRead = false
  563. return
  564. }
  565. func (d *cborDecDriver) DecodeNaked() {
  566. if !d.bdRead {
  567. d.readNextBd()
  568. }
  569. n := d.d.n
  570. var decodeFurther bool
  571. switch d.bd {
  572. case cborBdNil:
  573. n.v = valueTypeNil
  574. case cborBdFalse:
  575. n.v = valueTypeBool
  576. n.b = false
  577. case cborBdTrue:
  578. n.v = valueTypeBool
  579. n.b = true
  580. case cborBdFloat16, cborBdFloat32, cborBdFloat64:
  581. n.v = valueTypeFloat
  582. n.f = d.DecodeFloat64()
  583. case cborBdIndefiniteBytes:
  584. n.v = valueTypeBytes
  585. n.l = d.DecodeBytes(nil, false)
  586. case cborBdIndefiniteString:
  587. n.v = valueTypeString
  588. n.s = d.DecodeString()
  589. case cborBdIndefiniteArray:
  590. n.v = valueTypeArray
  591. decodeFurther = true
  592. case cborBdIndefiniteMap:
  593. n.v = valueTypeMap
  594. decodeFurther = true
  595. default:
  596. switch {
  597. case d.bd >= cborBaseUint && d.bd < cborBaseNegInt:
  598. if d.h.SignedInteger {
  599. n.v = valueTypeInt
  600. n.i = d.DecodeInt64()
  601. } else {
  602. n.v = valueTypeUint
  603. n.u = d.DecodeUint64()
  604. }
  605. case d.bd >= cborBaseNegInt && d.bd < cborBaseBytes:
  606. n.v = valueTypeInt
  607. n.i = d.DecodeInt64()
  608. case d.bd >= cborBaseBytes && d.bd < cborBaseString:
  609. n.v = valueTypeBytes
  610. n.l = d.DecodeBytes(nil, false)
  611. case d.bd >= cborBaseString && d.bd < cborBaseArray:
  612. n.v = valueTypeString
  613. n.s = d.DecodeString()
  614. case d.bd >= cborBaseArray && d.bd < cborBaseMap:
  615. n.v = valueTypeArray
  616. decodeFurther = true
  617. case d.bd >= cborBaseMap && d.bd < cborBaseTag:
  618. n.v = valueTypeMap
  619. decodeFurther = true
  620. case d.bd >= cborBaseTag && d.bd < cborBaseSimple:
  621. n.v = valueTypeExt
  622. n.u = d.decUint()
  623. n.l = nil
  624. if n.u == 0 || n.u == 1 {
  625. d.bdRead = false
  626. n.v = valueTypeTime
  627. n.t = d.decodeTime(n.u)
  628. }
  629. // d.bdRead = false
  630. // d.d.decode(&re.Value) // handled by decode itself.
  631. // decodeFurther = true
  632. default:
  633. d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
  634. return
  635. }
  636. }
  637. if !decodeFurther {
  638. d.bdRead = false
  639. }
  640. return
  641. }
  642. // -------------------------
  643. // CborHandle is a Handle for the CBOR encoding format,
  644. // defined at http://tools.ietf.org/html/rfc7049 and documented further at http://cbor.io .
  645. //
  646. // CBOR is comprehensively supported, including support for:
  647. // - indefinite-length arrays/maps/bytes/strings
  648. // - (extension) tags in range 0..0xffff (0 .. 65535)
  649. // - half, single and double-precision floats
  650. // - all numbers (1, 2, 4 and 8-byte signed and unsigned integers)
  651. // - nil, true, false, ...
  652. // - arrays and maps, bytes and text strings
  653. //
  654. // None of the optional extensions (with tags) defined in the spec are supported out-of-the-box.
  655. // Users can implement them as needed (using SetExt), including spec-documented ones:
  656. // - timestamp, BigNum, BigFloat, Decimals,
  657. // - Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
  658. type CborHandle struct {
  659. binaryEncodingType
  660. noElemSeparators
  661. BasicHandle
  662. // IndefiniteLength=true, means that we encode using indefinitelength
  663. IndefiniteLength bool
  664. // TimeRFC3339 says to encode time.Time using RFC3339 format.
  665. // If unset, we encode time.Time using seconds past epoch.
  666. TimeRFC3339 bool
  667. // _ [1]uint64 // padding
  668. }
  669. // Name returns the name of the handle: cbor
  670. func (h *CborHandle) Name() string { return "cbor" }
  671. // SetInterfaceExt sets an extension
  672. func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
  673. return h.SetExt(rt, tag, &extWrapper{bytesExtFailer{}, ext})
  674. }
  675. func (h *CborHandle) newEncDriver(e *Encoder) encDriver {
  676. return &cborEncDriver{e: e, w: e.w, h: h}
  677. }
  678. func (h *CborHandle) newDecDriver(d *Decoder) decDriver {
  679. return &cborDecDriver{d: d, h: h, r: d.r, br: d.bytes}
  680. }
  681. func (e *cborEncDriver) reset() {
  682. e.w = e.e.w
  683. }
  684. func (d *cborDecDriver) reset() {
  685. d.r, d.br = d.d.r, d.d.bytes
  686. d.bd, d.bdRead = 0, false
  687. }
  688. var _ decDriver = (*cborDecDriver)(nil)
  689. var _ encDriver = (*cborEncDriver)(nil)