tracker/udp_test.go

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