From a68e4a6f5ac0efe40c43bb0f34e50db527d59deb Mon Sep 17 00:00:00 2001
From: nsf <no.smile.face@gmail.com>
Date: Wed, 20 Jun 2012 19:21:32 +0600
Subject: [PATCH 1/1] Initial commit.
---
README | 1 +
bencode/README | 1 +
...nux-2011.08.19-netinstall-i686.iso.torrent | Bin 0 -> 12792 bytes
bencode/api.go | 100 ++++
bencode/both_test.go | 77 +++
bencode/decode.go | 491 ++++++++++++++++++
bencode/decode_test.go | 34 ++
bencode/encode.go | 205 ++++++++
bencode/encode_test.go | 53 ++
bencode/tags.go | 34 ++
10 files changed, 996 insertions(+)
create mode 100644 README
create mode 100644 bencode/README
create mode 100644 bencode/_testdata/archlinux-2011.08.19-netinstall-i686.iso.torrent
create mode 100644 bencode/api.go
create mode 100644 bencode/both_test.go
create mode 100644 bencode/decode.go
create mode 100644 bencode/decode_test.go
create mode 100644 bencode/encode.go
create mode 100644 bencode/encode_test.go
create mode 100644 bencode/tags.go
diff --git a/README b/README
new file mode 100644
index 00000000..ce8fac90
--- /dev/null
+++ b/README
@@ -0,0 +1 @@
+BitTorrent Go library, work in progress..
\ No newline at end of file
diff --git a/bencode/README b/bencode/README
new file mode 100644
index 00000000..440bd5f7
--- /dev/null
+++ b/bencode/README
@@ -0,0 +1 @@
+Bencode encoding/decoding sub package. Uses similar API design to Go's json package.
diff --git a/bencode/_testdata/archlinux-2011.08.19-netinstall-i686.iso.torrent b/bencode/_testdata/archlinux-2011.08.19-netinstall-i686.iso.torrent
new file mode 100644
index 0000000000000000000000000000000000000000..9ce7748aaa46f90aa56c29699b763896fc08af91
GIT binary patch
literal 12792
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%0D*f1Euc8hO)={iLER+R%jSr
zbL?P%?sN9biGTMOc+jTymO*29v25GHp=j6tnmOR_rn-m6z@fahu>T1C$DoHn9ibNX
z*eg~Ttn+(w<M{o>|66S+C>rVr;r+R1z*4xk%+XRhVD3;6zmtWr72MC&5y+vddr^YH
z01N^QutNS)7wV7Q>%i4LI2?@u?ScPG+dJsddq4zwe;#0=f9jS8_I}0%0Hd(lfTC@&
zqXDatW7P0Bd)5%po(iGAs|fYyGCFJlzbs>k+#h)WDD1zc^LH-nkqA2owv_*{c{^;`
zdmPz-u(M__OdI=sdun_40{LXIqwVLPjwDv-pmiK-!PfPtV*b$%T@Y|9bA;{jWi5P=
zg~PS25C{tt!V(RDIUY44e6ZI(eEb)Q`+G?k<{yXyA^#@Z8r%B-b{7AhV3C6a|6*C_
zznudPX!>Od4*QRj1b9HgzVu-jj1>U>Qwj(a-_M-vZx4>~`CuP$NDLf=L1Tv?01p0l
z+~Iuv<@8_Rh@)Hr54g04BG5=%#D13c#@$|-{vzvt(f?k!NGwfza>Srv0Q*0jTSN{T
z=`UjdkOkH}8Un*^zU=_W<MyXVlKPiPcP#86<b7Wed)wf>fPV*jNY~yO@krr_9GzKC
z2qX-fNPyijgZk)j1h|0U77*;9#~hQzzj<l<yS#0Y|6bIG9RY=bV+R5RfP`2;kyz&-
zsNWlcgW&!V*by>O!vAB1?2!p`L4mM$ivchw20P4;Z+yT5gL_DO1QHFyw%vpIhpm!7
zbo)b{9|Q%k$GEy;%L8ovkMItPX@6DhWWd(YuQM0g>EF|E*w|6lAPa;Oc8pkHCmG`B
zY3*3#fyKS}(6$GNpT#fxZ>{-IEc=Z9z6TCKAG3Y``<(t6p)C~R2*7~;%QO%^aP^Q$
z6viF}`FUzPQUZq#f<d;}oi)@Pd*0fAH*yS(2g&|j<zNsRU~l2PcL+TOcC^~CH^>2w
zf3kHjQ1;HdR_Hwkt*|c*z}EZ5j@?`xZVP|<2>`*tFzm+M2?T}iqyM1Ef6N(y|5imu
z=@I-NVKD4?vHL0Kzp#lFkR=8N`$sJtWz`O`|Njn-e<k*}4Ko6TL0}KFdx&HCJRI)7
z_(cBiN<m`KRuJrqyW^E|WKyHBFFKqB0BCE76&QxVo@#!-kKy|V8%K};7YGc7aI%DA
VPZNLG==@`J?ajPn-i<&Y{|9GpPwD^w
literal 0
HcmV?d00001
diff --git a/bencode/api.go b/bencode/api.go
new file mode 100644
index 00000000..ce94f240
--- /dev/null
+++ b/bencode/api.go
@@ -0,0 +1,100 @@
+package bencode
+
+import "bytes"
+import "bufio"
+import "reflect"
+import "strconv"
+
+// In case if marshaler cannot encode a type in bencode, 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 (this *MarshalTypeError) Error() string {
+ return "bencode: unsupported type: " + this.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 specific Go
+// value
+type UnmarshalTypeError struct {
+ Value string
+ Type reflect.Type
+}
+
+func (e *UnmarshalTypeError) Error() string {
+ return "bencode: value (" + e.Value + ") is not appropriate for type: " +
+ e.Type.String()
+}
+
+// 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()
+}
+
+type SyntaxError struct {
+ Offset int64 // location of the error
+ what string // error description
+}
+
+func (e *SyntaxError) Error() string {
+ return "bencode: syntax error (offset: " +
+ strconv.FormatInt(e.Offset, 10) +
+ "): " + e.what
+}
+
+func Marshal(v interface{}) ([]byte, error) {
+ var buf bytes.Buffer
+ e := encoder{Writer: bufio.NewWriter(&buf)}
+ err := e.encode(v)
+ if err != nil {
+ return nil, err
+ }
+ err = e.Flush()
+ return buf.Bytes(), err
+}
+
+type Marshaler interface {
+ MarshalBencode() ([]byte, error)
+}
+
+func Unmarshal(data []byte, v interface{}) error {
+ e := decoder{Reader: bufio.NewReader(bytes.NewBuffer(data))}
+ return e.decode(v)
+}
+
+/*
+func Unmarshal(data []byte, v interface{}) error
+
+type Decoder int
+func NewDecoder(r io.Reader) *Decoder
+func (dec *Decoder) Decode(v interface{}) error
+
+type Encoder int
+func NewEncoder(w io.Writer) *Encoder
+func (enc *Encoder) Encode(v interface{}) error
+*/
diff --git a/bencode/both_test.go b/bencode/both_test.go
new file mode 100644
index 00000000..837e6115
--- /dev/null
+++ b/bencode/both_test.go
@@ -0,0 +1,77 @@
+package bencode
+
+import "testing"
+import "bytes"
+import "io/ioutil"
+import "time"
+
+func load_file(name string, t *testing.T) []byte {
+ data, err := ioutil.ReadFile(name)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return data
+}
+
+func TestBothInterface(t *testing.T) {
+ data1 := load_file("_testdata/archlinux-2011.08.19-netinstall-i686.iso.torrent", t)
+ var iface interface{}
+
+ err := Unmarshal(data1, &iface)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ data2, err := Marshal(iface)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if !bytes.Equal(data1, data2) {
+ t.Fatalf("equality expected\n")
+ }
+}
+
+type torrent_file struct {
+ Info struct {
+ Name string `bencode:"name"`
+ Length int64 `bencode:"length"`
+ MD5Sum string `bencode:"md5sum,omitempty"`
+ PieceLength int64 `bencode:"piece length"`
+ Pieces string `bencode:"pieces"`
+ Private bool `bencode:"private,omitempty"`
+ } `bencode:"info"`
+
+ Announce string `bencode:"announce"`
+ AnnounceList [][]string `bencode:"announce-list,omitempty"`
+ CreationDate int64 `bencode:"creation date,omitempty"`
+ Comment string `bencode:"comment,omitempty"`
+ CreatedBy string `bencode:"created by,omitempty"`
+ URLList interface{} `bencode:"url-list,omitempty"`
+}
+
+func TestBoth(t *testing.T) {
+ data1 := load_file("_testdata/archlinux-2011.08.19-netinstall-i686.iso.torrent", t)
+ var f torrent_file
+
+ err := Unmarshal(data1, &f)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ t.Logf("Name: %s\n", f.Info.Name)
+ t.Logf("Length: %v bytes\n", f.Info.Length)
+ t.Logf("Announce: %s\n", f.Announce)
+ t.Logf("CreationDate: %s\n", time.Unix(f.CreationDate, 0).String())
+ t.Logf("CreatedBy: %s\n", f.CreatedBy)
+ t.Logf("Comment: %s\n", f.Comment)
+
+ data2, err := Marshal(&f)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ if !bytes.Equal(data1, data2) {
+ t.Fatalf("equality expected")
+ }
+}
diff --git a/bencode/decode.go b/bencode/decode.go
new file mode 100644
index 00000000..0479cf8e
--- /dev/null
+++ b/bencode/decode.go
@@ -0,0 +1,491 @@
+package bencode
+
+import "reflect"
+import "runtime"
+import "bufio"
+import "bytes"
+import "strconv"
+import "strings"
+import "io"
+
+type decoder struct {
+ *bufio.Reader
+ offset int64
+ buf bytes.Buffer
+ key string
+}
+
+func (d *decoder) decode(v interface{}) (err error) {
+ var _ runtime.Error
+ /*
+ defer func() {
+ if e := recover(); e != nil {
+ if _, ok := e.(runtime.Error); ok {
+ panic(e)
+ }
+ err = e.(error)
+ }
+ }()
+ */
+
+ pv := reflect.ValueOf(v)
+ if pv.Kind() != reflect.Ptr || pv.IsNil() {
+ return &UnmarshalInvalidArgError{reflect.TypeOf(v)}
+ }
+
+ d.parse_value(pv.Elem())
+ return nil
+}
+
+func check_for_unexpected_eof(err error, offset int64) {
+ if err == io.EOF {
+ panic(&SyntaxError{
+ Offset: offset,
+ what: "unexpected EOF",
+ })
+ }
+}
+
+func (d *decoder) read_byte() byte {
+ b, err := d.ReadByte()
+ if err != nil {
+ check_for_unexpected_eof(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) read_until(sep byte) {
+ for {
+ b := d.read_byte()
+ if b == sep {
+ return
+ }
+ d.buf.WriteByte(b)
+ }
+}
+
+func check_for_int_parse_error(err error, offset int64) {
+ if err != nil {
+ panic(&SyntaxError{
+ Offset: offset,
+ what: err.Error(),
+ })
+ }
+}
+
+// called when 'i' was consumed
+func (d *decoder) parse_int(v reflect.Value) {
+ start := d.offset - 1
+ d.read_until('e')
+ if d.buf.Len() == 0 {
+ panic(&SyntaxError{
+ Offset: start,
+ what: "empty integer value",
+ })
+ }
+
+ switch v.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ n, err := strconv.ParseInt(d.buf.String(), 10, 64)
+ check_for_int_parse_error(err, start)
+
+ if v.OverflowInt(n) {
+ panic(&UnmarshalTypeError{
+ Value: "integer " + d.buf.String(),
+ Type: v.Type(),
+ })
+ }
+ v.SetInt(n)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ n, err := strconv.ParseUint(d.buf.String(), 10, 64)
+ check_for_int_parse_error(err, start)
+
+ if v.OverflowUint(n) {
+ panic(&UnmarshalTypeError{
+ Value: "integer " + d.buf.String(),
+ Type: v.Type(),
+ })
+ }
+ v.SetUint(n)
+ case reflect.Bool:
+ if d.buf.Len() == 1 && d.buf.Bytes()[0] == '0' {
+ v.SetBool(false)
+ }
+ v.SetBool(true)
+ default:
+ panic(&UnmarshalTypeError{
+ Value: "integer " + d.buf.String(),
+ Type: v.Type(),
+ })
+ }
+ d.buf.Reset()
+}
+
+func (d *decoder) parse_string(v reflect.Value) {
+ start := d.offset - 1
+
+ // read the string length first
+ d.read_until(':')
+ length, err := strconv.ParseInt(d.buf.String(), 10, 64)
+ check_for_int_parse_error(err, start)
+
+ d.buf.Reset()
+ n, err := io.CopyN(&d.buf, d, length)
+ d.offset += n
+ if err != nil {
+ check_for_unexpected_eof(err, d.offset)
+ panic(&SyntaxError{
+ Offset: d.offset,
+ what: "unexpected I/O error: " + err.Error(),
+ })
+ }
+
+ switch v.Kind() {
+ case reflect.String:
+ v.SetString(d.buf.String())
+ case reflect.Slice:
+ if v.Type().Elem().Kind() != reflect.Uint8 {
+ panic(&UnmarshalTypeError{
+ Value: "string",
+ Type: v.Type(),
+ })
+ }
+ v.Set(reflect.ValueOf(d.buf.Bytes()))
+ default:
+ panic(&UnmarshalTypeError{
+ Value: "string",
+ Type: v.Type(),
+ })
+ }
+
+ d.buf.Reset()
+}
+
+func (d *decoder) parse_dict(v reflect.Value) {
+ switch v.Kind() {
+ case reflect.Map:
+ t := v.Type()
+ if t.Key().Kind() != reflect.String {
+ panic(&UnmarshalTypeError{
+ Value: "object",
+ Type: t,
+ })
+ }
+ if v.IsNil() {
+ v.Set(reflect.MakeMap(t))
+ }
+ case reflect.Struct:
+ default:
+ panic(&UnmarshalTypeError{
+ Value: "object",
+ Type: v.Type(),
+ })
+ }
+
+ var map_elem reflect.Value
+
+ // so, at this point 'd' byte was consumed, let's just read key/value
+ // pairs one by one
+ for {
+ var valuev reflect.Value
+ keyv := reflect.ValueOf(&d.key).Elem()
+ if !d.parse_value(keyv) {
+ return
+ }
+
+ // get valuev as a map value or as a struct field
+ switch v.Kind() {
+ case reflect.Map:
+ elem_type := v.Type().Elem()
+ if !map_elem.IsValid() {
+ map_elem = reflect.New(elem_type).Elem()
+ } else {
+ map_elem.Set(reflect.Zero(elem_type))
+ }
+ valuev = map_elem
+ case reflect.Struct:
+ var f reflect.StructField
+ var ok bool
+
+ t := v.Type()
+ for i, n := 0, t.NumField(); i < n; i++ {
+ f = t.Field(i)
+ tag := f.Tag.Get("bencode")
+ if tag == "-" {
+ continue
+ }
+ if f.Anonymous {
+ continue
+ }
+
+ tag_name, _ := parse_tag(tag)
+ if tag_name == d.key {
+ ok = true
+ break
+ }
+
+ if f.Name == d.key {
+ ok = true
+ break
+ }
+
+ if strings.EqualFold(f.Name, d.key) {
+ ok = true
+ break
+ }
+ }
+
+ if ok {
+ if f.PkgPath != "" {
+ panic(&UnmarshalFieldError{
+ Key: d.key,
+ Type: v.Type(),
+ Field: f,
+ })
+ } else {
+ valuev = v.FieldByIndex(f.Index)
+ }
+ } else {
+ _, ok := d.parse_value_interface()
+ if !ok {
+ panic(&SyntaxError{
+ Offset: d.offset,
+ what: "unexpected end of dict, no matching value for a given key",
+ })
+ }
+ continue
+ }
+ }
+
+ // now we need to actually parse it
+ if !d.parse_value(valuev) {
+ panic(&SyntaxError{
+ Offset: d.offset,
+ what: "unexpected end of dict, no matching value for a given key",
+ })
+ }
+
+ if v.Kind() == reflect.Map {
+ v.SetMapIndex(keyv, valuev)
+ }
+ }
+}
+
+func (d *decoder) parse_list(v reflect.Value) {
+ switch v.Kind() {
+ case reflect.Array, reflect.Slice:
+ default:
+ panic(&UnmarshalTypeError{
+ Value: "array",
+ Type: v.Type(),
+ })
+ }
+
+ i := 0
+ for {
+ if v.Kind() == reflect.Slice && i >= v.Len() {
+ v.Set(reflect.Append(v, reflect.Zero(v.Type().Elem())))
+ }
+
+ ok := false
+ if i < v.Len() {
+ ok = d.parse_value(v.Index(i))
+ } else {
+ _, ok = d.parse_value_interface()
+ }
+
+ if !ok {
+ break
+ }
+
+ i++
+ }
+
+ 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))
+ }
+}
+
+// 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) parse_value(v reflect.Value) bool {
+ if pv := v; pv.Kind() == reflect.Ptr {
+ // if the pointer is nil, allocate a new element of the type it
+ // points to
+ if pv.IsNil() {
+ pv.Set(reflect.New(pv.Type().Elem()))
+ }
+ v = pv.Elem()
+ }
+
+ // common case
+ if v.Kind() == reflect.Interface {
+ iface, _ := d.parse_value_interface()
+ v.Set(reflect.ValueOf(iface))
+ return true
+ }
+
+ b, err := d.ReadByte()
+ if err != nil {
+ panic(err)
+ }
+ d.offset++
+
+ switch b {
+ case 'e':
+ return false
+ case 'd':
+ d.parse_dict(v)
+ case 'l':
+ d.parse_list(v)
+ case 'i':
+ d.parse_int(v)
+ default:
+ if b >= '0' && b <= '9' {
+ // string
+ // append first digit of the length to the buffer
+ d.buf.WriteByte(b)
+ d.parse_string(v)
+ break
+ }
+
+ // unknown value
+ panic(&SyntaxError{
+ Offset: d.offset - 1,
+ what: "unknown value type (invalid bencode?)",
+ })
+ }
+
+ return true
+}
+
+func (d *decoder) parse_value_interface() (interface{}, bool) {
+ b, err := d.ReadByte()
+ if err != nil {
+ panic(err)
+ }
+ d.offset++
+
+ switch b {
+ case 'e':
+ return nil, false
+ case 'd':
+ return d.parse_dict_interface(), true
+ case 'l':
+ return d.parse_list_interface(), true
+ case 'i':
+ return d.parse_int_interface(), true
+ default:
+ if b >= '0' && b <= '9' {
+ // string
+ // append first digit of the length to the buffer
+ d.buf.WriteByte(b)
+ return d.parse_string_interface(), true
+ }
+
+ // unknown value
+ panic(&SyntaxError{
+ Offset: d.offset - 1,
+ what: "unknown value type (invalid bencode?)",
+ })
+ }
+ panic("unreachable")
+}
+
+func (d *decoder) parse_int_interface() interface{} {
+ start := d.offset - 1
+ d.read_until('e')
+ if d.buf.Len() == 0 {
+ panic(&SyntaxError{
+ Offset: start,
+ what: "empty integer value",
+ })
+ }
+
+ n, err := strconv.ParseInt(d.buf.String(), 10, 64)
+ check_for_int_parse_error(err, start)
+ d.buf.Reset()
+ return n
+}
+
+func (d *decoder) parse_string_interface() interface{} {
+ start := d.offset - 1
+
+ // read the string length first
+ d.read_until(':')
+ length, err := strconv.ParseInt(d.buf.String(), 10, 64)
+ check_for_int_parse_error(err, start)
+
+ d.buf.Reset()
+ n, err := io.CopyN(&d.buf, d, length)
+ d.offset += n
+ if err != nil {
+ check_for_unexpected_eof(err, d.offset)
+ panic(&SyntaxError{
+ Offset: d.offset,
+ what: "unexpected I/O error: " + err.Error(),
+ })
+ }
+
+ s := d.buf.String()
+ d.buf.Reset()
+ return s
+}
+
+func (d *decoder) parse_dict_interface() interface{} {
+ dict := make(map[string]interface{})
+ for {
+ keyi, ok := d.parse_value_interface()
+ if !ok {
+ break
+ }
+
+ key, ok := keyi.(string)
+ if !ok {
+ panic(&SyntaxError{
+ Offset: d.offset,
+ what: "non-string key in a dict",
+ })
+ }
+
+ valuei, ok := d.parse_value_interface()
+ if !ok {
+ panic(&SyntaxError{
+ Offset: d.offset,
+ what: "unexpected end of dict, no matching value for a given key",
+ })
+ }
+
+ dict[key] = valuei
+ }
+ return dict
+}
+
+func (d *decoder) parse_list_interface() interface{} {
+ var list []interface{}
+ for {
+ valuei, ok := d.parse_value_interface()
+ if !ok {
+ break
+ }
+
+ list = append(list, valuei)
+ }
+ return list
+}
diff --git a/bencode/decode_test.go b/bencode/decode_test.go
new file mode 100644
index 00000000..3cf5776f
--- /dev/null
+++ b/bencode/decode_test.go
@@ -0,0 +1,34 @@
+package bencode
+
+import "testing"
+import "reflect"
+
+type random_decode_test struct {
+ data string
+ expected interface{}
+}
+
+var random_decode_tests = []random_decode_test{
+ {"i57e", int64(57)},
+ {"i-9223372036854775808e", int64(-9223372036854775808)},
+ {"5:hello", "hello"},
+ {"29:unicode test пÑовеÑка", "unicode test пÑовеÑка"},
+ {"d1:ai5e1:b5:helloe", map[string]interface{}{"a": int64(5), "b": "hello"}},
+ {"li5ei10ei15ei20e7:bencodee",
+ []interface{}{int64(5), int64(10), int64(15), int64(20), "bencode"}},
+}
+
+func TestRandomDecode(t *testing.T) {
+ for _, test := range random_decode_tests {
+ var value interface{}
+ err := Unmarshal([]byte(test.data), &value)
+ if err != nil {
+ t.Error(err)
+ continue
+ }
+ if !reflect.DeepEqual(test.expected, value) {
+ t.Errorf("got: %v (%T), expected: %v (%T)\n",
+ value, value, test.expected, test.expected)
+ }
+ }
+}
diff --git a/bencode/encode.go b/bencode/encode.go
new file mode 100644
index 00000000..82f5b4c2
--- /dev/null
+++ b/bencode/encode.go
@@ -0,0 +1,205 @@
+package bencode
+
+import "bufio"
+import "reflect"
+import "runtime"
+import "strconv"
+import "sync"
+import "sort"
+
+func is_empty_value(v reflect.Value) bool {
+ switch v.Kind() {
+ case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+ return v.Len() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Interface, reflect.Ptr:
+ return v.IsNil()
+ }
+ return false
+}
+
+type encoder struct {
+ *bufio.Writer
+ scratch [64]byte
+}
+
+func (e *encoder) encode(v interface{}) (err error) {
+ defer func() {
+ if e := recover(); e != nil {
+ if _, ok := e.(runtime.Error); ok {
+ panic(e)
+ }
+ err = e.(error)
+ }
+ }()
+ e.reflect_value(reflect.ValueOf(v))
+ return nil
+}
+
+type string_values []reflect.Value
+
+func (sv string_values) Len() int { return len(sv) }
+func (sv string_values) Swap(i, j int) { sv[i], sv[j] = sv[j], sv[i] }
+func (sv string_values) Less(i, j int) bool { return sv.get(i) < sv.get(j) }
+func (sv string_values) get(i int) string { return sv[i].String() }
+
+func (e *encoder) reflect_string(s string) {
+ b := strconv.AppendInt(e.scratch[:0], int64(len(s)), 10)
+ e.Write(b)
+ e.WriteString(":")
+ e.WriteString(s)
+}
+
+func (e *encoder) reflect_byte_slice(s []byte) {
+ b := strconv.AppendInt(e.scratch[:0], int64(len(s)), 10)
+ e.Write(b)
+ e.WriteString(":")
+ e.Write(s)
+}
+
+func (e *encoder) reflect_value(v reflect.Value) {
+ if !v.IsValid() {
+ 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:
+ b := strconv.AppendInt(e.scratch[:0], v.Int(), 10)
+ e.WriteString("i")
+ e.Write(b)
+ e.WriteString("e")
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ b := strconv.AppendUint(e.scratch[:0], v.Uint(), 10)
+ e.WriteString("i")
+ e.Write(b)
+ e.WriteString("e")
+ case reflect.String:
+ e.reflect_string(v.String())
+ case reflect.Struct:
+ e.WriteString("d")
+ for _, ef := range encode_fields(v.Type()) {
+ field_value := v.Field(ef.i)
+ if ef.omit_empty && is_empty_value(field_value) {
+ continue
+ }
+
+ e.reflect_string(ef.tag)
+ e.reflect_value(field_value)
+ }
+ 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 := string_values(v.MapKeys())
+ sort.Sort(sv)
+ for _, key := range sv {
+ e.reflect_string(key.String())
+ e.reflect_value(v.MapIndex(key))
+ }
+ e.WriteString("e")
+ case reflect.Slice:
+ if v.IsNil() {
+ e.WriteString("le")
+ break
+ }
+ if v.Type().Elem().Kind() == reflect.Uint8 {
+ s := v.Bytes()
+ e.reflect_byte_slice(s)
+ break
+ }
+ fallthrough
+ case reflect.Array:
+ e.WriteString("l")
+ for i, n := 0, v.Len(); i < n; i++ {
+ e.reflect_value(v.Index(i))
+ }
+ e.WriteString("e")
+ case reflect.Interface, reflect.Ptr:
+ if v.IsNil() {
+ break
+ }
+ e.reflect_value(v.Elem())
+ default:
+ panic(&MarshalTypeError{v.Type()})
+ }
+}
+
+type encode_field struct {
+ i int
+ tag string
+ omit_empty bool
+}
+
+type encode_fields_sort_type []encode_field
+
+func (ef encode_fields_sort_type) Len() int { return len(ef) }
+func (ef encode_fields_sort_type) Swap(i, j int) { ef[i], ef[j] = ef[j], ef[i] }
+func (ef encode_fields_sort_type) Less(i, j int) bool { return ef[i].tag < ef[j].tag }
+
+var (
+ type_cache_lock sync.RWMutex
+ encode_fields_cache = make(map[reflect.Type][]encode_field)
+)
+
+func encode_fields(t reflect.Type) []encode_field {
+ type_cache_lock.RLock()
+ fs, ok := encode_fields_cache[t]
+ type_cache_lock.RUnlock()
+ if ok {
+ return fs
+ }
+
+ type_cache_lock.Lock()
+ defer type_cache_lock.Unlock()
+ fs, ok = encode_fields_cache[t]
+ if ok {
+ return fs
+ }
+
+ for i, n := 0, t.NumField(); i < n; i++ {
+ f := t.Field(i)
+ if f.PkgPath != "" {
+ continue
+ }
+ if f.Anonymous {
+ continue
+ }
+ var ef encode_field
+ ef.i = i
+ ef.tag = f.Name
+
+ tv := f.Tag.Get("bencode")
+ if tv != "" {
+ if tv == "-" {
+ continue
+ }
+ name, opts := parse_tag(tv)
+ ef.tag = name
+ ef.omit_empty = opts.contains("omitempty")
+ }
+ fs = append(fs, ef)
+ }
+ fss := encode_fields_sort_type(fs)
+ sort.Sort(fss)
+ encode_fields_cache[t] = fs
+ return fs
+}
diff --git a/bencode/encode_test.go b/bencode/encode_test.go
new file mode 100644
index 00000000..de89542b
--- /dev/null
+++ b/bencode/encode_test.go
@@ -0,0 +1,53 @@
+package bencode
+
+import "testing"
+import "bytes"
+
+type random_encode_test struct {
+ value interface{}
+ expected string
+}
+
+type random_struct struct {
+ ABC int `bencode:"abc"`
+ SkipThisOne string `bencode:"-"`
+ CDE string
+}
+
+var random_encode_tests = []random_encode_test{
+ {int(10), "i10e"},
+ {uint(10), "i10e"},
+ {"hello, world", "12:hello, world"},
+ {true, "i1e"},
+ {false, "i0e"},
+ {int8(-8), "i-8e"},
+ {int16(-16), "i-16e"},
+ {int32(32), "i32e"},
+ {int64(-64), "i-64e"},
+ {uint8(8), "i8e"},
+ {uint16(16), "i16e"},
+ {uint32(32), "i32e"},
+ {uint64(64), "i64e"},
+ {random_struct{123, "nono", "hello"}, "d3:CDE5:hello3:abci123ee"},
+ {map[string]string{"a": "b", "c": "d"}, "d1:a1:b1:c1:de"},
+ {[]byte{1, 2, 3, 4}, "4:\x01\x02\x03\x04"},
+ {[4]byte{1, 2, 3, 4}, "li1ei2ei3ei4ee"},
+ {nil, ""},
+ {[]byte{}, "0:"},
+ {"", "0:"},
+ {[]int{}, "le"},
+ {map[string]int{}, "de"},
+}
+
+func TestRandomEncode(t *testing.T) {
+ for _, test := range random_encode_tests {
+ data, err := Marshal(test.value)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if !bytes.Equal(data, []byte(test.expected)) {
+ t.Errorf("got: %s, expected: %s\n",
+ string(data), string(test.expected))
+ }
+ }
+}
diff --git a/bencode/tags.go b/bencode/tags.go
new file mode 100644
index 00000000..0943b41d
--- /dev/null
+++ b/bencode/tags.go
@@ -0,0 +1,34 @@
+package bencode
+
+import (
+ "strings"
+)
+
+type tag_options string
+
+func parse_tag(tag string) (string, tag_options) {
+ if idx := strings.Index(tag, ","); idx != -1 {
+ return tag[:idx], tag_options(tag[idx+1:])
+ }
+ return tag, tag_options("")
+}
+
+func (this tag_options) contains(option_name string) bool {
+ if len(this) == 0 {
+ return false
+ }
+
+ s := string(this)
+ for s != "" {
+ var next string
+ i := strings.Index(s, ",")
+ if i != -1 {
+ s, next = s[:i], s[i+1:]
+ }
+ if s == option_name {
+ return true
+ }
+ s = next
+ }
+ return false
+}
--
2.51.0