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