feat: Waku v2 bridge

Issue #12610

vendor/github.com/anacrolix/torrent/bencode/README.md

@@ -0,0 +1,38 @@
+Bencode encoding/decoding sub package. Uses similar API design to Go's json package.
+
+## Install
+
+```sh
+go get github.com/anacrolix/torrent
+```
+
+## Usage
+
+```go
+package demo
+
+import (
+	bencode "github.com/anacrolix/torrent/bencode"
+)
+
+type Message struct {
+	Query    string `json:"q,omitempty" bencode:"q,omitempty"`
+}
+
+var v Message
+
+func main(){
+	// encode
+	data, err := bencode.Marshal(v)
+	if err != nil {
+		log.Fatal(err)
+	}
+	
+	//decode
+	err := bencode.Unmarshal(data, &v)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Println(v)
+}
+```

vendor/github.com/anacrolix/torrent/bencode/api.go

@@ -0,0 +1,164 @@
+package bencode
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+
+	"github.com/anacrolix/missinggo/expect"
+)
+
+//----------------------------------------------------------------------------
+// Errors
+//----------------------------------------------------------------------------
+
+// In case if marshaler cannot encode a type, it will return this error. Typical
+// example of such type is float32/float64 which has no bencode representation.
+type MarshalTypeError struct {
+	Type reflect.Type
+}
+
+func (e *MarshalTypeError) Error() string {
+	return "bencode: unsupported type: " + e.Type.String()
+}
+
+// Unmarshal argument must be a non-nil value of some pointer type.
+type UnmarshalInvalidArgError struct {
+	Type reflect.Type
+}
+
+func (e *UnmarshalInvalidArgError) Error() string {
+	if e.Type == nil {
+		return "bencode: Unmarshal(nil)"
+	}
+
+	if e.Type.Kind() != reflect.Ptr {
+		return "bencode: Unmarshal(non-pointer " + e.Type.String() + ")"
+	}
+	return "bencode: Unmarshal(nil " + e.Type.String() + ")"
+}
+
+// Unmarshaler spotted a value that was not appropriate for a given Go value.
+type UnmarshalTypeError struct {
+	BencodeTypeName     string
+	UnmarshalTargetType reflect.Type
+}
+
+// This could probably be a value type, but we may already have users assuming
+// that it's passed by pointer.
+func (e *UnmarshalTypeError) Error() string {
+	return fmt.Sprintf(
+		"can't unmarshal a bencode %v into a %v",
+		e.BencodeTypeName,
+		e.UnmarshalTargetType,
+	)
+}
+
+// Unmarshaler tried to write to an unexported (therefore unwritable) field.
+type UnmarshalFieldError struct {
+	Key   string
+	Type  reflect.Type
+	Field reflect.StructField
+}
+
+func (e *UnmarshalFieldError) Error() string {
+	return "bencode: key \"" + e.Key + "\" led to an unexported field \"" +
+		e.Field.Name + "\" in type: " + e.Type.String()
+}
+
+// Malformed bencode input, unmarshaler failed to parse it.
+type SyntaxError struct {
+	Offset int64 // location of the error
+	What   error // error description
+}
+
+func (e *SyntaxError) Error() string {
+	return fmt.Sprintf("bencode: syntax error (offset: %d): %s", e.Offset, e.What)
+}
+
+// A non-nil error was returned after calling MarshalBencode on a type which
+// implements the Marshaler interface.
+type MarshalerError struct {
+	Type reflect.Type
+	Err  error
+}
+
+func (e *MarshalerError) Error() string {
+	return "bencode: error calling MarshalBencode for type " + e.Type.String() + ": " + e.Err.Error()
+}
+
+// A non-nil error was returned after calling UnmarshalBencode on a type which
+// implements the Unmarshaler interface.
+type UnmarshalerError struct {
+	Type reflect.Type
+	Err  error
+}
+
+func (e *UnmarshalerError) Error() string {
+	return "bencode: error calling UnmarshalBencode for type " + e.Type.String() + ": " + e.Err.Error()
+}
+
+//----------------------------------------------------------------------------
+// Interfaces
+//----------------------------------------------------------------------------
+
+// Any type which implements this interface, will be marshaled using the
+// specified method.
+type Marshaler interface {
+	MarshalBencode() ([]byte, error)
+}
+
+// Any type which implements this interface, will be unmarshaled using the
+// specified method.
+type Unmarshaler interface {
+	UnmarshalBencode([]byte) error
+}
+
+// Marshal the value 'v' to the bencode form, return the result as []byte and
+// an error if any.
+func Marshal(v interface{}) ([]byte, error) {
+	var buf bytes.Buffer
+	e := Encoder{w: &buf}
+	err := e.Encode(v)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+func MustMarshal(v interface{}) []byte {
+	b, err := Marshal(v)
+	expect.Nil(err)
+	return b
+}
+
+// Unmarshal the bencode value in the 'data' to a value pointed by the 'v' pointer, return a non-nil
+// error if any. If there are trailing bytes, this results in ErrUnusedTrailingBytes, but the value
+// will be valid. It's probably more consistent to use Decoder.Decode if you want to rely on this
+// behaviour (inspired by Rust's serde here).
+func Unmarshal(data []byte, v interface{}) (err error) {
+	buf := bytes.NewReader(data)
+	e := Decoder{r: buf}
+	err = e.Decode(v)
+	if err == nil && buf.Len() != 0 {
+		err = ErrUnusedTrailingBytes{buf.Len()}
+	}
+	return
+}
+
+type ErrUnusedTrailingBytes struct {
+	NumUnusedBytes int
+}
+
+func (me ErrUnusedTrailingBytes) Error() string {
+	return fmt.Sprintf("%d unused trailing bytes", me.NumUnusedBytes)
+}
+
+func NewDecoder(r io.Reader) *Decoder {
+	return &Decoder{r: &scanner{r: r}}
+}
+
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{w: w}
+}

vendor/github.com/anacrolix/torrent/bencode/bytes.go

@@ -0,0 +1,25 @@
+package bencode
+
+import (
+	"errors"
+)
+
+type Bytes []byte
+
+var (
+	_ Unmarshaler = (*Bytes)(nil)
+	_ Marshaler   = (*Bytes)(nil)
+	_ Marshaler   = Bytes{}
+)
+
+func (me *Bytes) UnmarshalBencode(b []byte) error {
+	*me = append([]byte(nil), b...)
+	return nil
+}
+
+func (me Bytes) MarshalBencode() ([]byte, error) {
+	if len(me) == 0 {
+		return nil, errors.New("marshalled Bytes should not be zero-length")
+	}
+	return me, nil
+}

vendor/github.com/anacrolix/torrent/bencode/decode.go

@@ -0,0 +1,740 @@
+package bencode
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"reflect"
+	"runtime"
+	"strconv"
+	"sync"
+)
+
+// The default bencode string length limit. This is a poor attempt to prevent excessive memory
+// allocation when parsing, but also leaves the window open to implement a better solution.
+const DefaultDecodeMaxStrLen = 1<<27 - 1 // ~128MiB
+
+type MaxStrLen = int64
+
+type Decoder struct {
+	// Maximum parsed bencode string length. Defaults to DefaultMaxStrLen if zero.
+	MaxStrLen MaxStrLen
+
+	r interface {
+		io.ByteScanner
+		io.Reader
+	}
+	// Sum of bytes used to Decode values.
+	Offset int64
+	buf    bytes.Buffer
+}
+
+func (d *Decoder) Decode(v interface{}) (err error) {
+	defer func() {
+		if err != nil {
+			return
+		}
+		r := recover()
+		if r == nil {
+			return
+		}
+		_, ok := r.(runtime.Error)
+		if ok {
+			panic(r)
+		}
+		if err, ok = r.(error); !ok {
+			panic(r)
+		}
+		// Errors thrown from deeper in parsing are unexpected. At value boundaries, errors should
+		// be returned directly (at least until all the panic nonsense is removed entirely).
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	pv := reflect.ValueOf(v)
+	if pv.Kind() != reflect.Ptr || pv.IsNil() {
+		return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
+	}
+
+	ok, err := d.parseValue(pv.Elem())
+	if err != nil {
+		return
+	}
+	if !ok {
+		d.throwSyntaxError(d.Offset-1, errors.New("unexpected 'e'"))
+	}
+	return
+}
+
+func checkForUnexpectedEOF(err error, offset int64) {
+	if err == io.EOF {
+		panic(&SyntaxError{
+			Offset: offset,
+			What:   io.ErrUnexpectedEOF,
+		})
+	}
+}
+
+func (d *Decoder) readByte() byte {
+	b, err := d.r.ReadByte()
+	if err != nil {
+		checkForUnexpectedEOF(err, d.Offset)
+		panic(err)
+	}
+
+	d.Offset++
+	return b
+}
+
+// reads data writing it to 'd.buf' until 'sep' byte is encountered, 'sep' byte
+// is consumed, but not included into the 'd.buf'
+func (d *Decoder) readUntil(sep byte) {
+	for {
+		b := d.readByte()
+		if b == sep {
+			return
+		}
+		d.buf.WriteByte(b)
+	}
+}
+
+func checkForIntParseError(err error, offset int64) {
+	if err != nil {
+		panic(&SyntaxError{
+			Offset: offset,
+			What:   err,
+		})
+	}
+}
+
+func (d *Decoder) throwSyntaxError(offset int64, err error) {
+	panic(&SyntaxError{
+		Offset: offset,
+		What:   err,
+	})
+}
+
+// Assume the 'i' is already consumed. Read and validate the rest of an int into the buffer.
+func (d *Decoder) readInt() error {
+	// start := d.Offset - 1
+	d.readUntil('e')
+	if err := d.checkBufferedInt(); err != nil {
+		return err
+	}
+	// if d.buf.Len() == 0 {
+	// 	panic(&SyntaxError{
+	// 		Offset: start,
+	// 		What:   errors.New("empty integer value"),
+	// 	})
+	// }
+	return nil
+}
+
+// called when 'i' was consumed, for the integer type in v.
+func (d *Decoder) parseInt(v reflect.Value) error {
+	start := d.Offset - 1
+
+	if err := d.readInt(); err != nil {
+		return err
+	}
+	s := bytesAsString(d.buf.Bytes())
+
+	switch v.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		n, err := strconv.ParseInt(s, 10, 64)
+		checkForIntParseError(err, start)
+
+		if v.OverflowInt(n) {
+			return &UnmarshalTypeError{
+				BencodeTypeName:     "int",
+				UnmarshalTargetType: v.Type(),
+			}
+		}
+		v.SetInt(n)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		n, err := strconv.ParseUint(s, 10, 64)
+		checkForIntParseError(err, start)
+
+		if v.OverflowUint(n) {
+			return &UnmarshalTypeError{
+				BencodeTypeName:     "int",
+				UnmarshalTargetType: v.Type(),
+			}
+		}
+		v.SetUint(n)
+	case reflect.Bool:
+		v.SetBool(s != "0")
+	default:
+		return &UnmarshalTypeError{
+			BencodeTypeName:     "int",
+			UnmarshalTargetType: v.Type(),
+		}
+	}
+	d.buf.Reset()
+	return nil
+}
+
+func (d *Decoder) checkBufferedInt() error {
+	b := d.buf.Bytes()
+	if len(b) <= 1 {
+		return nil
+	}
+	if b[0] == '-' {
+		b = b[1:]
+	}
+	if b[0] < '1' || b[0] > '9' {
+		return errors.New("invalid leading digit")
+	}
+	return nil
+}
+
+func (d *Decoder) parseStringLength() (uint64, error) {
+	// We should have already consumed the first byte of the length into the Decoder buf.
+	start := d.Offset - 1
+	d.readUntil(':')
+	if err := d.checkBufferedInt(); err != nil {
+		return 0, err
+	}
+	// Really the limit should be the uint size for the platform. But we can't pass in an allocator,
+	// or limit total memory use in Go, the best we might hope to do is limit the size of a single
+	// decoded value (by reading it in in-place and then operating on a view).
+	length, err := strconv.ParseUint(bytesAsString(d.buf.Bytes()), 10, 0)
+	checkForIntParseError(err, start)
+	if int64(length) > d.getMaxStrLen() {
+		err = fmt.Errorf("parsed string length %v exceeds limit (%v)", length, DefaultDecodeMaxStrLen)
+	}
+	d.buf.Reset()
+	return length, err
+}
+
+func (d *Decoder) parseString(v reflect.Value) error {
+	length, err := d.parseStringLength()
+	if err != nil {
+		return err
+	}
+	defer d.buf.Reset()
+	read := func(b []byte) {
+		n, err := io.ReadFull(d.r, b)
+		d.Offset += int64(n)
+		if err != nil {
+			checkForUnexpectedEOF(err, d.Offset)
+			panic(&SyntaxError{
+				Offset: d.Offset,
+				What:   errors.New("unexpected I/O error: " + err.Error()),
+			})
+		}
+	}
+
+	switch v.Kind() {
+	case reflect.String:
+		b := make([]byte, length)
+		read(b)
+		v.SetString(bytesAsString(b))
+		return nil
+	case reflect.Slice:
+		if v.Type().Elem().Kind() != reflect.Uint8 {
+			break
+		}
+		b := make([]byte, length)
+		read(b)
+		v.SetBytes(b)
+		return nil
+	case reflect.Array:
+		if v.Type().Elem().Kind() != reflect.Uint8 {
+			break
+		}
+		d.buf.Grow(int(length))
+		b := d.buf.Bytes()[:length]
+		read(b)
+		reflect.Copy(v, reflect.ValueOf(b))
+		return nil
+	}
+	d.buf.Grow(int(length))
+	read(d.buf.Bytes()[:length])
+	// I believe we return here to support "ignore_unmarshal_type_error".
+	return &UnmarshalTypeError{
+		BencodeTypeName:     "string",
+		UnmarshalTargetType: v.Type(),
+	}
+}
+
+// Info for parsing a dict value.
+type dictField struct {
+	Type reflect.Type
+	Get  func(value reflect.Value) func(reflect.Value)
+	Tags tag
+}
+
+// Returns specifics for parsing a dict field value.
+func getDictField(dict reflect.Type, key string) (_ dictField, err error) {
+	// get valuev as a map value or as a struct field
+	switch k := dict.Kind(); k {
+	case reflect.Map:
+		return dictField{
+			Type: dict.Elem(),
+			Get: func(mapValue reflect.Value) func(reflect.Value) {
+				return func(value reflect.Value) {
+					if mapValue.IsNil() {
+						mapValue.Set(reflect.MakeMap(dict))
+					}
+					// Assigns the value into the map.
+					// log.Printf("map type: %v", mapValue.Type())
+					mapValue.SetMapIndex(reflect.ValueOf(key).Convert(dict.Key()), value)
+				}
+			},
+		}, nil
+	case reflect.Struct:
+		return getStructFieldForKey(dict, key), nil
+		// if sf.r.PkgPath != "" {
+		//	panic(&UnmarshalFieldError{
+		//		Key:   key,
+		//		Type:  dict.Type(),
+		//		Field: sf.r,
+		//	})
+		// }
+	default:
+		err = fmt.Errorf("can't assign bencode dict items into a %v", k)
+		return
+	}
+}
+
+var (
+	structFieldsMu sync.Mutex
+	structFields   = map[reflect.Type]map[string]dictField{}
+)
+
+func parseStructFields(struct_ reflect.Type, each func(key string, df dictField)) {
+	for _i, n := 0, struct_.NumField(); _i < n; _i++ {
+		i := _i
+		f := struct_.Field(i)
+		if f.Anonymous {
+			t := f.Type
+			if t.Kind() == reflect.Ptr {
+				t = t.Elem()
+			}
+			parseStructFields(t, func(key string, df dictField) {
+				innerGet := df.Get
+				df.Get = func(value reflect.Value) func(reflect.Value) {
+					anonPtr := value.Field(i)
+					if anonPtr.Kind() == reflect.Ptr && anonPtr.IsNil() {
+						anonPtr.Set(reflect.New(f.Type.Elem()))
+						anonPtr = anonPtr.Elem()
+					}
+					return innerGet(anonPtr)
+				}
+				each(key, df)
+			})
+			continue
+		}
+		tagStr := f.Tag.Get("bencode")
+		if tagStr == "-" {
+			continue
+		}
+		tag := parseTag(tagStr)
+		key := tag.Key()
+		if key == "" {
+			key = f.Name
+		}
+		each(key, dictField{f.Type, func(value reflect.Value) func(reflect.Value) {
+			return value.Field(i).Set
+		}, tag})
+	}
+}
+
+func saveStructFields(struct_ reflect.Type) {
+	m := make(map[string]dictField)
+	parseStructFields(struct_, func(key string, sf dictField) {
+		m[key] = sf
+	})
+	structFields[struct_] = m
+}
+
+func getStructFieldForKey(struct_ reflect.Type, key string) (f dictField) {
+	structFieldsMu.Lock()
+	if _, ok := structFields[struct_]; !ok {
+		saveStructFields(struct_)
+	}
+	f, ok := structFields[struct_][key]
+	structFieldsMu.Unlock()
+	if !ok {
+		var discard interface{}
+		return dictField{
+			Type: reflect.TypeOf(discard),
+			Get:  func(reflect.Value) func(reflect.Value) { return func(reflect.Value) {} },
+			Tags: nil,
+		}
+	}
+	return
+}
+
+func (d *Decoder) parseDict(v reflect.Value) error {
+	// At this point 'd' byte was consumed, now read key/value pairs
+	for {
+		var keyStr string
+		keyValue := reflect.ValueOf(&keyStr).Elem()
+		ok, err := d.parseValue(keyValue)
+		if err != nil {
+			return fmt.Errorf("error parsing dict key: %w", err)
+		}
+		if !ok {
+			return nil
+		}
+
+		df, err := getDictField(v.Type(), keyStr)
+		if err != nil {
+			return fmt.Errorf("parsing bencode dict into %v: %w", v.Type(), err)
+		}
+
+		// now we need to actually parse it
+		if df.Type == nil {
+			// Discard the value, there's nowhere to put it.
+			var if_ interface{}
+			if_, ok = d.parseValueInterface()
+			if if_ == nil {
+				return fmt.Errorf("error parsing value for key %q", keyStr)
+			}
+			if !ok {
+				return fmt.Errorf("missing value for key %q", keyStr)
+			}
+			continue
+		}
+		setValue := reflect.New(df.Type).Elem()
+		// log.Printf("parsing into %v", setValue.Type())
+		ok, err = d.parseValue(setValue)
+		if err != nil {
+			var target *UnmarshalTypeError
+			if !(errors.As(err, &target) && df.Tags.IgnoreUnmarshalTypeError()) {
+				return fmt.Errorf("parsing value for key %q: %w", keyStr, err)
+			}
+		}
+		if !ok {
+			return fmt.Errorf("missing value for key %q", keyStr)
+		}
+		df.Get(v)(setValue)
+	}
+}
+
+func (d *Decoder) parseList(v reflect.Value) error {
+	switch v.Kind() {
+	default:
+		// If the list is a singleton of the expected type, use that value. See
+		// https://github.com/anacrolix/torrent/issues/297.
+		l := reflect.New(reflect.SliceOf(v.Type()))
+		if err := d.parseList(l.Elem()); err != nil {
+			return err
+		}
+		if l.Elem().Len() != 1 {
+			return &UnmarshalTypeError{
+				BencodeTypeName:     "list",
+				UnmarshalTargetType: v.Type(),
+			}
+		}
+		v.Set(l.Elem().Index(0))
+		return nil
+	case reflect.Array, reflect.Slice:
+		// We can work with this. Normal case, fallthrough.
+	}
+
+	i := 0
+	for ; ; i++ {
+		if v.Kind() == reflect.Slice && i >= v.Len() {
+			v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
+		}
+
+		if i < v.Len() {
+			ok, err := d.parseValue(v.Index(i))
+			if err != nil {
+				return err
+			}
+			if !ok {
+				break
+			}
+		} else {
+			_, ok := d.parseValueInterface()
+			if !ok {
+				break
+			}
+		}
+	}
+
+	if i < v.Len() {
+		if v.Kind() == reflect.Array {
+			z := reflect.Zero(v.Type().Elem())
+			for n := v.Len(); i < n; i++ {
+				v.Index(i).Set(z)
+			}
+		} else {
+			v.SetLen(i)
+		}
+	}
+
+	if i == 0 && v.Kind() == reflect.Slice {
+		v.Set(reflect.MakeSlice(v.Type(), 0, 0))
+	}
+	return nil
+}
+
+func (d *Decoder) readOneValue() bool {
+	b, err := d.r.ReadByte()
+	if err != nil {
+		panic(err)
+	}
+	if b == 'e' {
+		d.r.UnreadByte()
+		return false
+	} else {
+		d.Offset++
+		d.buf.WriteByte(b)
+	}
+
+	switch b {
+	case 'd', 'l':
+		// read until there is nothing to read
+		for d.readOneValue() {
+		}
+		// consume 'e' as well
+		b = d.readByte()
+		d.buf.WriteByte(b)
+	case 'i':
+		d.readUntil('e')
+		d.buf.WriteString("e")
+	default:
+		if b >= '0' && b <= '9' {
+			start := d.buf.Len() - 1
+			d.readUntil(':')
+			length, err := strconv.ParseInt(bytesAsString(d.buf.Bytes()[start:]), 10, 64)
+			checkForIntParseError(err, d.Offset-1)
+
+			d.buf.WriteString(":")
+			n, err := io.CopyN(&d.buf, d.r, length)
+			d.Offset += n
+			if err != nil {
+				checkForUnexpectedEOF(err, d.Offset)
+				panic(&SyntaxError{
+					Offset: d.Offset,
+					What:   errors.New("unexpected I/O error: " + err.Error()),
+				})
+			}
+			break
+		}
+
+		d.raiseUnknownValueType(b, d.Offset-1)
+	}
+
+	return true
+}
+
+func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
+	if !v.Type().Implements(unmarshalerType) {
+		if v.Addr().Type().Implements(unmarshalerType) {
+			v = v.Addr()
+		} else {
+			return false
+		}
+	}
+	d.buf.Reset()
+	if !d.readOneValue() {
+		return false
+	}
+	m := v.Interface().(Unmarshaler)
+	err := m.UnmarshalBencode(d.buf.Bytes())
+	if err != nil {
+		panic(&UnmarshalerError{v.Type(), err})
+	}
+	return true
+}
+
+// Returns true if there was a value and it's now stored in 'v', otherwise
+// there was an end symbol ("e") and no value was stored.
+func (d *Decoder) parseValue(v reflect.Value) (bool, error) {
+	// we support one level of indirection at the moment
+	if v.Kind() == reflect.Ptr {
+		// if the pointer is nil, allocate a new element of the type it
+		// points to
+		if v.IsNil() {
+			v.Set(reflect.New(v.Type().Elem()))
+		}
+		v = v.Elem()
+	}
+
+	if d.parseUnmarshaler(v) {
+		return true, nil
+	}
+
+	// common case: interface{}
+	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
+		iface, _ := d.parseValueInterface()
+		v.Set(reflect.ValueOf(iface))
+		return true, nil
+	}
+
+	b, err := d.r.ReadByte()
+	if err != nil {
+		return false, err
+	}
+	d.Offset++
+
+	switch b {
+	case 'e':
+		return false, nil
+	case 'd':
+		return true, d.parseDict(v)
+	case 'l':
+		return true, d.parseList(v)
+	case 'i':
+		return true, d.parseInt(v)
+	default:
+		if b >= '0' && b <= '9' {
+			// It's a string.
+			d.buf.Reset()
+			// Write the first digit of the length to the buffer.
+			d.buf.WriteByte(b)
+			return true, d.parseString(v)
+		}
+
+		d.raiseUnknownValueType(b, d.Offset-1)
+	}
+	panic("unreachable")
+}
+
+// An unknown bencode type character was encountered.
+func (d *Decoder) raiseUnknownValueType(b byte, offset int64) {
+	panic(&SyntaxError{
+		Offset: offset,
+		What:   fmt.Errorf("unknown value type %+q", b),
+	})
+}
+
+func (d *Decoder) parseValueInterface() (interface{}, bool) {
+	b, err := d.r.ReadByte()
+	if err != nil {
+		panic(err)
+	}
+	d.Offset++
+
+	switch b {
+	case 'e':
+		return nil, false
+	case 'd':
+		return d.parseDictInterface(), true
+	case 'l':
+		return d.parseListInterface(), true
+	case 'i':
+		return d.parseIntInterface(), true
+	default:
+		if b >= '0' && b <= '9' {
+			// string
+			// append first digit of the length to the buffer
+			d.buf.WriteByte(b)
+			return d.parseStringInterface(), true
+		}
+
+		d.raiseUnknownValueType(b, d.Offset-1)
+		panic("unreachable")
+	}
+}
+
+// Called after 'i', for an arbitrary integer size.
+func (d *Decoder) parseIntInterface() (ret interface{}) {
+	start := d.Offset - 1
+
+	if err := d.readInt(); err != nil {
+		panic(err)
+	}
+	n, err := strconv.ParseInt(d.buf.String(), 10, 64)
+	if ne, ok := err.(*strconv.NumError); ok && ne.Err == strconv.ErrRange {
+		i := new(big.Int)
+		_, ok := i.SetString(d.buf.String(), 10)
+		if !ok {
+			panic(&SyntaxError{
+				Offset: start,
+				What:   errors.New("failed to parse integer"),
+			})
+		}
+		ret = i
+	} else {
+		checkForIntParseError(err, start)
+		ret = n
+	}
+
+	d.buf.Reset()
+	return
+}
+
+func (d *Decoder) readBytes(length int) []byte {
+	b, err := io.ReadAll(io.LimitReader(d.r, int64(length)))
+	if err != nil {
+		panic(err)
+	}
+	if len(b) != length {
+		panic(fmt.Errorf("read %v bytes expected %v", len(b), length))
+	}
+	return b
+}
+
+func (d *Decoder) parseStringInterface() string {
+	length, err := d.parseStringLength()
+	if err != nil {
+		panic(err)
+	}
+	b := d.readBytes(int(length))
+	d.Offset += int64(len(b))
+	if err != nil {
+		panic(&SyntaxError{Offset: d.Offset, What: err})
+	}
+	return bytesAsString(b)
+}
+
+func (d *Decoder) parseDictInterface() interface{} {
+	dict := make(map[string]interface{})
+	var lastKey string
+	lastKeyOk := false
+	for {
+		start := d.Offset
+		keyi, ok := d.parseValueInterface()
+		if !ok {
+			break
+		}
+
+		key, ok := keyi.(string)
+		if !ok {
+			panic(&SyntaxError{
+				Offset: d.Offset,
+				What:   errors.New("non-string key in a dict"),
+			})
+		}
+		if lastKeyOk && key <= lastKey {
+			d.throwSyntaxError(start, fmt.Errorf("dict keys unsorted: %q <= %q", key, lastKey))
+		}
+		start = d.Offset
+		valuei, ok := d.parseValueInterface()
+		if !ok {
+			d.throwSyntaxError(start, fmt.Errorf("dict elem missing value [key=%v]", key))
+		}
+
+		lastKey = key
+		lastKeyOk = true
+		dict[key] = valuei
+	}
+	return dict
+}
+
+func (d *Decoder) parseListInterface() (list []interface{}) {
+	list = []interface{}{}
+	valuei, ok := d.parseValueInterface()
+	for ok {
+		list = append(list, valuei)
+		valuei, ok = d.parseValueInterface()
+	}
+	return
+}
+
+func (d *Decoder) getMaxStrLen() int64 {
+	if d.MaxStrLen == 0 {
+		return DefaultDecodeMaxStrLen
+	}
+	return d.MaxStrLen
+}

vendor/github.com/anacrolix/torrent/bencode/encode.go

@@ -0,0 +1,293 @@
+package bencode
+
+import (
+	"io"
+	"math/big"
+	"reflect"
+	"runtime"
+	"sort"
+	"strconv"
+	"sync"
+
+	"github.com/anacrolix/missinggo"
+)
+
+func isEmptyValue(v reflect.Value) bool {
+	return missinggo.IsEmptyValue(v)
+}
+
+type Encoder struct {
+	w       io.Writer
+	scratch [64]byte
+}
+
+func (e *Encoder) Encode(v interface{}) (err error) {
+	if v == nil {
+		return
+	}
+	defer func() {
+		if e := recover(); e != nil {
+			if _, ok := e.(runtime.Error); ok {
+				panic(e)
+			}
+			var ok bool
+			err, ok = e.(error)
+			if !ok {
+				panic(e)
+			}
+		}
+	}()
+	e.reflectValue(reflect.ValueOf(v))
+	return nil
+}
+
+type stringValues []reflect.Value
+
+func (sv stringValues) Len() int           { return len(sv) }
+func (sv stringValues) Swap(i, j int)      { sv[i], sv[j] = sv[j], sv[i] }
+func (sv stringValues) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
+func (sv stringValues) get(i int) string   { return sv[i].String() }
+
+func (e *Encoder) write(s []byte) {
+	_, err := e.w.Write(s)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (e *Encoder) writeString(s string) {
+	for s != "" {
+		n := copy(e.scratch[:], s)
+		s = s[n:]
+		e.write(e.scratch[:n])
+	}
+}
+
+func (e *Encoder) reflectString(s string) {
+	e.writeStringPrefix(int64(len(s)))
+	e.writeString(s)
+}
+
+func (e *Encoder) writeStringPrefix(l int64) {
+	b := strconv.AppendInt(e.scratch[:0], l, 10)
+	e.write(b)
+	e.writeString(":")
+}
+
+func (e *Encoder) reflectByteSlice(s []byte) {
+	e.writeStringPrefix(int64(len(s)))
+	e.write(s)
+}
+
+// Returns true if the value implements Marshaler interface and marshaling was
+// done successfully.
+func (e *Encoder) reflectMarshaler(v reflect.Value) bool {
+	if !v.Type().Implements(marshalerType) {
+		if v.Kind() != reflect.Ptr && v.CanAddr() && v.Addr().Type().Implements(marshalerType) {
+			v = v.Addr()
+		} else {
+			return false
+		}
+	}
+	m := v.Interface().(Marshaler)
+	data, err := m.MarshalBencode()
+	if err != nil {
+		panic(&MarshalerError{v.Type(), err})
+	}
+	e.write(data)
+	return true
+}
+
+var bigIntType = reflect.TypeOf((*big.Int)(nil)).Elem()
+
+func (e *Encoder) reflectValue(v reflect.Value) {
+	if e.reflectMarshaler(v) {
+		return
+	}
+
+	if v.Type() == bigIntType {
+		e.writeString("i")
+		bi := v.Interface().(big.Int)
+		e.writeString(bi.String())
+		e.writeString("e")
+		return
+	}
+
+	switch v.Kind() {
+	case reflect.Bool:
+		if v.Bool() {
+			e.writeString("i1e")
+		} else {
+			e.writeString("i0e")
+		}
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		e.writeString("i")
+		b := strconv.AppendInt(e.scratch[:0], v.Int(), 10)
+		e.write(b)
+		e.writeString("e")
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		e.writeString("i")
+		b := strconv.AppendUint(e.scratch[:0], v.Uint(), 10)
+		e.write(b)
+		e.writeString("e")
+	case reflect.String:
+		e.reflectString(v.String())
+	case reflect.Struct:
+		e.writeString("d")
+		for _, ef := range getEncodeFields(v.Type()) {
+			fieldValue := ef.i(v)
+			if !fieldValue.IsValid() {
+				continue
+			}
+			if ef.omitEmpty && isEmptyValue(fieldValue) {
+				continue
+			}
+			e.reflectString(ef.tag)
+			e.reflectValue(fieldValue)
+		}
+		e.writeString("e")
+	case reflect.Map:
+		if v.Type().Key().Kind() != reflect.String {
+			panic(&MarshalTypeError{v.Type()})
+		}
+		if v.IsNil() {
+			e.writeString("de")
+			break
+		}
+		e.writeString("d")
+		sv := stringValues(v.MapKeys())
+		sort.Sort(sv)
+		for _, key := range sv {
+			e.reflectString(key.String())
+			e.reflectValue(v.MapIndex(key))
+		}
+		e.writeString("e")
+	case reflect.Slice, reflect.Array:
+		e.reflectSequence(v)
+	case reflect.Interface:
+		e.reflectValue(v.Elem())
+	case reflect.Ptr:
+		if v.IsNil() {
+			v = reflect.Zero(v.Type().Elem())
+		} else {
+			v = v.Elem()
+		}
+		e.reflectValue(v)
+	default:
+		panic(&MarshalTypeError{v.Type()})
+	}
+}
+
+func (e *Encoder) reflectSequence(v reflect.Value) {
+	// Use bencode string-type
+	if v.Type().Elem().Kind() == reflect.Uint8 {
+		if v.Kind() != reflect.Slice {
+			// Can't use []byte optimization
+			if !v.CanAddr() {
+				e.writeStringPrefix(int64(v.Len()))
+				for i := 0; i < v.Len(); i++ {
+					var b [1]byte
+					b[0] = byte(v.Index(i).Uint())
+					e.write(b[:])
+				}
+				return
+			}
+			v = v.Slice(0, v.Len())
+		}
+		s := v.Bytes()
+		e.reflectByteSlice(s)
+		return
+	}
+	if v.IsNil() {
+		e.writeString("le")
+		return
+	}
+	e.writeString("l")
+	for i, n := 0, v.Len(); i < n; i++ {
+		e.reflectValue(v.Index(i))
+	}
+	e.writeString("e")
+}
+
+type encodeField struct {
+	i         func(v reflect.Value) reflect.Value
+	tag       string
+	omitEmpty bool
+}
+
+type encodeFieldsSortType []encodeField
+
+func (ef encodeFieldsSortType) Len() int           { return len(ef) }
+func (ef encodeFieldsSortType) Swap(i, j int)      { ef[i], ef[j] = ef[j], ef[i] }
+func (ef encodeFieldsSortType) Less(i, j int) bool { return ef[i].tag < ef[j].tag }
+
+var (
+	typeCacheLock     sync.RWMutex
+	encodeFieldsCache = make(map[reflect.Type][]encodeField)
+)
+
+func getEncodeFields(t reflect.Type) []encodeField {
+	typeCacheLock.RLock()
+	fs, ok := encodeFieldsCache[t]
+	typeCacheLock.RUnlock()
+	if ok {
+		return fs
+	}
+	fs = makeEncodeFields(t)
+	typeCacheLock.Lock()
+	defer typeCacheLock.Unlock()
+	encodeFieldsCache[t] = fs
+	return fs
+}
+
+func makeEncodeFields(t reflect.Type) (fs []encodeField) {
+	for _i, n := 0, t.NumField(); _i < n; _i++ {
+		i := _i
+		f := t.Field(i)
+		if f.PkgPath != "" {
+			continue
+		}
+		if f.Anonymous {
+			t := f.Type
+			if t.Kind() == reflect.Ptr {
+				t = t.Elem()
+			}
+			anonEFs := makeEncodeFields(t)
+			for aefi := range anonEFs {
+				anonEF := anonEFs[aefi]
+				bottomField := anonEF
+				bottomField.i = func(v reflect.Value) reflect.Value {
+					v = v.Field(i)
+					if v.Kind() == reflect.Ptr {
+						if v.IsNil() {
+							// This will skip serializing this value.
+							return reflect.Value{}
+						}
+						v = v.Elem()
+					}
+					return anonEF.i(v)
+				}
+				fs = append(fs, bottomField)
+			}
+			continue
+		}
+		var ef encodeField
+		ef.i = func(v reflect.Value) reflect.Value {
+			return v.Field(i)
+		}
+		ef.tag = f.Name
+
+		tv := getTag(f.Tag)
+		if tv.Ignore() {
+			continue
+		}
+		if tv.Key() != "" {
+			ef.tag = tv.Key()
+		}
+		ef.omitEmpty = tv.OmitEmpty()
+		fs = append(fs, ef)
+	}
+	fss := encodeFieldsSortType(fs)
+	sort.Sort(fss)
+	return fs
+}

vendor/github.com/anacrolix/torrent/bencode/misc.go

@@ -0,0 +1,16 @@
+package bencode
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// Wow Go is retarded.
+var (
+	marshalerType   = reflect.TypeOf((*Marshaler)(nil)).Elem()
+	unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
+)
+
+func bytesAsString(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}

vendor/github.com/anacrolix/torrent/bencode/scanner.go

@@ -0,0 +1,38 @@
+package bencode
+
+import (
+	"errors"
+	"io"
+)
+
+// Implements io.ByteScanner over io.Reader, for use in Decoder, to ensure
+// that as little as the undecoded input Reader is consumed as possible.
+type scanner struct {
+	r      io.Reader
+	b      [1]byte // Buffer for ReadByte
+	unread bool    // True if b has been unread, and so should be returned next
+}
+
+func (me *scanner) Read(b []byte) (int, error) {
+	return me.r.Read(b)
+}
+
+func (me *scanner) ReadByte() (byte, error) {
+	if me.unread {
+		me.unread = false
+		return me.b[0], nil
+	}
+	n, err := me.r.Read(me.b[:])
+	if n == 1 {
+		err = nil
+	}
+	return me.b[0], err
+}
+
+func (me *scanner) UnreadByte() error {
+	if me.unread {
+		return errors.New("byte already unread")
+	}
+	me.unread = true
+	return nil
+}

vendor/github.com/anacrolix/torrent/bencode/tags.go

@@ -0,0 +1,44 @@
+package bencode
+
+import (
+	"reflect"
+	"strings"
+)
+
+func getTag(st reflect.StructTag) tag {
+	return parseTag(st.Get("bencode"))
+}
+
+type tag []string
+
+func parseTag(tagStr string) tag {
+	return strings.Split(tagStr, ",")
+}
+
+func (me tag) Ignore() bool {
+	return me[0] == "-"
+}
+
+func (me tag) Key() string {
+	return me[0]
+}
+
+func (me tag) HasOpt(opt string) bool {
+	if len(me) < 1 {
+		return false
+	}
+	for _, s := range me[1:] {
+		if s == opt {
+			return true
+		}
+	}
+	return false
+}
+
+func (me tag) OmitEmpty() bool {
+	return me.HasOpt("omitempty")
+}
+
+func (me tag) IgnoreUnmarshalTypeError() bool {
+	return me.HasOpt("ignore_unmarshal_type_error")
+}