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