func test_file(t *testing.T, filename string) {
mi, err := LoadFromFile(filename)
if err != nil {
t.Fatal(err)
}
if len(mi.Info.Files) == 1 {
t.Logf("Single file: %s (length: %d)\n", mi.Info.Name, mi.Info.Files[0].Length)
} else {
t.Logf("Multiple files: %s\n", mi.Info.Name)
for _, f := range mi.Info.Files {
t.Logf(" - %s (length: %d)\n", path.Join(f.Path...), f.Length)
}
}
for _, group := range mi.AnnounceList {
for _, tracker := range group {
t.Logf("Tracker: %s\n", tracker)
}
}
// for _, url := range mi.WebSeedURLs {
// t.Logf("URL: %s\n", url)
// }
b, err := bencode.Marshal(mi.Info)
if !bytes.Equal(b, mi.Info.Bytes) {
t.Logf("\n%q\n%q", b[len(b)-20:], mi.Info.Bytes[len(mi.Info.Bytes)-20:])
t.Fatal("encoded and decoded bytes don't match")
}
}
func testFile(t *testing.T, filename string) {
mi, err := LoadFromFile(filename)
if err != nil {
t.Fatal(err)
}
if len(mi.Info.Files) == 1 {
t.Logf("Single file: %s (length: %d)\n", mi.Info.Name, mi.Info.Files[0].Length)
} else {
t.Logf("Multiple files: %s\n", mi.Info.Name)
for _, f := range mi.Info.Files {
t.Logf(" - %s (length: %d)\n", path.Join(f.Path...), f.Length)
}
}
for _, group := range mi.AnnounceList {
for _, tracker := range group {
t.Logf("Tracker: %s\n", tracker)
}
}
// for _, url := range mi.WebSeedURLs {
// t.Logf("URL: %s\n", url)
// }
b, err := bencode.Marshal(mi.Info)
require.NoError(t, err)
assert.EqualValues(t, b, mi.Info.Bytes)
}
func (c *connection) requestMetadataPiece(index int) {
eID := c.PeerExtensionIDs["ut_metadata"]
if eID == 0 {
return
}
if index < len(c.metadataRequests) && c.metadataRequests[index] {
return
}
c.Post(pp.Message{
Type: pp.Extended,
ExtendedID: eID,
ExtendedPayload: func() []byte {
b, err := bencode.Marshal(map[string]int{
"msg_type": pp.RequestMetadataExtensionMsgType,
"piece": index,
})
if err != nil {
panic(err)
}
return b
}(),
})
for index >= len(c.metadataRequests) {
c.metadataRequests = append(c.metadataRequests, false)
}
c.metadataRequests[index] = true
}
// Marshals .Info, and sets .Bytes with the result.
func (ie *InfoEx) UpdateBytes() {
var err error
ie.Bytes, err = bencode.Marshal(&ie.Info)
if err != nil {
panic(err)
}
}
func (s *Server) query(node dHTAddr, q string, a map[string]interface{}, onResponse func(Msg)) (t *Transaction, err error) {
tid := s.nextTransactionID()
if a == nil {
a = make(map[string]interface{}, 1)
}
a["id"] = s.ID()
d := map[string]interface{}{
"t": tid,
"y": "q",
"q": q,
"a": a,
}
b, err := bencode.Marshal(d)
if err != nil {
return
}
t = &Transaction{
remoteAddr: node,
t: tid,
response: make(chan Msg, 1),
done: make(chan struct{}),
queryPacket: b,
s: s,
onResponse: onResponse,
}
err = t.sendQuery()
if err != nil {
return
}
s.getNode(node, "").lastSentQuery = time.Now()
t.startTimer()
s.addTransaction(t)
return
}
func (cl *Client) sendInitialMessages(conn *connection, torrent *Torrent) {
if conn.PeerExtensionBytes.SupportsExtended() && cl.extensionBytes.SupportsExtended() {
conn.Post(pp.Message{
Type: pp.Extended,
ExtendedID: pp.HandshakeExtendedID,
ExtendedPayload: func() []byte {
d := map[string]interface{}{
"m": func() (ret map[string]int) {
ret = make(map[string]int, 2)
ret["ut_metadata"] = metadataExtendedId
if !cl.config.DisablePEX {
ret["ut_pex"] = pexExtendedId
}
return
}(),
"v": extendedHandshakeClientVersion,
// No upload queue is implemented yet.
"reqq": 64,
}
if !cl.config.DisableEncryption {
d["e"] = 1
}
if torrent.metadataSizeKnown() {
d["metadata_size"] = torrent.metadataSize()
}
if p := cl.incomingPeerPort(); p != 0 {
d["p"] = p
}
yourip, err := addrCompactIP(conn.remoteAddr())
if err != nil {
log.Printf("error calculating yourip field value in extension handshake: %s", err)
} else {
d["yourip"] = yourip
}
// log.Printf("sending %v", d)
b, err := bencode.Marshal(d)
if err != nil {
panic(err)
}
return b
}(),
})
}
if torrent.haveAnyPieces() {
conn.Bitfield(torrent.bitfield())
} else if cl.extensionBytes.SupportsFast() && conn.PeerExtensionBytes.SupportsFast() {
conn.Post(pp.Message{
Type: pp.HaveNone,
})
}
if conn.PeerExtensionBytes.SupportsDHT() && cl.extensionBytes.SupportsDHT() && cl.dHT != nil {
conn.Post(pp.Message{
Type: pp.Port,
Port: uint16(missinggo.AddrPort(cl.dHT.Addr())),
})
}
}
func (me CompactPeer) MarshalBencode() (ret []byte, err error) {
ip := me.IP
if ip4 := ip.To4(); ip4 != nil {
ip = ip4
}
ret = make([]byte, len(ip)+2)
copy(ret, ip)
binary.BigEndian.PutUint16(ret[len(ip):], uint16(me.Port))
return bencode.Marshal(ret)
}
func testMarshalUnmarshalMsg(t *testing.T, m Msg, expected string) {
b, err := bencode.Marshal(m)
require.NoError(t, err)
assert.Equal(t, expected, string(b))
var _m Msg
err = bencode.Unmarshal([]byte(expected), &_m)
assert.NoError(t, err)
assert.EqualValues(t, m, _m)
assert.EqualValues(t, m.R, _m.R)
}
func (me CompactIPv4NodeInfo) MarshalBencode() (ret []byte, err error) {
var buf bytes.Buffer
for _, ni := range me {
buf.Write(ni.ID[:])
if ni.Addr == nil {
err = errors.New("nil addr in node info")
return
}
buf.Write(ni.Addr.IP().To4())
binary.Write(&buf, binary.BigEndian, uint16(ni.Addr.UDPAddr().Port))
}
return bencode.Marshal(buf.Bytes())
}
func (s *Server) reply(addr dHTAddr, t string, r Return) {
r.ID = s.ID()
m := Msg{
T: t,
Y: "r",
R: &r,
}
b, err := bencode.Marshal(m)
if err != nil {
panic(err)
}
err = s.writeToNode(b, addr)
if err != nil {
log.Printf("error replying to %s: %s", addr, err)
}
}
func (t *torrent) newMetadataExtensionMessage(c *connection, msgType int, piece int, data []byte) pp.Message {
d := map[string]int{
"msg_type": msgType,
"piece": piece,
}
if data != nil {
d["total_size"] = len(t.MetaData)
}
p, err := bencode.Marshal(d)
if err != nil {
panic(err)
}
return pp.Message{
Type: pp.Extended,
ExtendedID: byte(c.PeerExtensionIDs["ut_metadata"]),
ExtendedPayload: append(p, data...),
}
}
func (s *Server) reply(addr dHTAddr, t string, r map[string]interface{}) {
if r == nil {
r = make(map[string]interface{}, 1)
}
r["id"] = s.ID()
m := map[string]interface{}{
"t": t,
"y": "r",
"r": r,
}
b, err := bencode.Marshal(m)
if err != nil {
panic(err)
}
err = s.writeToNode(b, addr)
if err != nil {
log.Printf("error replying to %s: %s", addr, err)
}
}
func (s *Server) query(node Addr, q string, a map[string]interface{}, onResponse func(krpc.Msg)) (t *Transaction, err error) {
tid := s.nextTransactionID()
if a == nil {
a = make(map[string]interface{}, 1)
}
a["id"] = s.ID()
d := map[string]interface{}{
"t": tid,
"y": "q",
"q": q,
"a": a,
}
// BEP 43. Outgoing queries from uncontactiable nodes should contain
// "ro":1 in the top level dictionary.
if s.config.Passive {
d["ro"] = 1
}
b, err := bencode.Marshal(d)
if err != nil {
return
}
_t := &Transaction{
remoteAddr: node,
t: tid,
response: make(chan krpc.Msg, 1),
done: make(chan struct{}),
queryPacket: b,
s: s,
onResponse: onResponse,
}
err = _t.sendQuery()
if err != nil {
return
}
s.getNode(node, "").lastSentQuery = time.Now()
_t.mu.Lock()
_t.startTimer()
_t.mu.Unlock()
s.addTransaction(_t)
t = _t
return
}
func testFile(t *testing.T, filename string) {
mi, err := LoadFromFile(filename)
require.NoError(t, err)
if len(mi.Info.Files) == 1 {
t.Logf("Single file: %s (length: %d)\n", mi.Info.Name, mi.Info.Files[0].Length)
} else {
t.Logf("Multiple files: %s\n", mi.Info.Name)
for _, f := range mi.Info.Files {
t.Logf(" - %s (length: %d)\n", path.Join(f.Path...), f.Length)
}
}
for _, group := range mi.AnnounceList {
for _, tracker := range group {
t.Logf("Tracker: %s\n", tracker)
}
}
b, err := bencode.Marshal(&mi.Info.Info)
require.NoError(t, err)
assert.EqualValues(t, string(b), string(mi.Info.Bytes))
}
func (this InfoEx) MarshalBencode() ([]byte, error) {
if this.Bytes != nil {
return this.Bytes, nil
}
return bencode.Marshal(&this.Info)
}
func (e KRPCError) MarshalBencode() (ret []byte, err error) {
return bencode.Marshal([]interface{}{e.Code, e.Msg})
}
func testMarshalMetainfo(t *testing.T, expected string, mi MetaInfo) {
b, err := bencode.Marshal(mi)
assert.NoError(t, err)
assert.EqualValues(t, expected, string(b))
}