From a68e4a6f5ac0efe40c43bb0f34e50db527d59deb Mon Sep 17 00:00:00 2001 From: nsf Date: Wed, 20 Jun 2012 19:21:32 +0600 Subject: [PATCH] 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|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=_WfPV*jNY~yO@krr_9GzKC z2qX-fNPyijgZk)j1h|0U77*;9#~hQzzjO!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#f2w zf3kHjQ1;HdR_Hwkt*|c*z}EZ5j@?`xZVP|<2>`*tFzm+M2?T}iqyM1Ef6N(y|5imu z=@I-NVKD4?vHL0Kzp#lFkR=8N`$sJtWz`O`|Njn-e= 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.48.1