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