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