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