16 "github.com/stretchr/testify/assert"
17 "github.com/stretchr/testify/require"
19 "github.com/anacrolix/torrent/util"
22 // Ensure net.IPs are stored big-endian, to match the way they're read from
24 func TestNetIPv4Bytes(t *testing.T) {
25 ip := net.IP([]byte{127, 0, 0, 1})
26 if ip.String() != "127.0.0.1" {
29 if string(ip) != "\x7f\x00\x00\x01" {
34 func TestMarshalAnnounceResponse(t *testing.T) {
35 peers := util.CompactIPv4Peers{
36 {[]byte{127, 0, 0, 1}, 2},
37 {[]byte{255, 0, 0, 3}, 4},
39 b, err := peers.MarshalBinary()
40 require.NoError(t, err)
41 require.EqualValues(t,
42 "\x7f\x00\x00\x01\x00\x02\xff\x00\x00\x03\x00\x04",
44 require.EqualValues(t, 12, binary.Size(AnnounceResponseHeader{}))
47 // Failure to write an entire packet to UDP is expected to given an error.
48 func TestLongWriteUDP(t *testing.T) {
50 l, err := net.ListenUDP("udp", nil)
55 c, err := net.DialUDP("udp", nil, l.LocalAddr().(*net.UDPAddr))
60 for msgLen := 1; ; msgLen *= 2 {
61 n, err := c.Write(make([]byte, msgLen))
63 require.Contains(t, err.Error(), "message too long")
72 func TestShortBinaryRead(t *testing.T) {
73 var data ResponseHeader
74 err := binary.Read(bytes.NewBufferString("\x00\x00\x00\x01"), binary.BigEndian, &data)
75 if err != io.ErrUnexpectedEOF {
80 func TestConvertInt16ToInt(t *testing.T) {
82 if int(uint16(int16(i))) != 50000 {
87 func TestAnnounceLocalhost(t *testing.T) {
90 t: map[[20]byte]torrent{
91 [20]byte{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1}: {
94 Peers: []util.CompactPeer{
95 {[]byte{1, 2, 3, 4}, 5},
96 {[]byte{6, 7, 8, 9}, 10},
102 srv.pc, err = net.ListenPacket("udp", ":0")
103 require.NoError(t, err)
105 tr, err := New(fmt.Sprintf("udp://%s/announce", srv.pc.LocalAddr().String()))
106 require.NoError(t, err)
108 require.NoError(t, srv.serveOne())
111 require.NoError(t, err)
112 req := AnnounceRequest{
116 rand.Read(req.PeerId[:])
117 copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
119 require.NoError(t, srv.serveOne())
121 ar, err := tr.Announce(&req)
122 require.NoError(t, err)
123 assert.EqualValues(t, 1, ar.Seeders)
124 assert.EqualValues(t, 2, len(ar.Peers))
127 func TestUDPTracker(t *testing.T) {
129 tr, err := New("udp://tracker.openbittorrent.com:80/announce")
130 require.NoError(t, err)
134 if err := tr.Connect(); err != nil {
135 if strings.Contains(err.Error(), "no such host") {
138 if strings.Contains(err.Error(), "i/o timeout") {
143 req := AnnounceRequest{
147 rand.Read(req.PeerId[:])
148 copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
149 ar, err := tr.Announce(&req)
150 if ne, ok := err.(net.Error); ok {
155 require.NoError(t, err)
159 func TestAnnounceRandomInfoHashThirdParty(t *testing.T) {
162 // This test involves contacting third party servers that may have
163 // unpreditable results.
166 req := AnnounceRequest{
169 rand.Read(req.PeerId[:])
170 rand.Read(req.InfoHash[:])
171 wg := sync.WaitGroup{}
172 success := make(chan bool)
173 fail := make(chan struct{})
174 for _, url := range []string{
175 "udp://tracker.openbittorrent.com:80/announce",
176 "udp://tracker.publicbt.com:80",
177 "udp://tracker.istole.it:6969",
178 "udp://tracker.ccc.de:80",
179 "udp://tracker.open.demonii.com:1337",
180 "udp://open.demonii.com:1337",
181 "udp://exodus.desync.com:6969",
184 go func(url string) {
190 if err := tr.Connect(); err != nil {
194 resp, err := tr.Announce(&req)
196 t.Logf("error announcing to %s: %s", url, err)
199 if resp.Leechers != 0 || resp.Seeders != 0 || len(resp.Peers) != 0 {
200 // The info hash we generated was random in 2^160 space. If we
201 // get a hit, something is weird.
204 t.Logf("announced to %s", url)
205 // TODO: Can probably get stuck here, but it's just a throwaway
214 // Bail as quickly as we can.
222 // Check that URLPath option is done correctly.
223 func TestURLPathOption(t *testing.T) {
224 conn, err := net.ListenUDP("udp", nil)
229 cl := newClient(&url.URL{
230 Host: conn.LocalAddr().String(),
238 _, err = cl.Announce(&AnnounceRequest{})
244 _, addr, _ := conn.ReadFrom(b[:])
245 r := bytes.NewReader(b[:])
249 write(w, ResponseHeader{
250 TransactionId: h.TransactionId,
252 write(w, ConnectionResponse{42})
253 conn.WriteTo(w.Bytes(), addr)
254 n, _, _ := conn.ReadFrom(b[:])
255 r = bytes.NewReader(b[:n])
257 read(r, &AnnounceRequest{})
258 all, _ := ioutil.ReadAll(r)
259 if string(all) != "\x02\x09/announce" {
263 write(w, ResponseHeader{
264 TransactionId: h.TransactionId,
266 write(w, AnnounceResponseHeader{})
267 conn.WriteTo(w.Bytes(), addr)