import (
"bytes"
+ "context"
"crypto/rand"
- "encoding/binary"
- "io"
+ "errors"
+ "fmt"
"io/ioutil"
- "log"
"net"
"net/url"
"sync"
"testing"
+ "time"
+ "github.com/anacrolix/dht/v2/krpc"
+ _ "github.com/anacrolix/envpprof"
+ "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
- "github.com/anacrolix/torrent/util"
+ "github.com/anacrolix/torrent/tracker/udp"
)
-// Ensure net.IPs are stored big-endian, to match the way they're read from
-// the wire.
-func TestNetIPv4Bytes(t *testing.T) {
- ip := net.IP([]byte{127, 0, 0, 1})
- if ip.String() != "127.0.0.1" {
- t.FailNow()
- }
- if string(ip) != "\x7f\x00\x00\x01" {
- t.Fatal([]byte(ip))
- }
-}
-
-func TestMarshalAnnounceResponse(t *testing.T) {
- w := bytes.Buffer{}
- peers := util.CompactPeers{{[]byte{127, 0, 0, 1}, 2}, {[]byte{255, 0, 0, 3}, 4}}
- err := peers.WriteBinary(&w)
- if err != nil {
- t.Fatalf("error writing udp announce response addrs: %s", err)
- }
- if w.String() != "\x7f\x00\x00\x01\x00\x02\xff\x00\x00\x03\x00\x04" {
- t.FailNow()
- }
- if binary.Size(AnnounceResponseHeader{}) != 12 {
- t.FailNow()
- }
+var trackers = []string{
+ "udp://tracker.opentrackr.org:1337/announce",
+ "udp://tracker.openbittorrent.com:6969/announce",
+ "udp://localhost:42069",
}
-// Failure to write an entire packet to UDP is expected to given an error.
-func TestLongWriteUDP(t *testing.T) {
- l, err := net.ListenUDP("udp", nil)
- defer l.Close()
- if err != nil {
- t.Fatal(err)
- }
- c, err := net.DialUDP("udp", nil, l.LocalAddr().(*net.UDPAddr))
- if err != nil {
- t.Fatal(err)
- }
- defer c.Close()
- for msgLen := 1; ; msgLen *= 2 {
- n, err := c.Write(make([]byte, msgLen))
- if err != nil {
- require.Contains(t, err.Error(), "message too long")
- return
- }
- if n < msgLen {
- t.FailNow()
- }
- }
-}
-
-func TestShortBinaryRead(t *testing.T) {
- var data ResponseHeader
- err := binary.Read(bytes.NewBufferString("\x00\x00\x00\x01"), binary.BigEndian, &data)
- if err != io.ErrUnexpectedEOF {
- t.FailNow()
- }
-}
-
-func TestConvertInt16ToInt(t *testing.T) {
- i := 50000
- if int(uint16(int16(i))) != 50000 {
- t.FailNow()
+func TestAnnounceLocalhost(t *testing.T) {
+ t.Parallel()
+ srv := server{
+ t: map[[20]byte]torrent{
+ {0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1}: {
+ Seeders: 1,
+ Leechers: 2,
+ Peers: krpc.CompactIPv4NodeAddrs{
+ {[]byte{1, 2, 3, 4}, 5},
+ {[]byte{6, 7, 8, 9}, 10},
+ },
+ },
+ },
+ }
+ var err error
+ srv.pc, err = net.ListenPacket("udp", "localhost:0")
+ require.NoError(t, err)
+ defer srv.pc.Close()
+ go func() {
+ require.NoError(t, srv.serveOne())
+ }()
+ req := AnnounceRequest{
+ NumWant: -1,
+ Event: Started,
}
+ rand.Read(req.PeerId[:])
+ copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
+ go func() {
+ require.NoError(t, srv.serveOne())
+ }()
+ ar, err := Announce{
+ TrackerUrl: fmt.Sprintf("udp://%s/announce", srv.pc.LocalAddr().String()),
+ Request: req,
+ }.Do()
+ require.NoError(t, err)
+ assert.EqualValues(t, 1, ar.Seeders)
+ assert.EqualValues(t, 2, len(ar.Peers))
}
func TestUDPTracker(t *testing.T) {
+ t.Parallel()
if testing.Short() {
t.SkipNow()
}
- tr, err := New("udp://tracker.openbittorrent.com:80/announce")
- if err != nil {
- t.Skip(err)
- }
- if err := tr.Connect(); err != nil {
- t.Skip(err)
- }
req := AnnounceRequest{
NumWant: -1,
- Event: Started,
}
rand.Read(req.PeerId[:])
copy(req.InfoHash[:], []uint8{0xa3, 0x56, 0x41, 0x43, 0x74, 0x23, 0xe6, 0x26, 0xd9, 0x38, 0x25, 0x4a, 0x6b, 0x80, 0x49, 0x10, 0xa6, 0x67, 0xa, 0xc1})
- _, err = tr.Announce(&req)
- if err != nil {
+ ctx, cancel := context.WithTimeout(context.Background(), DefaultTrackerAnnounceTimeout)
+ defer cancel()
+ if dl, ok := t.Deadline(); ok {
+ var cancel func()
+ ctx, cancel = context.WithDeadline(context.Background(), dl.Add(-time.Second))
+ defer cancel()
+ }
+ ar, err := Announce{
+ TrackerUrl: trackers[0],
+ Request: req,
+ Context: ctx,
+ }.Do()
+ // Skip any net errors as we don't control the server.
+ var ne net.Error
+ if errors.As(err, &ne) {
t.Skip(err)
}
+ require.NoError(t, err)
+ t.Logf("%+v", ar)
}
-// TODO: Create a fake UDP tracker to make these requests to.
-func TestAnnounceRandomInfoHash(t *testing.T) {
+func TestAnnounceRandomInfoHashThirdParty(t *testing.T) {
+ t.Parallel()
if testing.Short() {
+ // This test involves contacting third party servers that may have
+ // unpredictable results.
t.SkipNow()
}
req := AnnounceRequest{
rand.Read(req.PeerId[:])
rand.Read(req.InfoHash[:])
wg := sync.WaitGroup{}
- for _, url := range []string{
- "udp://tracker.openbittorrent.com:80/announce",
- "udp://tracker.publicbt.com:80",
- "udp://tracker.istole.it:6969",
- "udp://tracker.ccc.de:80",
- "udp://tracker.open.demonii.com:1337",
- } {
+ ctx, cancel := context.WithTimeout(context.Background(), DefaultTrackerAnnounceTimeout)
+ defer cancel()
+ if dl, ok := t.Deadline(); ok {
+ var cancel func()
+ ctx, cancel = context.WithDeadline(ctx, dl.Add(-time.Second))
+ defer cancel()
+ }
+ for _, url := range trackers {
+ wg.Add(1)
go func(url string) {
defer wg.Done()
- tr, err := New(url)
- if err != nil {
- t.Fatal(err)
- }
- if err := tr.Connect(); err != nil {
- t.Log(err)
- return
- }
- resp, err := tr.Announce(&req)
+ resp, err := Announce{
+ TrackerUrl: url,
+ Request: req,
+ Context: ctx,
+ }.Do()
if err != nil {
t.Logf("error announcing to %s: %s", url, err)
return
}
if resp.Leechers != 0 || resp.Seeders != 0 || len(resp.Peers) != 0 {
+ // The info hash we generated was random in 2^160 space. If we
+ // get a hit, something is weird.
t.Fatal(resp)
}
+ t.Logf("announced to %s", url)
+ cancel()
}(url)
- wg.Add(1)
}
wg.Wait()
+ cancel()
}
// Check that URLPath option is done correctly.
func TestURLPathOption(t *testing.T) {
- conn, err := net.ListenUDP("udp", nil)
+ conn, err := net.ListenPacket("udp", "localhost:0")
if err != nil {
panic(err)
}
defer conn.Close()
- cl := newClient(&url.URL{
- Host: conn.LocalAddr().String(),
- Path: "/announce",
- })
+ announceErr := make(chan error)
go func() {
- err = cl.Connect()
- if err != nil {
- t.Fatal(err)
- }
- log.Print("connected")
- _, err = cl.Announce(&AnnounceRequest{})
- if err != nil {
- t.Fatal(err)
- }
+ _, err := Announce{
+ TrackerUrl: (&url.URL{
+ Scheme: "udp",
+ Host: conn.LocalAddr().String(),
+ Path: "/announce",
+ }).String(),
+ }.Do()
+ defer conn.Close()
+ announceErr <- err
}()
var b [512]byte
+ // conn.SetReadDeadline(time.Now().Add(time.Second))
_, addr, _ := conn.ReadFrom(b[:])
r := bytes.NewReader(b[:])
- var h RequestHeader
- read(r, &h)
+ var h udp.RequestHeader
+ udp.Read(r, &h)
w := &bytes.Buffer{}
- write(w, ResponseHeader{
+ udp.Write(w, udp.ResponseHeader{
+ Action: udp.ActionConnect,
TransactionId: h.TransactionId,
})
- write(w, ConnectionResponse{42})
+ udp.Write(w, udp.ConnectionResponse{42})
conn.WriteTo(w.Bytes(), addr)
n, _, _ := conn.ReadFrom(b[:])
r = bytes.NewReader(b[:n])
- read(r, &h)
- read(r, &AnnounceRequest{})
+ udp.Read(r, &h)
+ udp.Read(r, &AnnounceRequest{})
all, _ := ioutil.ReadAll(r)
if string(all) != "\x02\x09/announce" {
t.FailNow()
}
w = &bytes.Buffer{}
- write(w, ResponseHeader{
+ udp.Write(w, udp.ResponseHeader{
+ Action: udp.ActionAnnounce,
TransactionId: h.TransactionId,
})
- write(w, AnnounceResponseHeader{})
+ udp.Write(w, udp.AnnounceResponseHeader{})
conn.WriteTo(w.Bytes(), addr)
+ require.NoError(t, <-announceErr)
}