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