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) error {
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 return &UnmarshalTypeError{
124 BencodeTypeName: "int",
125 UnmarshalTargetType: v.Type(),
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 return &UnmarshalTypeError{
135 BencodeTypeName: "int",
136 UnmarshalTargetType: v.Type(),
143 return &UnmarshalTypeError{
144 BencodeTypeName: "int",
145 UnmarshalTargetType: v.Type(),
152 func (d *Decoder) parseString(v reflect.Value) error {
153 start := d.Offset - 1
155 // read the string length first
157 length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()), 10, 0)
158 checkForIntParseError(err, start)
162 read := func(b []byte) {
163 n, err := io.ReadFull(d.r, b)
166 checkForUnexpectedEOF(err, d.Offset)
169 What: errors.New("unexpected I/O error: " + err.Error()),
176 b := make([]byte, length)
178 v.SetString(bytesAsString(b))
181 if v.Type().Elem().Kind() != reflect.Uint8 {
184 b := make([]byte, length)
189 if v.Type().Elem().Kind() != reflect.Uint8 {
192 d.buf.Grow(int(length))
193 b := d.buf.Bytes()[:length]
195 reflect.Copy(v, reflect.ValueOf(b))
198 d.buf.Grow(int(length))
199 read(d.buf.Bytes()[:length])
200 // I believe we return here to support "ignore_unmarshal_type_error".
201 return &UnmarshalTypeError{
202 BencodeTypeName: "string",
203 UnmarshalTargetType: v.Type(),
207 // Info for parsing a dict value.
208 type dictField struct {
210 Get func(value reflect.Value) func(reflect.Value)
214 // Returns specifics for parsing a dict field value.
215 func getDictField(dict reflect.Type, key string) (_ dictField, err error) {
216 // get valuev as a map value or as a struct field
217 switch k := dict.Kind(); k {
221 Get: func(mapValue reflect.Value) func(reflect.Value) {
222 return func(value reflect.Value) {
223 if mapValue.IsNil() {
224 mapValue.Set(reflect.MakeMap(dict))
226 // Assigns the value into the map.
227 //log.Printf("map type: %v", mapValue.Type())
228 mapValue.SetMapIndex(reflect.ValueOf(key).Convert(dict.Key()), value)
233 return getStructFieldForKey(dict, key), nil
234 //if sf.r.PkgPath != "" {
235 // panic(&UnmarshalFieldError{
237 // Type: dict.Type(),
242 err = fmt.Errorf("can't assign bencode dict items into a %v", k)
248 structFieldsMu sync.Mutex
249 structFields = map[reflect.Type]map[string]dictField{}
252 func parseStructFields(struct_ reflect.Type, each func(key string, df dictField)) {
253 for _i, n := 0, struct_.NumField(); _i < n; _i++ {
255 f := struct_.Field(i)
258 if t.Kind() == reflect.Ptr {
261 parseStructFields(t, func(key string, df dictField) {
263 df.Get = func(value reflect.Value) func(reflect.Value) {
264 anonPtr := value.Field(i)
265 if anonPtr.Kind() == reflect.Ptr && anonPtr.IsNil() {
266 anonPtr.Set(reflect.New(f.Type.Elem()))
267 anonPtr = anonPtr.Elem()
269 return innerGet(anonPtr)
275 tagStr := f.Tag.Get("bencode")
279 tag := parseTag(tagStr)
284 each(key, dictField{f.Type, func(value reflect.Value) func(reflect.Value) {
285 return value.Field(i).Set
290 func saveStructFields(struct_ reflect.Type) {
291 m := make(map[string]dictField)
292 parseStructFields(struct_, func(key string, sf dictField) {
295 structFields[struct_] = m
298 func getStructFieldForKey(struct_ reflect.Type, key string) (f dictField) {
299 structFieldsMu.Lock()
300 if _, ok := structFields[struct_]; !ok {
301 saveStructFields(struct_)
303 f, ok := structFields[struct_][key]
304 structFieldsMu.Unlock()
306 var discard interface{}
308 Type: reflect.TypeOf(discard),
309 Get: func(reflect.Value) func(reflect.Value) { return func(reflect.Value) {} },
316 func (d *Decoder) parseDict(v reflect.Value) error {
317 // At this point 'd' byte was consumed, now read key/value pairs
320 keyValue := reflect.ValueOf(&keyStr).Elem()
321 ok, err := d.parseValue(keyValue)
323 return fmt.Errorf("error parsing dict key: %w", err)
329 df, err := getDictField(v.Type(), keyStr)
331 return fmt.Errorf("parsing bencode dict into %v: %w", v.Type(), err)
334 // now we need to actually parse it
336 // Discard the value, there's nowhere to put it.
338 if_, ok = d.parseValueInterface()
340 return fmt.Errorf("error parsing value for key %q", keyStr)
343 return fmt.Errorf("missing value for key %q", keyStr)
347 setValue := reflect.New(df.Type).Elem()
348 //log.Printf("parsing into %v", setValue.Type())
349 ok, err = d.parseValue(setValue)
351 var target *UnmarshalTypeError
352 if !(errors.As(err, &target) && df.Tags.IgnoreUnmarshalTypeError()) {
353 return fmt.Errorf("parsing value for key %q: %w", keyStr, err)
357 return fmt.Errorf("missing value for key %q", keyStr)
363 func (d *Decoder) parseList(v reflect.Value) error {
366 // If the list is a singleton of the expected type, use that value. See
367 // https://github.com/anacrolix/torrent/issues/297.
368 l := reflect.New(reflect.SliceOf(v.Type()))
369 if err := d.parseList(l.Elem()); err != nil {
372 if l.Elem().Len() != 1 {
373 return &UnmarshalTypeError{
374 BencodeTypeName: "list",
375 UnmarshalTargetType: v.Type(),
378 v.Set(l.Elem().Index(0))
380 case reflect.Array, reflect.Slice:
381 // We can work with this. Normal case, fallthrough.
386 if v.Kind() == reflect.Slice && i >= v.Len() {
387 v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
391 ok, err := d.parseValue(v.Index(i))
399 _, ok := d.parseValueInterface()
407 if v.Kind() == reflect.Array {
408 z := reflect.Zero(v.Type().Elem())
409 for n := v.Len(); i < n; i++ {
417 if i == 0 && v.Kind() == reflect.Slice {
418 v.Set(reflect.MakeSlice(v.Type(), 0, 0))
423 func (d *Decoder) readOneValue() bool {
424 b, err := d.r.ReadByte()
438 // read until there is nothing to read
439 for d.readOneValue() {
441 // consume 'e' as well
446 d.buf.WriteString("e")
448 if b >= '0' && b <= '9' {
449 start := d.buf.Len() - 1
451 length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()[start:]), 10, 64)
452 checkForIntParseError(err, d.Offset-1)
454 d.buf.WriteString(":")
455 n, err := io.CopyN(&d.buf, d.r, length)
458 checkForUnexpectedEOF(err, d.Offset)
461 What: errors.New("unexpected I/O error: " + err.Error()),
467 d.raiseUnknownValueType(b, d.Offset-1)
474 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
475 if !v.Type().Implements(unmarshalerType) {
476 if v.Addr().Type().Implements(unmarshalerType) {
483 if !d.readOneValue() {
486 m := v.Interface().(Unmarshaler)
487 err := m.UnmarshalBencode(d.buf.Bytes())
489 panic(&UnmarshalerError{v.Type(), err})
494 // Returns true if there was a value and it's now stored in 'v', otherwise
495 // there was an end symbol ("e") and no value was stored.
496 func (d *Decoder) parseValue(v reflect.Value) (bool, error) {
497 // we support one level of indirection at the moment
498 if v.Kind() == reflect.Ptr {
499 // if the pointer is nil, allocate a new element of the type it
502 v.Set(reflect.New(v.Type().Elem()))
507 if d.parseUnmarshaler(v) {
511 // common case: interface{}
512 if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
513 iface, _ := d.parseValueInterface()
514 v.Set(reflect.ValueOf(iface))
518 b, err := d.r.ReadByte()
528 return true, d.parseDict(v)
530 return true, d.parseList(v)
532 return true, d.parseInt(v)
534 if b >= '0' && b <= '9' {
537 // Write the first digit of the length to the buffer.
539 return true, d.parseString(v)
542 d.raiseUnknownValueType(b, d.Offset-1)
547 // An unknown bencode type character was encountered.
548 func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
551 What: fmt.Errorf("unknown value type %+q", b),
555 func (d *Decoder) parseValueInterface() (interface{}, bool) {
556 b, err := d.r.ReadByte()
566 return d.parseDictInterface(), true
568 return d.parseListInterface(), true
570 return d.parseIntInterface(), true
572 if b >= '0' && b <= '9' {
574 // append first digit of the length to the buffer
576 return d.parseStringInterface(), true
579 d.raiseUnknownValueType(b, d.Offset-1)
584 func (d *Decoder) parseIntInterface() (ret interface{}) {
585 start := d.Offset - 1
587 if d.buf.Len() == 0 {
590 What: errors.New("empty integer value"),
594 n, err := strconv.ParseInt(d.buf.String(), 10, 64)
595 if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
597 _, ok := i.SetString(d.buf.String(), 10)
601 What: errors.New("failed to parse integer"),
606 checkForIntParseError(err, start)
614 func (d *Decoder) parseStringInterface() interface{} {
615 start := d.Offset - 1
617 // read the string length first
619 length, err := strconv.ParseInt(d.buf.String(), 10, 64)
620 checkForIntParseError(err, start)
623 n, err := io.CopyN(&d.buf, d.r, length)
626 checkForUnexpectedEOF(err, d.Offset)
629 What: errors.New("unexpected I/O error: " + err.Error()),
638 func (d *Decoder) parseDictInterface() interface{} {
639 dict := make(map[string]interface{})
641 keyi, ok := d.parseValueInterface()
646 key, ok := keyi.(string)
650 What: errors.New("non-string key in a dict"),
654 valuei, ok := d.parseValueInterface()
664 func (d *Decoder) parseListInterface() interface{} {
665 var list []interface{}
667 valuei, ok := d.parseValueInterface()
672 list = append(list, valuei)
675 list = make([]interface{}, 0)