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