bencode/decode.go

   1 package bencode
   2
   3 import (
   4         "bytes"
   5         "errors"
   6         "fmt"
   7         "io"
   8         "math/big"
   9         "reflect"
  10         "runtime"
  11         "strconv"
  12         "sync"
  13 )
  14
  15 type Decoder struct {
  16         r interface {
  17                 io.ByteScanner
  18                 io.Reader
  19         }
  20         // Sum of bytes used to Decode values.
  21         Offset int64
  22         buf    bytes.Buffer
  23 }
  24
  25 func (d *Decoder) Decode(v interface{}) (err error) {
  26         defer func() {
  27                 if err != nil {
  28                         return
  29                 }
  30                 r := recover()
  31                 _, ok := r.(runtime.Error)
  32                 if ok {
  33                         panic(r)
  34                 }
  35                 err, ok = r.(error)
  36                 if !ok && r != nil {
  37                         panic(r)
  38                 }
  39         }()
  40
  41         pv := reflect.ValueOf(v)
  42         if pv.Kind() != reflect.Ptr || pv.IsNil() {
  43                 return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
  44         }
  45
  46         ok, err := d.parseValue(pv.Elem())
  47         if err != nil {
  48                 return
  49         }
  50         if !ok {
  51                 d.throwSyntaxError(d.Offset-1, errors.New("unexpected 'e'"))
  52         }
  53         return
  54 }
  55
  56 func checkForUnexpectedEOF(err error, offset int64) {
  57         if err == io.EOF {
  58                 panic(&SyntaxError{
  59                         Offset: offset,
  60                         What:   io.ErrUnexpectedEOF,
  61                 })
  62         }
  63 }
  64
  65 func (d *Decoder) readByte() byte {
  66         b, err := d.r.ReadByte()
  67         if err != nil {
  68                 checkForUnexpectedEOF(err, d.Offset)
  69                 panic(err)
  70         }
  71
  72         d.Offset++
  73         return b
  74 }
  75
  76 // reads data writing it to 'd.buf' until 'sep' byte is encountered, 'sep' byte
  77 // is consumed, but not included into the 'd.buf'
  78 func (d *Decoder) readUntil(sep byte) {
  79         for {
  80                 b := d.readByte()
  81                 if b == sep {
  82                         return
  83                 }
  84                 d.buf.WriteByte(b)
  85         }
  86 }
  87
  88 func checkForIntParseError(err error, offset int64) {
  89         if err != nil {
  90                 panic(&SyntaxError{
  91                         Offset: offset,
  92                         What:   err,
  93                 })
  94         }
  95 }
  96
  97 func (d *Decoder) throwSyntaxError(offset int64, err error) {
  98         panic(&SyntaxError{
  99                 Offset: offset,
 100                 What:   err,
 101         })
 102 }
 103
 104 // called when 'i' was consumed
 105 func (d *Decoder) parseInt(v reflect.Value) error {
 106         start := d.Offset - 1
 107         d.readUntil('e')
 108         if d.buf.Len() == 0 {
 109                 panic(&SyntaxError{
 110                         Offset: start,
 111                         What:   errors.New("empty integer value"),
 112                 })
 113         }
 114
 115         s := bytesAsString(d.buf.Bytes())
 116
 117         switch v.Kind() {
 118         case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 119                 n, err := strconv.ParseInt(s, 10, 64)
 120                 checkForIntParseError(err, start)
 121
 122                 if v.OverflowInt(n) {
 123                         return &UnmarshalTypeError{
 124                                 BencodeTypeName:     "int",
 125                                 UnmarshalTargetType: v.Type(),
 126                         }
 127                 }
 128                 v.SetInt(n)
 129         case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 130                 n, err := strconv.ParseUint(s, 10, 64)
 131                 checkForIntParseError(err, start)
 132
 133                 if v.OverflowUint(n) {
 134                         return &UnmarshalTypeError{
 135                                 BencodeTypeName:     "int",
 136                                 UnmarshalTargetType: v.Type(),
 137                         }
 138                 }
 139                 v.SetUint(n)
 140         case reflect.Bool:
 141                 v.SetBool(s != "0")
 142         default:
 143                 return &UnmarshalTypeError{
 144                         BencodeTypeName:     "int",
 145                         UnmarshalTargetType: v.Type(),
 146                 }
 147         }
 148         d.buf.Reset()
 149         return nil
 150 }
 151
 152 func (d *Decoder) parseString(v reflect.Value) error {
 153         start := d.Offset - 1
 154
 155         // read the string length first
 156         d.readUntil(':')
 157         length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()), 10, 0)
 158         checkForIntParseError(err, start)
 159
 160         defer d.buf.Reset()
 161
 162         read := func(b []byte) {
 163                 n, err := io.ReadFull(d.r, b)
 164                 d.Offset += int64(n)
 165                 if err != nil {
 166                         checkForUnexpectedEOF(err, d.Offset)
 167                         panic(&SyntaxError{
 168                                 Offset: d.Offset,
 169                                 What:   errors.New("unexpected I/O error: " + err.Error()),
 170                         })
 171                 }
 172         }
 173
 174         switch v.Kind() {
 175         case reflect.String:
 176                 b := make([]byte, length)
 177                 read(b)
 178                 v.SetString(bytesAsString(b))
 179                 return nil
 180         case reflect.Slice:
 181                 if v.Type().Elem().Kind() != reflect.Uint8 {
 182                         break
 183                 }
 184                 b := make([]byte, length)
 185                 read(b)
 186                 v.SetBytes(b)
 187                 return nil
 188         case reflect.Array:
 189                 if v.Type().Elem().Kind() != reflect.Uint8 {
 190                         break
 191                 }
 192                 d.buf.Grow(int(length))
 193                 b := d.buf.Bytes()[:length]
 194                 read(b)
 195                 reflect.Copy(v, reflect.ValueOf(b))
 196                 return nil
 197         }
 198         d.buf.Grow(int(length))
 199         read(d.buf.Bytes()[:length])
 200         // I believe we return here to support "ignore_unmarshal_type_error".
 201         return &UnmarshalTypeError{
 202                 BencodeTypeName:     "string",
 203                 UnmarshalTargetType: v.Type(),
 204         }
 205 }
 206
 207 // Info for parsing a dict value.
 208 type dictField struct {
 209         Type reflect.Type
 210         Get  func(value reflect.Value) func(reflect.Value)
 211         Tags tag
 212 }
 213
 214 // Returns specifics for parsing a dict field value.
 215 func getDictField(dict reflect.Type, key string) (_ dictField, err error) {
 216         // get valuev as a map value or as a struct field
 217         switch k := dict.Kind(); k {
 218         case reflect.Map:
 219                 return dictField{
 220                         Type: dict.Elem(),
 221                         Get: func(mapValue reflect.Value) func(reflect.Value) {
 222                                 return func(value reflect.Value) {
 223                                         if mapValue.IsNil() {
 224                                                 mapValue.Set(reflect.MakeMap(dict))
 225                                         }
 226                                         // Assigns the value into the map.
 227                                         //log.Printf("map type: %v", mapValue.Type())
 228                                         mapValue.SetMapIndex(reflect.ValueOf(key).Convert(dict.Key()), value)
 229                                 }
 230                         },
 231                 }, nil
 232         case reflect.Struct:
 233                 return getStructFieldForKey(dict, key), nil
 234                 //if sf.r.PkgPath != "" {
 235                 //      panic(&UnmarshalFieldError{
 236                 //              Key:   key,
 237                 //              Type:  dict.Type(),
 238                 //              Field: sf.r,
 239                 //      })
 240                 //}
 241         default:
 242                 err = fmt.Errorf("can't assign bencode dict items into a %v", k)
 243                 return
 244         }
 245 }
 246
 247 var (
 248         structFieldsMu sync.Mutex
 249         structFields   = map[reflect.Type]map[string]dictField{}
 250 )
 251
 252 func parseStructFields(struct_ reflect.Type, each func(key string, df dictField)) {
 253         for _i, n := 0, struct_.NumField(); _i < n; _i++ {
 254                 i := _i
 255                 f := struct_.Field(i)
 256                 if f.Anonymous {
 257                         t := f.Type
 258                         if t.Kind() == reflect.Ptr {
 259                                 t = t.Elem()
 260                         }
 261                         parseStructFields(t, func(key string, df dictField) {
 262                                 innerGet := df.Get
 263                                 df.Get = func(value reflect.Value) func(reflect.Value) {
 264                                         anonPtr := value.Field(i)
 265                                         if anonPtr.Kind() == reflect.Ptr && anonPtr.IsNil() {
 266                                                 anonPtr.Set(reflect.New(f.Type.Elem()))
 267                                                 anonPtr = anonPtr.Elem()
 268                                         }
 269                                         return innerGet(anonPtr)
 270                                 }
 271                                 each(key, df)
 272                         })
 273                         continue
 274                 }
 275                 tagStr := f.Tag.Get("bencode")
 276                 if tagStr == "-" {
 277                         continue
 278                 }
 279                 tag := parseTag(tagStr)
 280                 key := tag.Key()
 281                 if key == "" {
 282                         key = f.Name
 283                 }
 284                 each(key, dictField{f.Type, func(value reflect.Value) func(reflect.Value) {
 285                         return value.Field(i).Set
 286                 }, tag})
 287         }
 288 }
 289
 290 func saveStructFields(struct_ reflect.Type) {
 291         m := make(map[string]dictField)
 292         parseStructFields(struct_, func(key string, sf dictField) {
 293                 m[key] = sf
 294         })
 295         structFields[struct_] = m
 296 }
 297
 298 func getStructFieldForKey(struct_ reflect.Type, key string) (f dictField) {
 299         structFieldsMu.Lock()
 300         if _, ok := structFields[struct_]; !ok {
 301                 saveStructFields(struct_)
 302         }
 303         f, ok := structFields[struct_][key]
 304         structFieldsMu.Unlock()
 305         if !ok {
 306                 var discard interface{}
 307                 return dictField{
 308                         Type: reflect.TypeOf(discard),
 309                         Get:  func(reflect.Value) func(reflect.Value) { return func(reflect.Value) {} },
 310                         Tags: nil,
 311                 }
 312         }
 313         return
 314 }
 315
 316 func (d *Decoder) parseDict(v reflect.Value) error {
 317         // At this point 'd' byte was consumed, now read key/value pairs
 318         for {
 319                 var keyStr string
 320                 keyValue := reflect.ValueOf(&keyStr).Elem()
 321                 ok, err := d.parseValue(keyValue)
 322                 if err != nil {
 323                         return fmt.Errorf("error parsing dict key: %w", err)
 324                 }
 325                 if !ok {
 326                         return nil
 327                 }
 328
 329                 df, err := getDictField(v.Type(), keyStr)
 330                 if err != nil {
 331                         return fmt.Errorf("parsing bencode dict into %v: %w", v.Type(), err)
 332                 }
 333
 334                 // now we need to actually parse it
 335                 if df.Type == nil {
 336                         // Discard the value, there's nowhere to put it.
 337                         var if_ interface{}
 338                         if_, ok = d.parseValueInterface()
 339                         if if_ == nil {
 340                                 return fmt.Errorf("error parsing value for key %q", keyStr)
 341                         }
 342                         if !ok {
 343                                 return fmt.Errorf("missing value for key %q", keyStr)
 344                         }
 345                         continue
 346                 }
 347                 setValue := reflect.New(df.Type).Elem()
 348                 //log.Printf("parsing into %v", setValue.Type())
 349                 ok, err = d.parseValue(setValue)
 350                 if err != nil {
 351                         var target *UnmarshalTypeError
 352                         if !(errors.As(err, &target) && df.Tags.IgnoreUnmarshalTypeError()) {
 353                                 return fmt.Errorf("parsing value for key %q: %w", keyStr, err)
 354                         }
 355                 }
 356                 if !ok {
 357                         return fmt.Errorf("missing value for key %q", keyStr)
 358                 }
 359                 df.Get(v)(setValue)
 360         }
 361 }
 362
 363 func (d *Decoder) parseList(v reflect.Value) error {
 364         switch v.Kind() {
 365         default:
 366                 // If the list is a singleton of the expected type, use that value. See
 367                 // https://github.com/anacrolix/torrent/issues/297.
 368                 l := reflect.New(reflect.SliceOf(v.Type()))
 369                 if err := d.parseList(l.Elem()); err != nil {
 370                         return err
 371                 }
 372                 if l.Elem().Len() != 1 {
 373                         return &UnmarshalTypeError{
 374                                 BencodeTypeName:     "list",
 375                                 UnmarshalTargetType: v.Type(),
 376                         }
 377                 }
 378                 v.Set(l.Elem().Index(0))
 379                 return nil
 380         case reflect.Array, reflect.Slice:
 381                 // We can work with this. Normal case, fallthrough.
 382         }
 383
 384         i := 0
 385         for ; ; i++ {
 386                 if v.Kind() == reflect.Slice && i >= v.Len() {
 387                         v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
 388                 }
 389
 390                 if i < v.Len() {
 391                         ok, err := d.parseValue(v.Index(i))
 392                         if err != nil {
 393                                 return err
 394                         }
 395                         if !ok {
 396                                 break
 397                         }
 398                 } else {
 399                         _, ok := d.parseValueInterface()
 400                         if !ok {
 401                                 break
 402                         }
 403                 }
 404         }
 405
 406         if i < v.Len() {
 407                 if v.Kind() == reflect.Array {
 408                         z := reflect.Zero(v.Type().Elem())
 409                         for n := v.Len(); i < n; i++ {
 410                                 v.Index(i).Set(z)
 411                         }
 412                 } else {
 413                         v.SetLen(i)
 414                 }
 415         }
 416
 417         if i == 0 && v.Kind() == reflect.Slice {
 418                 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
 419         }
 420         return nil
 421 }
 422
 423 func (d *Decoder) readOneValue() bool {
 424         b, err := d.r.ReadByte()
 425         if err != nil {
 426                 panic(err)
 427         }
 428         if b == 'e' {
 429                 d.r.UnreadByte()
 430                 return false
 431         } else {
 432                 d.Offset++
 433                 d.buf.WriteByte(b)
 434         }
 435
 436         switch b {
 437         case 'd', 'l':
 438                 // read until there is nothing to read
 439                 for d.readOneValue() {
 440                 }
 441                 // consume 'e' as well
 442                 b = d.readByte()
 443                 d.buf.WriteByte(b)
 444         case 'i':
 445                 d.readUntil('e')
 446                 d.buf.WriteString("e")
 447         default:
 448                 if b >= '0' && b <= '9' {
 449                         start := d.buf.Len() - 1
 450                         d.readUntil(':')
 451                         length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()[start:]), 10, 64)
 452                         checkForIntParseError(err, d.Offset-1)
 453
 454                         d.buf.WriteString(":")
 455                         n, err := io.CopyN(&d.buf, d.r, length)
 456                         d.Offset += n
 457                         if err != nil {
 458                                 checkForUnexpectedEOF(err, d.Offset)
 459                                 panic(&SyntaxError{
 460                                         Offset: d.Offset,
 461                                         What:   errors.New("unexpected I/O error: " + err.Error()),
 462                                 })
 463                         }
 464                         break
 465                 }
 466
 467                 d.raiseUnknownValueType(b, d.Offset-1)
 468         }
 469
 470         return true
 471
 472 }
 473
 474 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
 475         if !v.Type().Implements(unmarshalerType) {
 476                 if v.Addr().Type().Implements(unmarshalerType) {
 477                         v = v.Addr()
 478                 } else {
 479                         return false
 480                 }
 481         }
 482         d.buf.Reset()
 483         if !d.readOneValue() {
 484                 return false
 485         }
 486         m := v.Interface().(Unmarshaler)
 487         err := m.UnmarshalBencode(d.buf.Bytes())
 488         if err != nil {
 489                 panic(&UnmarshalerError{v.Type(), err})
 490         }
 491         return true
 492 }
 493
 494 // Returns true if there was a value and it's now stored in 'v', otherwise
 495 // there was an end symbol ("e") and no value was stored.
 496 func (d *Decoder) parseValue(v reflect.Value) (bool, error) {
 497         // we support one level of indirection at the moment
 498         if v.Kind() == reflect.Ptr {
 499                 // if the pointer is nil, allocate a new element of the type it
 500                 // points to
 501                 if v.IsNil() {
 502                         v.Set(reflect.New(v.Type().Elem()))
 503                 }
 504                 v = v.Elem()
 505         }
 506
 507         if d.parseUnmarshaler(v) {
 508                 return true, nil
 509         }
 510
 511         // common case: interface{}
 512         if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
 513                 iface, _ := d.parseValueInterface()
 514                 v.Set(reflect.ValueOf(iface))
 515                 return true, nil
 516         }
 517
 518         b, err := d.r.ReadByte()
 519         if err != nil {
 520                 panic(err)
 521         }
 522         d.Offset++
 523
 524         switch b {
 525         case 'e':
 526                 return false, nil
 527         case 'd':
 528                 return true, d.parseDict(v)
 529         case 'l':
 530                 return true, d.parseList(v)
 531         case 'i':
 532                 return true, d.parseInt(v)
 533         default:
 534                 if b >= '0' && b <= '9' {
 535                         // It's a string.
 536                         d.buf.Reset()
 537                         // Write the first digit of the length to the buffer.
 538                         d.buf.WriteByte(b)
 539                         return true, d.parseString(v)
 540                 }
 541
 542                 d.raiseUnknownValueType(b, d.Offset-1)
 543         }
 544         panic("unreachable")
 545 }
 546
 547 // An unknown bencode type character was encountered.
 548 func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
 549         panic(&SyntaxError{
 550                 Offset: offset,
 551                 What:   fmt.Errorf("unknown value type %+q", b),
 552         })
 553 }
 554
 555 func (d *Decoder) parseValueInterface() (interface{}, bool) {
 556         b, err := d.r.ReadByte()
 557         if err != nil {
 558                 panic(err)
 559         }
 560         d.Offset++
 561
 562         switch b {
 563         case 'e':
 564                 return nil, false
 565         case 'd':
 566                 return d.parseDictInterface(), true
 567         case 'l':
 568                 return d.parseListInterface(), true
 569         case 'i':
 570                 return d.parseIntInterface(), true
 571         default:
 572                 if b >= '0' && b <= '9' {
 573                         // string
 574                         // append first digit of the length to the buffer
 575                         d.buf.WriteByte(b)
 576                         return d.parseStringInterface(), true
 577                 }
 578
 579                 d.raiseUnknownValueType(b, d.Offset-1)
 580                 panic("unreachable")
 581         }
 582 }
 583
 584 func (d *Decoder) parseIntInterface() (ret interface{}) {
 585         start := d.Offset - 1
 586         d.readUntil('e')
 587         if d.buf.Len() == 0 {
 588                 panic(&SyntaxError{
 589                         Offset: start,
 590                         What:   errors.New("empty integer value"),
 591                 })
 592         }
 593
 594         n, err := strconv.ParseInt(d.buf.String(), 10, 64)
 595         if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
 596                 i := new(big.Int)
 597                 _, ok := i.SetString(d.buf.String(), 10)
 598                 if !ok {
 599                         panic(&SyntaxError{
 600                                 Offset: start,
 601                                 What:   errors.New("failed to parse integer"),
 602                         })
 603                 }
 604                 ret = i
 605         } else {
 606                 checkForIntParseError(err, start)
 607                 ret = n
 608         }
 609
 610         d.buf.Reset()
 611         return
 612 }
 613
 614 func (d *Decoder) parseStringInterface() interface{} {
 615         start := d.Offset - 1
 616
 617         // read the string length first
 618         d.readUntil(':')
 619         length, err := strconv.ParseInt(d.buf.String(), 10, 64)
 620         checkForIntParseError(err, start)
 621
 622         d.buf.Reset()
 623         n, err := io.CopyN(&d.buf, d.r, length)
 624         d.Offset += n
 625         if err != nil {
 626                 checkForUnexpectedEOF(err, d.Offset)
 627                 panic(&SyntaxError{
 628                         Offset: d.Offset,
 629                         What:   errors.New("unexpected I/O error: " + err.Error()),
 630                 })
 631         }
 632
 633         s := d.buf.String()
 634         d.buf.Reset()
 635         return s
 636 }
 637
 638 func (d *Decoder) parseDictInterface() interface{} {
 639         dict := make(map[string]interface{})
 640         for {
 641                 keyi, ok := d.parseValueInterface()
 642                 if !ok {
 643                         break
 644                 }
 645
 646                 key, ok := keyi.(string)
 647                 if !ok {
 648                         panic(&SyntaxError{
 649                                 Offset: d.Offset,
 650                                 What:   errors.New("non-string key in a dict"),
 651                         })
 652                 }
 653
 654                 valuei, ok := d.parseValueInterface()
 655                 if !ok {
 656                         break
 657                 }
 658
 659                 dict[key] = valuei
 660         }
 661         return dict
 662 }
 663
 664 func (d *Decoder) parseListInterface() interface{} {
 665         var list []interface{}
 666         for {
 667                 valuei, ok := d.parseValueInterface()
 668                 if !ok {
 669                         break
 670                 }
 671
 672                 list = append(list, valuei)
 673         }
 674         if list == nil {
 675                 list = make([]interface{}, 0)
 676         }
 677         return list
 678 }