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