@@ -22,29 +22,20 @@ package cid
22
22
import (
23
23
"bytes"
24
24
"encoding"
25
- "encoding/binary"
26
25
"encoding/json"
27
26
"errors"
28
27
"fmt"
29
28
"strings"
30
29
31
30
mbase "github.com/multiformats/go-multibase"
32
31
mh "github.com/multiformats/go-multihash"
32
+ varint "github.com/multiformats/go-varint"
33
33
)
34
34
35
35
// UnsupportedVersionString just holds an error message
36
36
const UnsupportedVersionString = "<unsupported cid version>"
37
37
38
38
var (
39
- // ErrVarintBuffSmall means that a buffer passed to the cid parser was not
40
- // long enough, or did not contain an invalid cid
41
- ErrVarintBuffSmall = errors .New ("reading varint: buffer too small" )
42
-
43
- // ErrVarintTooBig means that the varint in the given cid was above the
44
- // limit of 2^64
45
- ErrVarintTooBig = errors .New ("reading varint: varint bigger than 64bits" +
46
- " and not supported" )
47
-
48
39
// ErrCidTooShort means that the cid passed to decode was not long
49
40
// enough to be a valid Cid
50
41
ErrCidTooShort = errors .New ("cid too short" )
@@ -173,9 +164,9 @@ func NewCidV0(mhash mh.Multihash) Cid {
173
164
func NewCidV1 (codecType uint64 , mhash mh.Multihash ) Cid {
174
165
hashlen := len (mhash )
175
166
// two 8 bytes (max) numbers plus hash
176
- buf := make ([]byte , 2 * binary . MaxVarintLen64 + hashlen )
177
- n := binary .PutUvarint (buf , 1 )
178
- n += binary .PutUvarint (buf [n :], codecType )
167
+ buf := make ([]byte , 1 + varint . UvarintSize ( codecType ) + hashlen )
168
+ n := varint .PutUvarint (buf , 1 )
169
+ n += varint .PutUvarint (buf [n :], codecType )
179
170
cn := copy (buf [n :], mhash )
180
171
if cn != hashlen {
181
172
panic ("copy hash length is inconsistent" )
@@ -281,17 +272,6 @@ func ExtractEncoding(v string) (mbase.Encoding, error) {
281
272
return encoding , nil
282
273
}
283
274
284
- func uvError (read int ) error {
285
- switch {
286
- case read == 0 :
287
- return ErrVarintBuffSmall
288
- case read < 0 :
289
- return ErrVarintTooBig
290
- default :
291
- return nil
292
- }
293
- }
294
-
295
275
// Cast takes a Cid data slice, parses it and returns a Cid.
296
276
// For CidV1, the data buffer is in the form:
297
277
//
@@ -351,8 +331,8 @@ func (c Cid) Type() uint64 {
351
331
if c .Version () == 0 {
352
332
return DagProtobuf
353
333
}
354
- _ , n := uvarint (c .str )
355
- codec , _ := uvarint (c .str [n :])
334
+ _ , n , _ := uvarint (c .str )
335
+ codec , _ , _ := uvarint (c .str [n :])
356
336
return codec
357
337
}
358
338
@@ -414,9 +394,9 @@ func (c Cid) Hash() mh.Multihash {
414
394
}
415
395
416
396
// skip version length
417
- _ , n1 := binary . Uvarint (bytes )
397
+ _ , n1 , _ := varint . FromUvarint (bytes )
418
398
// skip codec length
419
- _ , n2 := binary . Uvarint (bytes [n1 :])
399
+ _ , n2 , _ := varint . FromUvarint (bytes [n1 :])
420
400
421
401
return mh .Multihash (bytes [n1 + n2 :])
422
402
}
@@ -562,34 +542,42 @@ func (p Prefix) Sum(data []byte) (Cid, error) {
562
542
//
563
543
// <version><codec><mh-type><mh-length>
564
544
func (p Prefix ) Bytes () []byte {
565
- buf := make ([]byte , 4 * binary .MaxVarintLen64 )
566
- n := binary .PutUvarint (buf , p .Version )
567
- n += binary .PutUvarint (buf [n :], p .Codec )
568
- n += binary .PutUvarint (buf [n :], uint64 (p .MhType ))
569
- n += binary .PutUvarint (buf [n :], uint64 (p .MhLength ))
570
- return buf [:n ]
545
+ size := varint .UvarintSize (p .Version )
546
+ size += varint .UvarintSize (p .Codec )
547
+ size += varint .UvarintSize (p .MhType )
548
+ size += varint .UvarintSize (uint64 (p .MhLength ))
549
+
550
+ buf := make ([]byte , size )
551
+ n := varint .PutUvarint (buf , p .Version )
552
+ n += varint .PutUvarint (buf [n :], p .Codec )
553
+ n += varint .PutUvarint (buf [n :], p .MhType )
554
+ n += varint .PutUvarint (buf [n :], uint64 (p .MhLength ))
555
+ if n != size {
556
+ panic ("size mismatch" )
557
+ }
558
+ return buf
571
559
}
572
560
573
561
// PrefixFromBytes parses a Prefix-byte representation onto a
574
562
// Prefix.
575
563
func PrefixFromBytes (buf []byte ) (Prefix , error ) {
576
564
r := bytes .NewReader (buf )
577
- vers , err := binary .ReadUvarint (r )
565
+ vers , err := varint .ReadUvarint (r )
578
566
if err != nil {
579
567
return Prefix {}, err
580
568
}
581
569
582
- codec , err := binary .ReadUvarint (r )
570
+ codec , err := varint .ReadUvarint (r )
583
571
if err != nil {
584
572
return Prefix {}, err
585
573
}
586
574
587
- mhtype , err := binary .ReadUvarint (r )
575
+ mhtype , err := varint .ReadUvarint (r )
588
576
if err != nil {
589
577
return Prefix {}, err
590
578
}
591
579
592
- mhlen , err := binary .ReadUvarint (r )
580
+ mhlen , err := varint .ReadUvarint (r )
593
581
if err != nil {
594
582
return Prefix {}, err
595
583
}
@@ -616,17 +604,17 @@ func CidFromBytes(data []byte) (int, Cid, error) {
616
604
return 34 , Cid {string (h )}, nil
617
605
}
618
606
619
- vers , n := binary . Uvarint (data )
620
- if err := uvError ( n ); err != nil {
607
+ vers , n , err := varint . FromUvarint (data )
608
+ if err != nil {
621
609
return 0 , Undef , err
622
610
}
623
611
624
612
if vers != 1 {
625
613
return 0 , Undef , fmt .Errorf ("expected 1 as the cid version number, got: %d" , vers )
626
614
}
627
615
628
- _ , cn := binary . Uvarint (data [n :])
629
- if err := uvError ( cn ); err != nil {
616
+ _ , cn , err := varint . FromUvarint (data [n :])
617
+ if err != nil {
630
618
return 0 , Undef , err
631
619
}
632
620
0 commit comments