20 // Sum of bytes used to Decode values.
25 func (d *Decoder) Decode(v interface{}) (err error) {
31 _, ok := r.(runtime.Error)
41 pv := reflect.ValueOf(v)
42 if pv.Kind() != reflect.Ptr || pv.IsNil() {
43 return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
46 ok, err := d.parseValue(pv.Elem())
51 d.throwSyntaxError(d.Offset-1, errors.New("unexpected 'e'"))
56 func checkForUnexpectedEOF(err error, offset int64) {
60 What: io.ErrUnexpectedEOF,
65 func (d *Decoder) readByte() byte {
66 b, err := d.r.ReadByte()
68 checkForUnexpectedEOF(err, d.Offset)
76 // reads data writing it to 'd.buf' until 'sep' byte is encountered, 'sep' byte
77 // is consumed, but not included into the 'd.buf'
78 func (d *Decoder) readUntil(sep byte) {
88 func checkForIntParseError(err error, offset int64) {
97 func (d *Decoder) throwSyntaxError(offset int64, err error) {
104 // called when 'i' was consumed
105 func (d *Decoder) parseInt(v reflect.Value) {
106 start := d.Offset - 1
108 if d.buf.Len() == 0 {
111 What: errors.New("empty integer value"),
115 s := bytesAsString(d.buf.Bytes())
118 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
119 n, err := strconv.ParseInt(s, 10, 64)
120 checkForIntParseError(err, start)
122 if v.OverflowInt(n) {
123 panic(&UnmarshalTypeError{
124 Value: "integer " + s,
129 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
130 n, err := strconv.ParseUint(s, 10, 64)
131 checkForIntParseError(err, start)
133 if v.OverflowUint(n) {
134 panic(&UnmarshalTypeError{
135 Value: "integer " + s,
143 panic(&UnmarshalTypeError{
144 Value: "integer " + s,
151 func (d *Decoder) parseString(v reflect.Value) error {
152 start := d.Offset - 1
154 // read the string length first
156 length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()), 10, 0)
157 checkForIntParseError(err, start)
161 read := func(b []byte) {
162 n, err := io.ReadFull(d.r, b)
165 checkForUnexpectedEOF(err, d.Offset)
168 What: errors.New("unexpected I/O error: " + err.Error()),
175 b := make([]byte, length)
177 v.SetString(bytesAsString(b))
180 if v.Type().Elem().Kind() != reflect.Uint8 {
183 b := make([]byte, length)
188 if v.Type().Elem().Kind() != reflect.Uint8 {
191 d.buf.Grow(int(length))
192 b := d.buf.Bytes()[:length]
194 reflect.Copy(v, reflect.ValueOf(b))
197 d.buf.Grow(int(length))
198 read(d.buf.Bytes()[:length])
199 // I believe we return here to support "ignore_unmarshal_type_error".
200 return &UnmarshalTypeError{
206 // Info for parsing a dict value.
207 type dictField struct {
208 Value reflect.Value // Storage for the parsed value.
209 // True if field value should be parsed into Value. If false, the value
210 // should be parsed and discarded.
212 Set func() // Call this after parsing into Value.
213 IgnoreUnmarshalTypeError bool
216 // Returns specifics for parsing a dict field value.
217 func getDictField(dict reflect.Value, key string) dictField {
218 // get valuev as a map value or as a struct field
221 value := reflect.New(dict.Type().Elem()).Elem()
227 dict.Set(reflect.MakeMap(dict.Type()))
229 // Assigns the value into the map.
230 dict.SetMapIndex(reflect.ValueOf(key).Convert(dict.Type().Key()), value)
234 sf, ok := getStructFieldForKey(dict.Type(), key)
238 if sf.r.PkgPath != "" {
239 panic(&UnmarshalFieldError{
246 Value: dict.FieldByIndex(sf.r.Index),
249 IgnoreUnmarshalTypeError: sf.tag.IgnoreUnmarshalTypeError(),
256 type structField struct {
257 r reflect.StructField
262 structFieldsMu sync.Mutex
263 structFields = map[reflect.Type]map[string]structField{}
266 func parseStructFields(struct_ reflect.Type, each func(string, structField)) {
267 for i, n := 0, struct_.NumField(); i < n; i++ {
268 f := struct_.Field(i)
272 tagStr := f.Tag.Get("bencode")
276 tag := parseTag(tagStr)
281 each(key, structField{f, tag})
285 func saveStructFields(struct_ reflect.Type) {
286 m := make(map[string]structField)
287 parseStructFields(struct_, func(key string, sf structField) {
290 structFields[struct_] = m
293 func getStructFieldForKey(struct_ reflect.Type, key string) (f structField, ok bool) {
294 structFieldsMu.Lock()
295 if _, ok := structFields[struct_]; !ok {
296 saveStructFields(struct_)
298 f, ok = structFields[struct_][key]
299 structFieldsMu.Unlock()
303 func (d *Decoder) parseDict(v reflect.Value) error {
304 // so, at this point 'd' byte was consumed, let's just read key/value
308 keyValue := reflect.ValueOf(&keyStr).Elem()
309 ok, err := d.parseValue(keyValue)
311 return fmt.Errorf("error parsing dict key: %s", err)
317 df := getDictField(v, keyStr)
319 // now we need to actually parse it
321 // log.Printf("parsing ok struct field for key %q", keyStr)
322 ok, err = d.parseValue(df.Value)
324 // Discard the value, there's nowhere to put it.
326 if_, ok = d.parseValueInterface()
328 err = fmt.Errorf("error parsing value for key %q", keyStr)
332 if _, ok := err.(*UnmarshalTypeError); !ok || !df.IgnoreUnmarshalTypeError {
333 return fmt.Errorf("parsing value for key %q: %s", keyStr, err)
337 return fmt.Errorf("missing value for key %q", keyStr)
345 func (d *Decoder) parseList(v reflect.Value) error {
348 // If the list is a singleton of the expected type, use that value. See
349 // https://github.com/anacrolix/torrent/issues/297.
350 l := reflect.New(reflect.SliceOf(v.Type()))
351 if err := d.parseList(l.Elem()); err != nil {
354 if l.Elem().Len() != 1 {
355 return &UnmarshalTypeError{
360 v.Set(l.Elem().Index(0))
362 case reflect.Array, reflect.Slice:
363 // We can work with this. Normal case, fallthrough.
368 if v.Kind() == reflect.Slice && i >= v.Len() {
369 v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
373 ok, err := d.parseValue(v.Index(i))
381 _, ok := d.parseValueInterface()
389 if v.Kind() == reflect.Array {
390 z := reflect.Zero(v.Type().Elem())
391 for n := v.Len(); i < n; i++ {
399 if i == 0 && v.Kind() == reflect.Slice {
400 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
405 func (d *Decoder) readOneValue() bool {
406 b, err := d.r.ReadByte()
420 // read until there is nothing to read
421 for d.readOneValue() {
423 // consume 'e' as well
428 d.buf.WriteString("e")
430 if b >= '0' && b <= '9' {
431 start := d.buf.Len() - 1
433 length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()[start:]), 10, 64)
434 checkForIntParseError(err, d.Offset-1)
436 d.buf.WriteString(":")
437 n, err := io.CopyN(&d.buf, d.r, length)
440 checkForUnexpectedEOF(err, d.Offset)
443 What: errors.New("unexpected I/O error: " + err.Error()),
449 d.raiseUnknownValueType(b, d.Offset-1)
456 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
457 if !v.Type().Implements(unmarshalerType) {
458 if v.Addr().Type().Implements(unmarshalerType) {
465 if !d.readOneValue() {
468 m := v.Interface().(Unmarshaler)
469 err := m.UnmarshalBencode(d.buf.Bytes())
471 panic(&UnmarshalerError{v.Type(), err})
476 // Returns true if there was a value and it's now stored in 'v', otherwise
477 // there was an end symbol ("e") and no value was stored.
478 func (d *Decoder) parseValue(v reflect.Value) (bool, error) {
479 // we support one level of indirection at the moment
480 if v.Kind() == reflect.Ptr {
481 // if the pointer is nil, allocate a new element of the type it
484 v.Set(reflect.New(v.Type().Elem()))
489 if d.parseUnmarshaler(v) {
493 // common case: interface{}
494 if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
495 iface, _ := d.parseValueInterface()
496 v.Set(reflect.ValueOf(iface))
500 b, err := d.r.ReadByte()
510 return true, d.parseDict(v)
512 return true, d.parseList(v)
517 if b >= '0' && b <= '9' {
520 // Write the first digit of the length to the buffer.
522 return true, d.parseString(v)
525 d.raiseUnknownValueType(b, d.Offset-1)
530 // An unknown bencode type character was encountered.
531 func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
534 What: fmt.Errorf("unknown value type %+q", b),
538 func (d *Decoder) parseValueInterface() (interface{}, bool) {
539 b, err := d.r.ReadByte()
549 return d.parseDictInterface(), true
551 return d.parseListInterface(), true
553 return d.parseIntInterface(), true
555 if b >= '0' && b <= '9' {
557 // append first digit of the length to the buffer
559 return d.parseStringInterface(), true
562 d.raiseUnknownValueType(b, d.Offset-1)
567 func (d *Decoder) parseIntInterface() (ret interface{}) {
568 start := d.Offset - 1
570 if d.buf.Len() == 0 {
573 What: errors.New("empty integer value"),
577 n, err := strconv.ParseInt(d.buf.String(), 10, 64)
578 if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
580 _, ok := i.SetString(d.buf.String(), 10)
584 What: errors.New("failed to parse integer"),
589 checkForIntParseError(err, start)
597 func (d *Decoder) parseStringInterface() interface{} {
598 start := d.Offset - 1
600 // read the string length first
602 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
603 checkForIntParseError(err, start)
606 n, err := io.CopyN(&d.buf, d.r, length)
609 checkForUnexpectedEOF(err, d.Offset)
612 What: errors.New("unexpected I/O error: " + err.Error()),
621 func (d *Decoder) parseDictInterface() interface{} {
622 dict := make(map[string]interface{})
624 keyi, ok := d.parseValueInterface()
629 key, ok := keyi.(string)
633 What: errors.New("non-string key in a dict"),
637 valuei, ok := d.parseValueInterface()
647 func (d *Decoder) parseListInterface() interface{} {
648 var list []interface{}
650 valuei, ok := d.parseValueInterface()
655 list = append(list, valuei)
658 list = make([]interface{}, 0, 0)