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