tracker/udp_test.go

   1 package tracker
   2
   3 import (
   4         "bytes"
   5         "crypto/rand"
   6         "encoding/binary"
   7         "fmt"
   8         "io"
   9         "io/ioutil"
  10         "net"
  11         "net/url"
  12         "strings"
  13         "sync"
  14         "testing"
  15
  16         "github.com/stretchr/testify/assert"
  17         "github.com/stretchr/testify/require"
  18
  19         "github.com/anacrolix/torrent/util"
  20 )
  21
  22 // Ensure net.IPs are stored big-endian, to match the way they're read from
  23 // the wire.
  24 func TestNetIPv4Bytes(t *testing.T) {
  25         ip := net.IP([]byte{127, 0, 0, 1})
  26         if ip.String() != "127.0.0.1" {
  27                 t.FailNow()
  28         }
  29         if string(ip) != "\x7f\x00\x00\x01" {
  30                 t.Fatal([]byte(ip))
  31         }
  32 }
  33
  34 func TestMarshalAnnounceResponse(t *testing.T) {
  35         peers := util.CompactIPv4Peers{
  36                 {[]byte{127, 0, 0, 1}, 2},
  37                 {[]byte{255, 0, 0, 3}, 4},
  38         }
  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",
  43                 b)
  44         require.EqualValues(t, 12, binary.Size(AnnounceResponseHeader{}))
  45 }
  46
  47 // Failure to write an entire packet to UDP is expected to given an error.
  48 func TestLongWriteUDP(t *testing.T) {
  49         l, err := net.ListenUDP("udp", nil)
  50         defer l.Close()
  51         if err != nil {
  52                 t.Fatal(err)
  53         }
  54         c, err := net.DialUDP("udp", nil, l.LocalAddr().(*net.UDPAddr))
  55         if err != nil {
  56                 t.Fatal(err)
  57         }
  58         defer c.Close()
  59         for msgLen := 1; ; msgLen *= 2 {
  60                 n, err := c.Write(make([]byte, msgLen))
  61                 if err != nil {
  62                         require.Contains(t, err.Error(), "message too long")
  63                         return
  64                 }
  65                 if n < msgLen {
  66                         t.FailNow()
  67                 }
  68         }
  69 }
  70
  71 func TestShortBinaryRead(t *testing.T) {
  72         var data ResponseHeader
  73         err := binary.Read(bytes.NewBufferString("\x00\x00\x00\x01"), binary.BigEndian, &data)
  74         if err != io.ErrUnexpectedEOF {
  75                 t.FailNow()
  76         }
  77 }
  78
  79 func TestConvertInt16ToInt(t *testing.T) {
  80         i := 50000
  81         if int(uint16(int16(i))) != 50000 {
  82                 t.FailNow()
  83         }
  84 }
  85
  86 func TestAnnounceLocalhost(t *testing.T) {
  87         srv := server{
  88                 t: map[[20]byte]torrent{
  89                         [20]byte{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1}: {
  90                                 Seeders:  1,
  91                                 Leechers: 2,
  92                                 Peers: []util.CompactPeer{
  93                                         {[]byte{1, 2, 3, 4}, 5},
  94                                         {[]byte{6, 7, 8, 9}, 10},
  95                                 },
  96                         },
  97                 },
  98         }
  99         var err error
 100         srv.pc, err = net.ListenPacket("udp", ":0")
 101         require.NoError(t, err)
 102         defer srv.pc.Close()
 103         tr, err := New(fmt.Sprintf("udp://%s/announce", srv.pc.LocalAddr().String()))
 104         require.NoError(t, err)
 105         go func() {
 106                 require.NoError(t, srv.serveOne())
 107         }()
 108         err = tr.Connect()
 109         require.NoError(t, err)
 110         req := AnnounceRequest{
 111                 NumWant: -1,
 112                 Event:   Started,
 113         }
 114         rand.Read(req.PeerId[:])
 115         copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
 116         go func() {
 117                 require.NoError(t, srv.serveOne())
 118         }()
 119         ar, err := tr.Announce(&req)
 120         require.NoError(t, err)
 121         assert.EqualValues(t, 1, ar.Seeders)
 122         assert.EqualValues(t, 2, len(ar.Peers))
 123 }
 124
 125 func TestUDPTracker(t *testing.T) {
 126         tr, err := New("udp://tracker.openbittorrent.com:80/announce")
 127         require.NoError(t, err)
 128         if testing.Short() {
 129                 t.SkipNow()
 130         }
 131         if err := tr.Connect(); err != nil {
 132                 if strings.Contains(err.Error(), "no such host") {
 133                         t.Skip(err)
 134                 }
 135                 if strings.Contains(err.Error(), "i/o timeout") {
 136                         t.Skip(err)
 137                 }
 138                 t.Fatal(err)
 139         }
 140         req := AnnounceRequest{
 141                 NumWant: -1,
 142                 // Event:   Started,
 143         }
 144         rand.Read(req.PeerId[:])
 145         copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
 146         ar, err := tr.Announce(&req)
 147         if ne, ok := err.(net.Error); ok {
 148                 if ne.Timeout() {
 149                         t.Skip(err)
 150                 }
 151         }
 152         require.NoError(t, err)
 153         t.Log(ar)
 154 }
 155
 156 func TestAnnounceRandomInfoHashThirdParty(t *testing.T) {
 157         if testing.Short() {
 158                 // This test involves contacting third party servers that may have
 159                 // unpreditable results.
 160                 t.SkipNow()
 161         }
 162         req := AnnounceRequest{
 163                 Event: Stopped,
 164         }
 165         rand.Read(req.PeerId[:])
 166         rand.Read(req.InfoHash[:])
 167         wg := sync.WaitGroup{}
 168         success := make(chan bool)
 169         fail := make(chan struct{})
 170         for _, url := range []string{
 171                 "udp://tracker.openbittorrent.com:80/announce",
 172                 "udp://tracker.publicbt.com:80",
 173                 "udp://tracker.istole.it:6969",
 174                 "udp://tracker.ccc.de:80",
 175                 "udp://tracker.open.demonii.com:1337",
 176                 "udp://open.demonii.com:1337",
 177                 "udp://exodus.desync.com:6969",
 178         } {
 179                 wg.Add(1)
 180                 go func(url string) {
 181                         defer wg.Done()
 182                         tr, err := New(url)
 183                         if err != nil {
 184                                 t.Fatal(err)
 185                         }
 186                         if err := tr.Connect(); err != nil {
 187                                 t.Log(err)
 188                                 return
 189                         }
 190                         resp, err := tr.Announce(&req)
 191                         if err != nil {
 192                                 t.Logf("error announcing to %s: %s", url, err)
 193                                 return
 194                         }
 195                         if resp.Leechers != 0 || resp.Seeders != 0 || len(resp.Peers) != 0 {
 196                                 // The info hash we generated was random in 2^160 space. If we
 197                                 // get a hit, something is weird.
 198                                 t.Fatal(resp)
 199                         }
 200                         t.Logf("announced to %s", url)
 201                         // TODO: Can probably get stuck here, but it's just a throwaway
 202                         // test.
 203                         success <- true
 204                 }(url)
 205         }
 206         go func() {
 207                 wg.Wait()
 208                 close(fail)
 209         }()
 210         // Bail as quickly as we can.
 211         select {
 212         case <-fail:
 213                 t.FailNow()
 214         case <-success:
 215         }
 216 }
 217
 218 // Check that URLPath option is done correctly.
 219 func TestURLPathOption(t *testing.T) {
 220         conn, err := net.ListenUDP("udp", nil)
 221         if err != nil {
 222                 panic(err)
 223         }
 224         defer conn.Close()
 225         cl := newClient(&url.URL{
 226                 Host: conn.LocalAddr().String(),
 227                 Path: "/announce",
 228         })
 229         go func() {
 230                 err = cl.Connect()
 231                 if err != nil {
 232                         t.Fatal(err)
 233                 }
 234                 _, err = cl.Announce(&AnnounceRequest{})
 235                 if err != nil {
 236                         t.Fatal(err)
 237                 }
 238         }()
 239         var b [512]byte
 240         _, addr, _ := conn.ReadFrom(b[:])
 241         r := bytes.NewReader(b[:])
 242         var h RequestHeader
 243         read(r, &h)
 244         w := &bytes.Buffer{}
 245         write(w, ResponseHeader{
 246                 TransactionId: h.TransactionId,
 247         })
 248         write(w, ConnectionResponse{42})
 249         conn.WriteTo(w.Bytes(), addr)
 250         n, _, _ := conn.ReadFrom(b[:])
 251         r = bytes.NewReader(b[:n])
 252         read(r, &h)
 253         read(r, &AnnounceRequest{})
 254         all, _ := ioutil.ReadAll(r)
 255         if string(all) != "\x02\x09/announce" {
 256                 t.FailNow()
 257         }
 258         w = &bytes.Buffer{}
 259         write(w, ResponseHeader{
 260                 TransactionId: h.TransactionId,
 261         })
 262         write(w, AnnounceResponseHeader{})
 263         conn.WriteTo(w.Bytes(), addr)
 264 }