client_test.go

   1 package torrent
   2
   3 import (
   4         "encoding/binary"
   5         "fmt"
   6         "io"
   7         "io/ioutil"
   8         "os"
   9         "path/filepath"
  10         "reflect"
  11         "testing"
  12         "testing/iotest"
  13         "time"
  14
  15         "github.com/bradfitz/iter"
  16         "github.com/frankban/quicktest"
  17         "github.com/stretchr/testify/assert"
  18         "github.com/stretchr/testify/require"
  19
  20         "github.com/anacrolix/dht/v2"
  21         "github.com/anacrolix/missinggo"
  22         "github.com/anacrolix/missinggo/v2/filecache"
  23
  24         "github.com/anacrolix/torrent/bencode"
  25         "github.com/anacrolix/torrent/internal/testutil"
  26         "github.com/anacrolix/torrent/iplist"
  27         "github.com/anacrolix/torrent/metainfo"
  28         "github.com/anacrolix/torrent/storage"
  29 )
  30
  31 func TestClientDefault(t *testing.T) {
  32         cl, err := NewClient(TestingConfig(t))
  33         require.NoError(t, err)
  34         cl.Close()
  35 }
  36
  37 func TestClientNilConfig(t *testing.T) {
  38         cl, err := NewClient(nil)
  39         require.NoError(t, err)
  40         cl.Close()
  41 }
  42
  43 func TestBoltPieceCompletionClosedWhenClientClosed(t *testing.T) {
  44         cfg := TestingConfig(t)
  45         pc, err := storage.NewBoltPieceCompletion(cfg.DataDir)
  46         require.NoError(t, err)
  47         ci := storage.NewFileWithCompletion(cfg.DataDir, pc)
  48         defer ci.Close()
  49         cfg.DefaultStorage = ci
  50         cl, err := NewClient(cfg)
  51         require.NoError(t, err)
  52         cl.Close()
  53         // And again, https://github.com/anacrolix/torrent/issues/158
  54         cl, err = NewClient(cfg)
  55         require.NoError(t, err)
  56         cl.Close()
  57 }
  58
  59 func TestAddDropTorrent(t *testing.T) {
  60         cl, err := NewClient(TestingConfig(t))
  61         require.NoError(t, err)
  62         defer cl.Close()
  63         dir, mi := testutil.GreetingTestTorrent()
  64         defer os.RemoveAll(dir)
  65         tt, new, err := cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
  66         require.NoError(t, err)
  67         assert.True(t, new)
  68         tt.SetMaxEstablishedConns(0)
  69         tt.SetMaxEstablishedConns(1)
  70         tt.Drop()
  71 }
  72
  73 func TestAddTorrentNoSupportedTrackerSchemes(t *testing.T) {
  74         // TODO?
  75         t.SkipNow()
  76 }
  77
  78 func TestAddTorrentNoUsableURLs(t *testing.T) {
  79         // TODO?
  80         t.SkipNow()
  81 }
  82
  83 func TestAddPeersToUnknownTorrent(t *testing.T) {
  84         // TODO?
  85         t.SkipNow()
  86 }
  87
  88 func TestPieceHashSize(t *testing.T) {
  89         assert.Equal(t, 20, pieceHash.Size())
  90 }
  91
  92 func TestTorrentInitialState(t *testing.T) {
  93         dir, mi := testutil.GreetingTestTorrent()
  94         defer os.RemoveAll(dir)
  95         cl := &Client{
  96                 config: TestingConfig(t),
  97         }
  98         cl.initLogger()
  99         tor := cl.newTorrent(
 100                 mi.HashInfoBytes(),
 101                 storage.NewFileWithCompletion(t.TempDir(), storage.NewMapPieceCompletion()),
 102         )
 103         tor.setChunkSize(2)
 104         tor.cl.lock()
 105         err := tor.setInfoBytes(mi.InfoBytes)
 106         tor.cl.unlock()
 107         require.NoError(t, err)
 108         require.Len(t, tor.pieces, 3)
 109         tor.pendAllChunkSpecs(0)
 110         tor.cl.lock()
 111         assert.EqualValues(t, 3, tor.pieceNumPendingChunks(0))
 112         tor.cl.unlock()
 113         assert.EqualValues(t, ChunkSpec{4, 1}, chunkIndexSpec(2, tor.pieceLength(0), tor.chunkSize))
 114 }
 115
 116 func TestReducedDialTimeout(t *testing.T) {
 117         cfg := NewDefaultClientConfig()
 118         for _, _case := range []struct {
 119                 Max             time.Duration
 120                 HalfOpenLimit   int
 121                 PendingPeers    int
 122                 ExpectedReduced time.Duration
 123         }{
 124                 {cfg.NominalDialTimeout, 40, 0, cfg.NominalDialTimeout},
 125                 {cfg.NominalDialTimeout, 40, 1, cfg.NominalDialTimeout},
 126                 {cfg.NominalDialTimeout, 40, 39, cfg.NominalDialTimeout},
 127                 {cfg.NominalDialTimeout, 40, 40, cfg.NominalDialTimeout / 2},
 128                 {cfg.NominalDialTimeout, 40, 80, cfg.NominalDialTimeout / 3},
 129                 {cfg.NominalDialTimeout, 40, 4000, cfg.NominalDialTimeout / 101},
 130         } {
 131                 reduced := reducedDialTimeout(cfg.MinDialTimeout, _case.Max, _case.HalfOpenLimit, _case.PendingPeers)
 132                 expected := _case.ExpectedReduced
 133                 if expected < cfg.MinDialTimeout {
 134                         expected = cfg.MinDialTimeout
 135                 }
 136                 if reduced != expected {
 137                         t.Fatalf("expected %s, got %s", _case.ExpectedReduced, reduced)
 138                 }
 139         }
 140 }
 141
 142 func TestAddDropManyTorrents(t *testing.T) {
 143         cl, err := NewClient(TestingConfig(t))
 144         require.NoError(t, err)
 145         defer cl.Close()
 146         for i := range iter.N(1000) {
 147                 var spec TorrentSpec
 148                 binary.PutVarint(spec.InfoHash[:], int64(i))
 149                 tt, new, err := cl.AddTorrentSpec(&spec)
 150                 assert.NoError(t, err)
 151                 assert.True(t, new)
 152                 defer tt.Drop()
 153         }
 154 }
 155
 156 func fileCachePieceResourceStorage(fc *filecache.Cache) storage.ClientImpl {
 157         return storage.NewResourcePiecesOpts(
 158                 fc.AsResourceProvider(),
 159                 storage.ResourcePiecesOpts{
 160                         LeaveIncompleteChunks: true,
 161                 },
 162         )
 163 }
 164
 165 func TestMergingTrackersByAddingSpecs(t *testing.T) {
 166         cl, err := NewClient(TestingConfig(t))
 167         require.NoError(t, err)
 168         defer cl.Close()
 169         spec := TorrentSpec{}
 170         T, new, _ := cl.AddTorrentSpec(&spec)
 171         if !new {
 172                 t.FailNow()
 173         }
 174         spec.Trackers = [][]string{{"http://a"}, {"udp://b"}}
 175         _, new, _ = cl.AddTorrentSpec(&spec)
 176         assert.False(t, new)
 177         assert.EqualValues(t, [][]string{{"http://a"}, {"udp://b"}}, T.metainfo.AnnounceList)
 178         // Because trackers are disabled in TestingConfig.
 179         assert.EqualValues(t, 0, len(T.trackerAnnouncers))
 180 }
 181
 182 // We read from a piece which is marked completed, but is missing data.
 183 func TestCompletedPieceWrongSize(t *testing.T) {
 184         cfg := TestingConfig(t)
 185         cfg.DefaultStorage = badStorage{}
 186         cl, err := NewClient(cfg)
 187         require.NoError(t, err)
 188         defer cl.Close()
 189         info := metainfo.Info{
 190                 PieceLength: 15,
 191                 Pieces:      make([]byte, 20),
 192                 Files: []metainfo.FileInfo{
 193                         {Path: []string{"greeting"}, Length: 13},
 194                 },
 195         }
 196         b, err := bencode.Marshal(info)
 197         require.NoError(t, err)
 198         tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
 199                 InfoBytes: b,
 200                 InfoHash:  metainfo.HashBytes(b),
 201         })
 202         require.NoError(t, err)
 203         defer tt.Drop()
 204         assert.True(t, new)
 205         r := tt.NewReader()
 206         defer r.Close()
 207         quicktest.Check(t, iotest.TestReader(r, []byte(testutil.GreetingFileContents)), quicktest.IsNil)
 208 }
 209
 210 func BenchmarkAddLargeTorrent(b *testing.B) {
 211         cfg := TestingConfig(b)
 212         cfg.DisableTCP = true
 213         cfg.DisableUTP = true
 214         cl, err := NewClient(cfg)
 215         require.NoError(b, err)
 216         defer cl.Close()
 217         b.ReportAllocs()
 218         for range iter.N(b.N) {
 219                 t, err := cl.AddTorrentFromFile("testdata/bootstrap.dat.torrent")
 220                 if err != nil {
 221                         b.Fatal(err)
 222                 }
 223                 t.Drop()
 224         }
 225 }
 226
 227 func TestResponsive(t *testing.T) {
 228         seederDataDir, mi := testutil.GreetingTestTorrent()
 229         defer os.RemoveAll(seederDataDir)
 230         cfg := TestingConfig(t)
 231         cfg.Seed = true
 232         cfg.DataDir = seederDataDir
 233         seeder, err := NewClient(cfg)
 234         require.Nil(t, err)
 235         defer seeder.Close()
 236         seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
 237         seederTorrent.VerifyData()
 238         leecherDataDir, err := ioutil.TempDir("", "")
 239         require.Nil(t, err)
 240         defer os.RemoveAll(leecherDataDir)
 241         cfg = TestingConfig(t)
 242         cfg.DataDir = leecherDataDir
 243         leecher, err := NewClient(cfg)
 244         require.Nil(t, err)
 245         defer leecher.Close()
 246         leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
 247                 ret = TorrentSpecFromMetaInfo(mi)
 248                 ret.ChunkSize = 2
 249                 return
 250         }())
 251         leecherTorrent.AddClientPeer(seeder)
 252         reader := leecherTorrent.NewReader()
 253         defer reader.Close()
 254         reader.SetReadahead(0)
 255         reader.SetResponsive()
 256         b := make([]byte, 2)
 257         _, err = reader.Seek(3, io.SeekStart)
 258         require.NoError(t, err)
 259         _, err = io.ReadFull(reader, b)
 260         assert.Nil(t, err)
 261         assert.EqualValues(t, "lo", string(b))
 262         _, err = reader.Seek(11, io.SeekStart)
 263         require.NoError(t, err)
 264         n, err := io.ReadFull(reader, b)
 265         assert.Nil(t, err)
 266         assert.EqualValues(t, 2, n)
 267         assert.EqualValues(t, "d\n", string(b))
 268 }
 269
 270 func TestTorrentDroppedDuringResponsiveRead(t *testing.T) {
 271         seederDataDir, mi := testutil.GreetingTestTorrent()
 272         defer os.RemoveAll(seederDataDir)
 273         cfg := TestingConfig(t)
 274         cfg.Seed = true
 275         cfg.DataDir = seederDataDir
 276         seeder, err := NewClient(cfg)
 277         require.Nil(t, err)
 278         defer seeder.Close()
 279         seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
 280         seederTorrent.VerifyData()
 281         leecherDataDir, err := ioutil.TempDir("", "")
 282         require.Nil(t, err)
 283         defer os.RemoveAll(leecherDataDir)
 284         cfg = TestingConfig(t)
 285         cfg.DataDir = leecherDataDir
 286         leecher, err := NewClient(cfg)
 287         require.Nil(t, err)
 288         defer leecher.Close()
 289         leecherTorrent, _, _ := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
 290                 ret = TorrentSpecFromMetaInfo(mi)
 291                 ret.ChunkSize = 2
 292                 return
 293         }())
 294         leecherTorrent.AddClientPeer(seeder)
 295         reader := leecherTorrent.NewReader()
 296         defer reader.Close()
 297         reader.SetReadahead(0)
 298         reader.SetResponsive()
 299         b := make([]byte, 2)
 300         _, err = reader.Seek(3, io.SeekStart)
 301         require.NoError(t, err)
 302         _, err = io.ReadFull(reader, b)
 303         assert.Nil(t, err)
 304         assert.EqualValues(t, "lo", string(b))
 305         go leecherTorrent.Drop()
 306         _, err = reader.Seek(11, io.SeekStart)
 307         require.NoError(t, err)
 308         n, err := reader.Read(b)
 309         assert.EqualError(t, err, "torrent closed")
 310         assert.EqualValues(t, 0, n)
 311 }
 312
 313 func TestDhtInheritBlocklist(t *testing.T) {
 314         ipl := iplist.New(nil)
 315         require.NotNil(t, ipl)
 316         cfg := TestingConfig(t)
 317         cfg.IPBlocklist = ipl
 318         cfg.NoDHT = false
 319         cl, err := NewClient(cfg)
 320         require.NoError(t, err)
 321         defer cl.Close()
 322         numServers := 0
 323         cl.eachDhtServer(func(s DhtServer) {
 324                 t.Log(s)
 325                 assert.Equal(t, ipl, s.(AnacrolixDhtServerWrapper).Server.IPBlocklist())
 326                 numServers++
 327         })
 328         assert.EqualValues(t, 2, numServers)
 329 }
 330
 331 // Check that stuff is merged in subsequent AddTorrentSpec for the same
 332 // infohash.
 333 func TestAddTorrentSpecMerging(t *testing.T) {
 334         cl, err := NewClient(TestingConfig(t))
 335         require.NoError(t, err)
 336         defer cl.Close()
 337         dir, mi := testutil.GreetingTestTorrent()
 338         defer os.RemoveAll(dir)
 339         tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
 340                 InfoHash: mi.HashInfoBytes(),
 341         })
 342         require.NoError(t, err)
 343         require.True(t, new)
 344         require.Nil(t, tt.Info())
 345         _, new, err = cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
 346         require.NoError(t, err)
 347         require.False(t, new)
 348         require.NotNil(t, tt.Info())
 349 }
 350
 351 func TestTorrentDroppedBeforeGotInfo(t *testing.T) {
 352         dir, mi := testutil.GreetingTestTorrent()
 353         os.RemoveAll(dir)
 354         cl, _ := NewClient(TestingConfig(t))
 355         defer cl.Close()
 356         tt, _, _ := cl.AddTorrentSpec(&TorrentSpec{
 357                 InfoHash: mi.HashInfoBytes(),
 358         })
 359         tt.Drop()
 360         assert.EqualValues(t, 0, len(cl.Torrents()))
 361         select {
 362         case <-tt.GotInfo():
 363                 t.FailNow()
 364         default:
 365         }
 366 }
 367
 368 func writeTorrentData(ts *storage.Torrent, info metainfo.Info, b []byte) {
 369         for i := range iter.N(info.NumPieces()) {
 370                 p := info.Piece(i)
 371                 ts.Piece(p).WriteAt(b[p.Offset():p.Offset()+p.Length()], 0)
 372         }
 373 }
 374
 375 func testAddTorrentPriorPieceCompletion(t *testing.T, alreadyCompleted bool, csf func(*filecache.Cache) storage.ClientImpl) {
 376         fileCacheDir, err := ioutil.TempDir("", "")
 377         require.NoError(t, err)
 378         defer os.RemoveAll(fileCacheDir)
 379         fileCache, err := filecache.NewCache(fileCacheDir)
 380         require.NoError(t, err)
 381         greetingDataTempDir, greetingMetainfo := testutil.GreetingTestTorrent()
 382         defer os.RemoveAll(greetingDataTempDir)
 383         filePieceStore := csf(fileCache)
 384         info, err := greetingMetainfo.UnmarshalInfo()
 385         require.NoError(t, err)
 386         ih := greetingMetainfo.HashInfoBytes()
 387         greetingData, err := storage.NewClient(filePieceStore).OpenTorrent(&info, ih)
 388         require.NoError(t, err)
 389         writeTorrentData(greetingData, info, []byte(testutil.GreetingFileContents))
 390         // require.Equal(t, len(testutil.GreetingFileContents), written)
 391         // require.NoError(t, err)
 392         for i := 0; i < info.NumPieces(); i++ {
 393                 p := info.Piece(i)
 394                 if alreadyCompleted {
 395                         require.NoError(t, greetingData.Piece(p).MarkComplete())
 396                 }
 397         }
 398         cfg := TestingConfig(t)
 399         // TODO: Disable network option?
 400         cfg.DisableTCP = true
 401         cfg.DisableUTP = true
 402         cfg.DefaultStorage = filePieceStore
 403         cl, err := NewClient(cfg)
 404         require.NoError(t, err)
 405         defer cl.Close()
 406         tt, err := cl.AddTorrent(greetingMetainfo)
 407         require.NoError(t, err)
 408         psrs := tt.PieceStateRuns()
 409         assert.Len(t, psrs, 1)
 410         assert.EqualValues(t, 3, psrs[0].Length)
 411         assert.Equal(t, alreadyCompleted, psrs[0].Complete)
 412         if alreadyCompleted {
 413                 r := tt.NewReader()
 414                 quicktest.Check(t, iotest.TestReader(r, []byte(testutil.GreetingFileContents)), quicktest.IsNil)
 415         }
 416 }
 417
 418 func TestAddTorrentPiecesAlreadyCompleted(t *testing.T) {
 419         testAddTorrentPriorPieceCompletion(t, true, fileCachePieceResourceStorage)
 420 }
 421
 422 func TestAddTorrentPiecesNotAlreadyCompleted(t *testing.T) {
 423         testAddTorrentPriorPieceCompletion(t, false, fileCachePieceResourceStorage)
 424 }
 425
 426 func TestAddMetainfoWithNodes(t *testing.T) {
 427         cfg := TestingConfig(t)
 428         cfg.ListenHost = func(string) string { return "" }
 429         cfg.NoDHT = false
 430         cfg.DhtStartingNodes = func(string) dht.StartingNodesGetter { return func() ([]dht.Addr, error) { return nil, nil } }
 431         // For now, we want to just jam the nodes into the table, without verifying them first. Also the
 432         // DHT code doesn't support mixing secure and insecure nodes if security is enabled (yet).
 433         // cfg.DHTConfig.NoSecurity = true
 434         cl, err := NewClient(cfg)
 435         require.NoError(t, err)
 436         defer cl.Close()
 437         sum := func() (ret int64) {
 438                 cl.eachDhtServer(func(s DhtServer) {
 439                         ret += s.Stats().(dht.ServerStats).OutboundQueriesAttempted
 440                 })
 441                 return
 442         }
 443         assert.EqualValues(t, 0, sum())
 444         tt, err := cl.AddTorrentFromFile("metainfo/testdata/issue_65a.torrent")
 445         require.NoError(t, err)
 446         // Nodes are not added or exposed in Torrent's metainfo. We just randomly
 447         // check if the announce-list is here instead. TODO: Add nodes.
 448         assert.Len(t, tt.metainfo.AnnounceList, 5)
 449         // There are 6 nodes in the torrent file.
 450         for sum() != int64(6*len(cl.dhtServers)) {
 451                 time.Sleep(time.Millisecond)
 452         }
 453 }
 454
 455 type testDownloadCancelParams struct {
 456         SetLeecherStorageCapacity bool
 457         LeecherStorageCapacity    int64
 458         Cancel                    bool
 459 }
 460
 461 func testDownloadCancel(t *testing.T, ps testDownloadCancelParams) {
 462         greetingTempDir, mi := testutil.GreetingTestTorrent()
 463         defer os.RemoveAll(greetingTempDir)
 464         cfg := TestingConfig(t)
 465         cfg.Seed = true
 466         cfg.DataDir = greetingTempDir
 467         seeder, err := NewClient(cfg)
 468         require.NoError(t, err)
 469         defer seeder.Close()
 470         defer testutil.ExportStatusWriter(seeder, "s", t)()
 471         seederTorrent, _, _ := seeder.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
 472         seederTorrent.VerifyData()
 473         leecherDataDir, err := ioutil.TempDir("", "")
 474         require.NoError(t, err)
 475         defer os.RemoveAll(leecherDataDir)
 476         fc, err := filecache.NewCache(leecherDataDir)
 477         require.NoError(t, err)
 478         if ps.SetLeecherStorageCapacity {
 479                 fc.SetCapacity(ps.LeecherStorageCapacity)
 480         }
 481         cfg.DefaultStorage = storage.NewResourcePieces(fc.AsResourceProvider())
 482         cfg.DataDir = leecherDataDir
 483         leecher, err := NewClient(cfg)
 484         require.NoError(t, err)
 485         defer leecher.Close()
 486         defer testutil.ExportStatusWriter(leecher, "l", t)()
 487         leecherGreeting, new, err := leecher.AddTorrentSpec(func() (ret *TorrentSpec) {
 488                 ret = TorrentSpecFromMetaInfo(mi)
 489                 ret.ChunkSize = 2
 490                 return
 491         }())
 492         require.NoError(t, err)
 493         assert.True(t, new)
 494         psc := leecherGreeting.SubscribePieceStateChanges()
 495         defer psc.Close()
 496
 497         leecherGreeting.cl.lock()
 498         leecherGreeting.downloadPiecesLocked(0, leecherGreeting.numPieces())
 499         if ps.Cancel {
 500                 leecherGreeting.cancelPiecesLocked(0, leecherGreeting.NumPieces())
 501         }
 502         leecherGreeting.cl.unlock()
 503         done := make(chan struct{})
 504         defer close(done)
 505         go leecherGreeting.AddClientPeer(seeder)
 506         completes := make(map[int]bool, 3)
 507         expected := func() map[int]bool {
 508                 if ps.Cancel {
 509                         return map[int]bool{0: false, 1: false, 2: false}
 510                 } else {
 511                         return map[int]bool{0: true, 1: true, 2: true}
 512                 }
 513         }()
 514         for !reflect.DeepEqual(completes, expected) {
 515                 _v := <-psc.Values
 516                 v := _v.(PieceStateChange)
 517                 completes[v.Index] = v.Complete
 518         }
 519 }
 520
 521 func TestTorrentDownloadAll(t *testing.T) {
 522         testDownloadCancel(t, testDownloadCancelParams{})
 523 }
 524
 525 func TestTorrentDownloadAllThenCancel(t *testing.T) {
 526         testDownloadCancel(t, testDownloadCancelParams{
 527                 Cancel: true,
 528         })
 529 }
 530
 531 // Ensure that it's an error for a peer to send an invalid have message.
 532 func TestPeerInvalidHave(t *testing.T) {
 533         cfg := TestingConfig(t)
 534         cfg.DropMutuallyCompletePeers = false
 535         cl, err := NewClient(cfg)
 536         require.NoError(t, err)
 537         defer cl.Close()
 538         info := metainfo.Info{
 539                 PieceLength: 1,
 540                 Pieces:      make([]byte, 20),
 541                 Files:       []metainfo.FileInfo{{Length: 1}},
 542         }
 543         infoBytes, err := bencode.Marshal(info)
 544         require.NoError(t, err)
 545         tt, _new, err := cl.AddTorrentSpec(&TorrentSpec{
 546                 InfoBytes: infoBytes,
 547                 InfoHash:  metainfo.HashBytes(infoBytes),
 548                 Storage:   badStorage{},
 549         })
 550         require.NoError(t, err)
 551         assert.True(t, _new)
 552         defer tt.Drop()
 553         cn := &PeerConn{Peer: Peer{
 554                 t: tt,
 555         }}
 556         cn.peerImpl = cn
 557         cl.lock()
 558         defer cl.unlock()
 559         assert.NoError(t, cn.peerSentHave(0))
 560         assert.Error(t, cn.peerSentHave(1))
 561 }
 562
 563 func TestPieceCompletedInStorageButNotClient(t *testing.T) {
 564         greetingTempDir, greetingMetainfo := testutil.GreetingTestTorrent()
 565         defer os.RemoveAll(greetingTempDir)
 566         cfg := TestingConfig(t)
 567         cfg.DataDir = greetingTempDir
 568         seeder, err := NewClient(TestingConfig(t))
 569         require.NoError(t, err)
 570         seeder.AddTorrentSpec(&TorrentSpec{
 571                 InfoBytes: greetingMetainfo.InfoBytes,
 572         })
 573 }
 574
 575 // Check that when the listen port is 0, all the protocols listened on have
 576 // the same port, and it isn't zero.
 577 func TestClientDynamicListenPortAllProtocols(t *testing.T) {
 578         cl, err := NewClient(TestingConfig(t))
 579         require.NoError(t, err)
 580         defer cl.Close()
 581         port := cl.LocalPort()
 582         assert.NotEqual(t, 0, port)
 583         cl.eachListener(func(s Listener) bool {
 584                 assert.Equal(t, port, missinggo.AddrPort(s.Addr()))
 585                 return true
 586         })
 587 }
 588
 589 func TestClientDynamicListenTCPOnly(t *testing.T) {
 590         cfg := TestingConfig(t)
 591         cfg.DisableUTP = true
 592         cfg.DisableTCP = false
 593         cl, err := NewClient(cfg)
 594         require.NoError(t, err)
 595         defer cl.Close()
 596         assert.NotEqual(t, 0, cl.LocalPort())
 597 }
 598
 599 func TestClientDynamicListenUTPOnly(t *testing.T) {
 600         cfg := TestingConfig(t)
 601         cfg.DisableTCP = true
 602         cfg.DisableUTP = false
 603         cl, err := NewClient(cfg)
 604         require.NoError(t, err)
 605         defer cl.Close()
 606         assert.NotEqual(t, 0, cl.LocalPort())
 607 }
 608
 609 func totalConns(tts []*Torrent) (ret int) {
 610         for _, tt := range tts {
 611                 tt.cl.lock()
 612                 ret += len(tt.conns)
 613                 tt.cl.unlock()
 614         }
 615         return
 616 }
 617
 618 func TestSetMaxEstablishedConn(t *testing.T) {
 619         var tts []*Torrent
 620         ih := testutil.GreetingMetaInfo().HashInfoBytes()
 621         cfg := TestingConfig(t)
 622         cfg.DisableAcceptRateLimiting = true
 623         cfg.DropDuplicatePeerIds = true
 624         for i := range iter.N(3) {
 625                 cl, err := NewClient(cfg)
 626                 require.NoError(t, err)
 627                 defer cl.Close()
 628                 tt, _ := cl.AddTorrentInfoHash(ih)
 629                 tt.SetMaxEstablishedConns(2)
 630                 defer testutil.ExportStatusWriter(cl, fmt.Sprintf("%d", i), t)()
 631                 tts = append(tts, tt)
 632         }
 633         addPeers := func() {
 634                 for _, tt := range tts {
 635                         for _, _tt := range tts {
 636                                 // if tt != _tt {
 637                                 tt.AddClientPeer(_tt.cl)
 638                                 // }
 639                         }
 640                 }
 641         }
 642         waitTotalConns := func(num int) {
 643                 for totalConns(tts) != num {
 644                         addPeers()
 645                         time.Sleep(time.Millisecond)
 646                 }
 647         }
 648         addPeers()
 649         waitTotalConns(6)
 650         tts[0].SetMaxEstablishedConns(1)
 651         waitTotalConns(4)
 652         tts[0].SetMaxEstablishedConns(0)
 653         waitTotalConns(2)
 654         tts[0].SetMaxEstablishedConns(1)
 655         addPeers()
 656         waitTotalConns(4)
 657         tts[0].SetMaxEstablishedConns(2)
 658         addPeers()
 659         waitTotalConns(6)
 660 }
 661
 662 // Creates a file containing its own name as data. Make a metainfo from that, adds it to the given
 663 // client, and returns a magnet link.
 664 func makeMagnet(t *testing.T, cl *Client, dir string, name string) string {
 665         os.MkdirAll(dir, 0770)
 666         file, err := os.Create(filepath.Join(dir, name))
 667         require.NoError(t, err)
 668         file.Write([]byte(name))
 669         file.Close()
 670         mi := metainfo.MetaInfo{}
 671         mi.SetDefaults()
 672         info := metainfo.Info{PieceLength: 256 * 1024}
 673         err = info.BuildFromFilePath(filepath.Join(dir, name))
 674         require.NoError(t, err)
 675         mi.InfoBytes, err = bencode.Marshal(info)
 676         require.NoError(t, err)
 677         magnet := mi.Magnet(nil, &info).String()
 678         tr, err := cl.AddTorrent(&mi)
 679         require.NoError(t, err)
 680         require.True(t, tr.Seeding())
 681         tr.VerifyData()
 682         return magnet
 683 }
 684
 685 // https://github.com/anacrolix/torrent/issues/114
 686 func TestMultipleTorrentsWithEncryption(t *testing.T) {
 687         testSeederLeecherPair(
 688                 t,
 689                 func(cfg *ClientConfig) {
 690                         cfg.HeaderObfuscationPolicy.Preferred = true
 691                         cfg.HeaderObfuscationPolicy.RequirePreferred = true
 692                 },
 693                 func(cfg *ClientConfig) {
 694                         cfg.HeaderObfuscationPolicy.RequirePreferred = false
 695                 },
 696         )
 697 }
 698
 699 // Test that the leecher can download a torrent in its entirety from the seeder. Note that the
 700 // seeder config is done first.
 701 func testSeederLeecherPair(t *testing.T, seeder func(*ClientConfig), leecher func(*ClientConfig)) {
 702         cfg := TestingConfig(t)
 703         cfg.Seed = true
 704         cfg.DataDir = filepath.Join(cfg.DataDir, "server")
 705         os.Mkdir(cfg.DataDir, 0755)
 706         seeder(cfg)
 707         server, err := NewClient(cfg)
 708         require.NoError(t, err)
 709         defer server.Close()
 710         defer testutil.ExportStatusWriter(server, "s", t)()
 711         magnet1 := makeMagnet(t, server, cfg.DataDir, "test1")
 712         // Extra torrents are added to test the seeder having to match incoming obfuscated headers
 713         // against more than one torrent. See issue #114
 714         makeMagnet(t, server, cfg.DataDir, "test2")
 715         for i := 0; i < 100; i++ {
 716                 makeMagnet(t, server, cfg.DataDir, fmt.Sprintf("test%d", i+2))
 717         }
 718         cfg = TestingConfig(t)
 719         cfg.DataDir = filepath.Join(cfg.DataDir, "client")
 720         leecher(cfg)
 721         client, err := NewClient(cfg)
 722         require.NoError(t, err)
 723         defer client.Close()
 724         defer testutil.ExportStatusWriter(client, "c", t)()
 725         tr, err := client.AddMagnet(magnet1)
 726         require.NoError(t, err)
 727         tr.AddClientPeer(server)
 728         <-tr.GotInfo()
 729         tr.DownloadAll()
 730         client.WaitAll()
 731 }
 732
 733 // This appears to be the situation with the S3 BitTorrent client.
 734 func TestObfuscatedHeaderFallbackSeederDisallowsLeecherPrefers(t *testing.T) {
 735         // Leecher prefers obfuscation, but the seeder does not allow it.
 736         testSeederLeecherPair(
 737                 t,
 738                 func(cfg *ClientConfig) {
 739                         cfg.HeaderObfuscationPolicy.Preferred = false
 740                         cfg.HeaderObfuscationPolicy.RequirePreferred = true
 741                 },
 742                 func(cfg *ClientConfig) {
 743                         cfg.HeaderObfuscationPolicy.Preferred = true
 744                         cfg.HeaderObfuscationPolicy.RequirePreferred = false
 745                 },
 746         )
 747 }
 748
 749 func TestObfuscatedHeaderFallbackSeederRequiresLeecherPrefersNot(t *testing.T) {
 750         // Leecher prefers no obfuscation, but the seeder enforces it.
 751         testSeederLeecherPair(
 752                 t,
 753                 func(cfg *ClientConfig) {
 754                         cfg.HeaderObfuscationPolicy.Preferred = true
 755                         cfg.HeaderObfuscationPolicy.RequirePreferred = true
 756                 },
 757                 func(cfg *ClientConfig) {
 758                         cfg.HeaderObfuscationPolicy.Preferred = false
 759                         cfg.HeaderObfuscationPolicy.RequirePreferred = false
 760                 },
 761         )
 762 }
 763
 764 func TestClientAddressInUse(t *testing.T) {
 765         s, _ := NewUtpSocket("udp", ":50007", nil)
 766         if s != nil {
 767                 defer s.Close()
 768         }
 769         cfg := TestingConfig(t).SetListenAddr(":50007")
 770         cl, err := NewClient(cfg)
 771         require.Error(t, err)
 772         require.Nil(t, cl)
 773 }
 774
 775 func TestClientHasDhtServersWhenUtpDisabled(t *testing.T) {
 776         cc := TestingConfig(t)
 777         cc.DisableUTP = true
 778         cc.NoDHT = false
 779         cl, err := NewClient(cc)
 780         require.NoError(t, err)
 781         defer cl.Close()
 782         assert.NotEmpty(t, cl.DhtServers())
 783 }
 784
 785 func TestIssue335(t *testing.T) {
 786         dir, mi := testutil.GreetingTestTorrent()
 787         defer os.RemoveAll(dir)
 788         cfg := TestingConfig(t)
 789         cfg.Seed = false
 790         cfg.Debug = true
 791         cfg.DataDir = dir
 792         comp, err := storage.NewBoltPieceCompletion(dir)
 793         require.NoError(t, err)
 794         defer comp.Close()
 795         cfg.DefaultStorage = storage.NewMMapWithCompletion(dir, comp)
 796         cl, err := NewClient(cfg)
 797         require.NoError(t, err)
 798         defer cl.Close()
 799         tor, new, err := cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
 800         require.NoError(t, err)
 801         assert.True(t, new)
 802         require.True(t, cl.WaitAll())
 803         tor.Drop()
 804         _, new, err = cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
 805         require.NoError(t, err)
 806         assert.True(t, new)
 807         require.True(t, cl.WaitAll())
 808 }
 809
 810 func TestClientDisabledImplicitNetworksButDhtEnabled(t *testing.T) {
 811         cfg := TestingConfig(t)
 812         cfg.DisableTCP = true
 813         cfg.DisableUTP = true
 814         cfg.NoDHT = false
 815         cl, err := NewClient(cfg)
 816         require.NoError(t, err)
 817         defer cl.Close()
 818         assert.Empty(t, cl.listeners)
 819         assert.NotEmpty(t, cl.DhtServers())
 820 }