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