bencode

README

go-bencode

Decoding and encoding bencode.

Support All go type including map/slice/struct/array, and simple type like bool/int/uint/string/....

float32 and float64 are not supported, bencode doesn't have this type.

Encoding and decoding some type from standard library like time.Time, net.IP are not supported. If you have any thought about how to support these types, please create an issue.

Or you can wrap these types and implement bencode.Marshaler or bencode.Unmarshaler

Supported and tested go version

• 1.22

Install

go get github.com/trim21/go-bencode

Usage

See examples

Marshal

If you want to encode customize type as struct field with omitempty, do implement both bencode.Marshaler and bencode.IsZeroValue, so encoder could know if it's a empty value and skip fields.

Bencode doesn't have null type, so all struct field with pointer type(*T) will get omitempty by default.

Unmarshal

go any type will be decoded as map[string]any, []any, int64 or string.

[]uint8([]byte) and [N]uint8([N]byte) will be decoded as bencode string.

Decode Go string may not be valid utf8 string.

Go Array will be decoded with size check. Only bencode string/list with same length are valid, otherwise it will return a error.

Note

go reflect package allow you to create dynamic struct with reflect.StructOf, but please use it with caution.

For performance, this package will try to "compile" input type to a static encoder/decoder at first time and cache it for future use.

So a dynamic struct may cause memory leak.

License

MIT License

Documentation

Index

• func AppendBytes(b []byte, s []byte) []byte
• func AppendInt(b []byte, i int64) []byte
• func AppendStr(b []byte, s string) []byte
• func Marshal(v any) ([]byte, error)
• func Unmarshal(data []byte, v any) error
• type Encoder
  • func NewEncoder(w io.Writer) *Encoder
  • func (e *Encoder) Encode(v any) error
• type IsZeroValue
• type Marshaler
• type RawBytes
  • func (b RawBytes) IsZeroBencodeValue() bool
  • func (b RawBytes) MarshalBencode() ([]byte, error)
  • func (b *RawBytes) UnmarshalBencode(bytes []byte) error
• type Unmarshaler

Examples

• Marshal
• Unmarshal

Functions

func AppendBytes

func AppendBytes(b []byte, s []byte) []byte

func AppendInt

func AppendInt(b []byte, i int64) []byte

func AppendStr

func AppendStr(b []byte, s string) []byte

func Marshal

func Marshal(v any) ([]byte, error)

Example

type User struct {
	ID   uint32 `bencode:"id,string"`
	Name string `bencode:"name"`
}

type Inner struct {
	V int    `bencode:"v"`
	S string `bencode:"a long string name replace field name"`
}

type With struct {
	Users   []User `bencode:"users,omitempty"`
	Obj     Inner  `bencode:"obj"`
	Ignored bool   `bencode:"-"`
}

var data = With{
	Users: []User{
		{ID: 1, Name: "sai"},
		{ID: 2, Name: "trim21"},
	},
	Obj: Inner{V: 2, S: "vvv"},
}
var b, err = bencode.Marshal(data)
if err != nil {
	panic(err)
}

fmt.Println(string(b))

Output:

d3:objd37:a long string name replace field name3:vvv1:vi2ee5:usersld2:idi1e4:name3:saied2:idi2e4:name6:trim21eee

func Unmarshal

func Unmarshal(data []byte, v any) error

Example

var v struct {
	S     map[[20]byte]struct{} `bencode:"s"`
	Value map[string]string     `bencode:"value" json:"value"`
}
raw := `d5:valued4:five1:5ee`

err := bencode.Unmarshal([]byte(raw), &v)
if err != nil {
	panic(err)
}

fmt.Println(v.Value["five"])

Output:

5

Types

type Encoder

type Encoder struct {
	// contains filtered or unexported fields
}

func NewEncoder

func NewEncoder(w io.Writer) *Encoder

func (*Encoder) Encode

func (e *Encoder) Encode(v any) error

type IsZeroValue

type IsZeroValue interface {
	// IsZeroBencodeValue enable support for omitempty feature.
	// if it's being used as struct field, and it returns true, this field will be skipped.
	IsZeroBencodeValue() bool
}

IsZeroValue add support type implements Marshaler and omitempty

var s struct {
	Field T `bencode:"field,omitempty"`
}

if `T` implements Marshaler, it can implement IsZeroValue so bencode know if it's

type Marshaler

type Marshaler interface {
	MarshalBencode() ([]byte, error)
}

Marshaler allow users to implement its own encoder.

type RawBytes

type RawBytes []byte

func (RawBytes) IsZeroBencodeValue

func (b RawBytes) IsZeroBencodeValue() bool

func (RawBytes) MarshalBencode

func (b RawBytes) MarshalBencode() ([]byte, error)

func (*RawBytes) UnmarshalBencode

func (b *RawBytes) UnmarshalBencode(bytes []byte) error

type Unmarshaler

type Unmarshaler interface {
	UnmarshalBencode([]byte) error
}