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