"bufio"
"context"
"crypto/rand"
+ "crypto/sha1"
"encoding/binary"
"errors"
+ "expvar"
"fmt"
"io"
+ "math"
"net"
"net/http"
+ "net/netip"
+ "sort"
"strconv"
"strings"
"time"
+ "github.com/davecgh/go-spew/spew"
+ "github.com/dustin/go-humanize"
+ gbtree "github.com/google/btree"
+ "github.com/pion/datachannel"
+ "golang.org/x/time/rate"
+
+ "github.com/anacrolix/chansync"
+ "github.com/anacrolix/chansync/events"
"github.com/anacrolix/dht/v2"
"github.com/anacrolix/dht/v2/krpc"
+ "github.com/anacrolix/generics"
+ . "github.com/anacrolix/generics"
"github.com/anacrolix/log"
"github.com/anacrolix/missinggo/perf"
- "github.com/anacrolix/missinggo/pubsub"
- "github.com/anacrolix/missinggo/slices"
"github.com/anacrolix/missinggo/v2"
"github.com/anacrolix/missinggo/v2/bitmap"
"github.com/anacrolix/missinggo/v2/pproffd"
"github.com/anacrolix/sync"
- "github.com/davecgh/go-spew/spew"
- "github.com/dustin/go-humanize"
- "github.com/google/btree"
- "github.com/pion/datachannel"
- "golang.org/x/time/rate"
- "golang.org/x/xerrors"
-
- "github.com/anacrolix/chansync"
"github.com/anacrolix/torrent/bencode"
"github.com/anacrolix/torrent/internal/limiter"
"github.com/anacrolix/torrent/metainfo"
"github.com/anacrolix/torrent/mse"
pp "github.com/anacrolix/torrent/peer_protocol"
+ request_strategy "github.com/anacrolix/torrent/request-strategy"
"github.com/anacrolix/torrent/storage"
"github.com/anacrolix/torrent/tracker"
"github.com/anacrolix/torrent/webtorrent"
_mu lockWithDeferreds
event sync.Cond
- closed missinggo.Event
+ closed chansync.SetOnce
config *ClientConfig
logger log.Logger
// include ourselves if we end up trying to connect to our own address
// through legitimate channels.
dopplegangerAddrs map[string]struct{}
- badPeerIPs map[string]struct{}
+ badPeerIPs map[netip.Addr]struct{}
torrents map[InfoHash]*Torrent
+ pieceRequestOrder map[interface{}]*request_strategy.PieceRequestOrder
acceptLimiter map[ipStr]int
dialRateLimiter *rate.Limiter
websocketTrackers websocketTrackers
activeAnnounceLimiter limiter.Instance
-
- updateRequests chansync.BroadcastCond
+ httpClient *http.Client
}
type ipStr string
-func (cl *Client) BadPeerIPs() []string {
+func (cl *Client) BadPeerIPs() (ips []string) {
cl.rLock()
- defer cl.rUnlock()
- return cl.badPeerIPsLocked()
+ ips = cl.badPeerIPsLocked()
+ cl.rUnlock()
+ return
}
-func (cl *Client) badPeerIPsLocked() []string {
- return slices.FromMapKeys(cl.badPeerIPs).([]string)
+func (cl *Client) badPeerIPsLocked() (ips []string) {
+ ips = make([]string, len(cl.badPeerIPs))
+ i := 0
+ for k := range cl.badPeerIPs {
+ ips[i] = k.String()
+ i += 1
+ }
+ return
}
func (cl *Client) PeerID() PeerID {
// numbers are the same, due to support for custom listeners. Returns zero if no port number is
// found.
func (cl *Client) LocalPort() (port int) {
- cl.eachListener(func(l Listener) bool {
- port = addrPortOrZero(l.Addr())
- return port == 0
- })
+ for i := 0; i < len(cl.listeners); i += 1 {
+ if port = addrPortOrZero(cl.listeners[i].Addr()); port != 0 {
+ return
+ }
+ }
return
}
writeDhtServerStatus(w, s)
})
spew.Fdump(w, &cl.stats)
- fmt.Fprintf(w, "# Torrents: %d\n", len(cl.torrentsAsSlice()))
+ torrentsSlice := cl.torrentsAsSlice()
+ fmt.Fprintf(w, "# Torrents: %d\n", len(torrentsSlice))
fmt.Fprintln(w)
- for _, t := range slices.Sort(cl.torrentsAsSlice(), func(l, r *Torrent) bool {
- return l.InfoHash().AsString() < r.InfoHash().AsString()
- }).([]*Torrent) {
+ sort.Slice(torrentsSlice, func(l, r int) bool {
+ return torrentsSlice[l].infoHash.AsString() < torrentsSlice[r].infoHash.AsString()
+ })
+ for _, t := range torrentsSlice {
if t.name() == "" {
fmt.Fprint(w, "<unknown name>")
} else {
w,
"%f%% of %d bytes (%s)",
100*(1-float64(t.bytesMissingLocked())/float64(t.info.TotalLength())),
- *t.length,
- humanize.Bytes(uint64(*t.length)))
+ t.length(),
+ humanize.Bytes(uint64(t.length())))
} else {
w.WriteString("<missing metainfo>")
}
}
}
-// Filters things that are less than warning from UPnP discovery.
-func upnpDiscoverLogFilter(m log.Msg) bool {
- level, ok := m.GetLevel()
- return !m.HasValue(UpnpDiscoverLogTag) || (!level.LessThan(log.Warning) && ok)
-}
-
func (cl *Client) initLogger() {
logger := cl.config.Logger
if logger.IsZero() {
logger = log.Default
- if !cl.config.Debug {
- logger = logger.FilterLevel(log.Info).WithFilter(upnpDiscoverLogFilter)
- }
+ }
+ if cl.config.Debug {
+ logger = logger.FilterLevel(log.Debug)
}
cl.logger = logger.WithValues(cl)
}
return int32(binary.BigEndian.Uint32(cl.peerID[16:20]))
}
+// Initializes a bare minimum Client. *Client and *ClientConfig must not be nil.
+func (cl *Client) init(cfg *ClientConfig) {
+ cl.config = cfg
+ generics.MakeMap(&cl.dopplegangerAddrs)
+ cl.torrents = make(map[metainfo.Hash]*Torrent)
+ cl.dialRateLimiter = rate.NewLimiter(10, 10)
+ cl.activeAnnounceLimiter.SlotsPerKey = 2
+ cl.event.L = cl.locker()
+ cl.ipBlockList = cfg.IPBlocklist
+ cl.httpClient = &http.Client{
+ Transport: &http.Transport{
+ Proxy: cfg.HTTPProxy,
+ // I think this value was observed from some webseeds. It seems reasonable to extend it
+ // to other uses of HTTP from the client.
+ MaxConnsPerHost: 10,
+ },
+ }
+}
+
func NewClient(cfg *ClientConfig) (cl *Client, err error) {
if cfg == nil {
cfg = NewDefaultClientConfig()
cfg.ListenPort = 0
}
- defer func() {
- if err != nil {
- cl = nil
- }
- }()
- cl = &Client{
- config: cfg,
- dopplegangerAddrs: make(map[string]struct{}),
- torrents: make(map[metainfo.Hash]*Torrent),
- dialRateLimiter: rate.NewLimiter(10, 10),
- }
- cl.activeAnnounceLimiter.SlotsPerKey = 2
+ var client Client
+ client.init(cfg)
+ cl = &client
go cl.acceptLimitClearer()
cl.initLogger()
defer func() {
- if err == nil {
- return
+ if err != nil {
+ cl.Close()
+ cl = nil
}
- cl.Close()
}()
- cl.event.L = cl.locker()
+
storageImpl := cfg.DefaultStorage
if storageImpl == nil {
// We'd use mmap by default but HFS+ doesn't support sparse files.
storageImpl = storageImplCloser
}
cl.defaultStorage = storage.NewClient(storageImpl)
- if cfg.IPBlocklist != nil {
- cl.ipBlockList = cfg.IPBlocklist
- }
if cfg.PeerID != "" {
missinggo.CopyExact(&cl.peerID, cfg.PeerID)
}
}
- sockets, err := listenAll(cl.listenNetworks(), cl.config.ListenHost, cl.config.ListenPort, cl.firewallCallback)
+ sockets, err := listenAll(cl.listenNetworks(), cl.config.ListenHost, cl.config.ListenPort, cl.firewallCallback, cl.logger)
if err != nil {
return
}
for _, _s := range sockets {
s := _s // Go is fucking retarded.
- cl.onClose = append(cl.onClose, func() { s.Close() })
+ cl.onClose = append(cl.onClose, func() { go s.Close() })
if peerNetworkEnabled(parseNetworkString(s.Addr().Network()), cl.config) {
cl.dialers = append(cl.dialers, s)
cl.listeners = append(cl.listeners, s)
}
return t.announceRequest(event), nil
},
+ Proxy: cl.config.HTTPProxy,
OnConn: func(dc datachannel.ReadWriteCloser, dcc webtorrent.DataChannelContext) {
cl.lock()
defer cl.unlock()
},
}
- go cl.requester()
-
return
}
// Creates an anacrolix/dht Server, as would be done internally in NewClient, for the given conn.
func (cl *Client) NewAnacrolixDhtServer(conn net.PacketConn) (s *dht.Server, err error) {
+ logger := cl.logger.WithNames("dht", conn.LocalAddr().String())
cfg := dht.ServerConfig{
IPBlocklist: cl.ipBlockList,
Conn: conn,
}(),
StartingNodes: cl.config.DhtStartingNodes(conn.LocalAddr().Network()),
OnQuery: cl.config.DHTOnQuery,
- Logger: cl.logger.WithContextText(fmt.Sprintf("dht server on %v", conn.LocalAddr().String())),
+ Logger: logger,
}
if f := cl.config.ConfigureAnacrolixDhtServer; f != nil {
f(&cfg)
go func() {
ts, err := s.Bootstrap()
if err != nil {
- cl.logger.Printf("error bootstrapping dht: %s", err)
+ logger.Levelf(log.Warning, "error bootstrapping dht: %s", err)
}
- log.Fstr("%v completed bootstrap (%v)", s, ts).AddValues(s, ts).Log(cl.logger)
+ logger.Levelf(log.Debug, "completed bootstrap: %+v", ts)
}()
}
return
}
-func (cl *Client) Closed() <-chan struct{} {
- cl.lock()
- defer cl.unlock()
- return cl.closed.C()
+func (cl *Client) Closed() events.Done {
+ return cl.closed.Done()
}
func (cl *Client) eachDhtServer(f func(DhtServer)) {
}
}
-// Stops the client. All connections to peers are closed and all activity will
-// come to a halt.
-func (cl *Client) Close() {
+// Stops the client. All connections to peers are closed and all activity will come to a halt.
+func (cl *Client) Close() (errs []error) {
+ var closeGroup sync.WaitGroup // For concurrent cleanup to complete before returning
cl.lock()
- defer cl.unlock()
- cl.closed.Set()
for _, t := range cl.torrents {
- t.close()
+ err := t.close(&closeGroup)
+ if err != nil {
+ errs = append(errs, err)
+ }
}
for i := range cl.onClose {
cl.onClose[len(cl.onClose)-1-i]()
}
+ cl.closed.Set()
+ cl.unlock()
cl.event.Broadcast()
+ closeGroup.Wait() // defer is LIFO. We want to Wait() after cl.unlock()
+ return
}
func (cl *Client) ipBlockRange(ip net.IP) (r iplist.Range, blocked bool) {
}
func (cl *Client) wantConns() bool {
+ if cl.config.AlwaysWantConns {
+ return true
+ }
for _, t := range cl.torrents {
if t.wantConns() {
return true
return false
}
-func (cl *Client) waitAccept() {
- for {
- if cl.closed.IsSet() {
- return
- }
- if cl.wantConns() {
- return
- }
- cl.event.Wait()
- }
-}
-
// TODO: Apply filters for non-standard networks, particularly rate-limiting.
func (cl *Client) rejectAccepted(conn net.Conn) error {
+ if !cl.wantConns() {
+ return errors.New("don't want conns right now")
+ }
ra := conn.RemoteAddr()
if rip := addrIpOrNil(ra); rip != nil {
if cl.config.DisableIPv4Peers && rip.To4() != nil {
}
if cl.config.DisableIPv4 && len(rip) == net.IPv4len {
return errors.New("ipv4 disabled")
-
}
if cl.config.DisableIPv6 && len(rip) == net.IPv6len && rip.To4() == nil {
return errors.New("ipv6 disabled")
cl.rLock()
closed := cl.closed.IsSet()
var reject error
- if conn != nil {
+ if !closed && conn != nil {
reject = cl.rejectAccepted(conn)
}
cl.rUnlock()
return
}
if err != nil {
- log.Fmsg("error accepting connection: %s", err).SetLevel(log.Debug).Log(cl.logger)
+ log.Fmsg("error accepting connection: %s", err).LogLevel(log.Debug, cl.logger)
continue
}
go func() {
if reject != nil {
torrent.Add("rejected accepted connections", 1)
- log.Fmsg("rejecting accepted conn: %v", reject).SetLevel(log.Debug).Log(cl.logger)
+ cl.logger.LazyLog(log.Debug, func() log.Msg {
+ return log.Fmsg("rejecting accepted conn: %v", reject)
+ })
conn.Close()
} else {
go cl.incomingConnection(conn)
}
- log.Fmsg("accepted %q connection at %q from %q",
- l.Addr().Network(),
- conn.LocalAddr(),
- conn.RemoteAddr(),
- ).SetLevel(log.Debug).Log(cl.logger)
+ cl.logger.LazyLog(log.Debug, func() log.Msg {
+ return log.Fmsg("accepted %q connection at %q from %q",
+ l.Addr().Network(),
+ conn.LocalAddr(),
+ conn.RemoteAddr(),
+ )
+ })
torrent.Add(fmt.Sprintf("accepted conn remote IP len=%d", len(addrIpOrNil(conn.RemoteAddr()))), 1)
torrent.Add(fmt.Sprintf("accepted conn network=%s", conn.RemoteAddr().Network()), 1)
torrent.Add(fmt.Sprintf("accepted on %s listener", l.Addr().Network()), 1)
}
c := cl.newConnection(nc, false, nc.RemoteAddr(), nc.RemoteAddr().Network(),
regularNetConnPeerConnConnString(nc))
- defer c.close()
+ defer func() {
+ cl.lock()
+ defer cl.unlock()
+ c.close()
+ }()
c.Discovery = PeerSourceIncoming
cl.runReceivedConn(c)
}
return cl.torrents[ih]
}
-type dialResult struct {
- Conn net.Conn
- Network string
+type DialResult struct {
+ Conn net.Conn
+ Dialer Dialer
}
func countDialResult(err error) {
}
}
-func reducedDialTimeout(minDialTimeout, max time.Duration, halfOpenLimit int, pendingPeers int) (ret time.Duration) {
+func reducedDialTimeout(minDialTimeout, max time.Duration, halfOpenLimit, pendingPeers int) (ret time.Duration) {
ret = max / time.Duration((pendingPeers+halfOpenLimit)/halfOpenLimit)
if ret < minDialTimeout {
ret = minDialTimeout
}
// Returns a connection over UTP or TCP, whichever is first to connect.
-func (cl *Client) dialFirst(ctx context.Context, addr string) (res dialResult) {
+func (cl *Client) dialFirst(ctx context.Context, addr string) (res DialResult) {
+ return DialFirst(ctx, addr, cl.dialers)
+}
+
+// Returns a connection over UTP or TCP, whichever is first to connect.
+func DialFirst(ctx context.Context, addr string, dialers []Dialer) (res DialResult) {
{
t := perf.NewTimer(perf.CallerName(0))
defer func() {
if res.Conn == nil {
t.Mark(fmt.Sprintf("returned no conn (context: %v)", ctx.Err()))
} else {
- t.Mark("returned conn over " + res.Network)
+ t.Mark("returned conn over " + res.Dialer.DialerNetwork())
}
}()
}
// As soon as we return one connection, cancel the others.
defer cancel()
left := 0
- resCh := make(chan dialResult, left)
- func() {
- cl.lock()
- defer cl.unlock()
- cl.eachDialer(func(s Dialer) bool {
- func() {
- left++
- //cl.logger.Printf("dialing %s on %s/%s", addr, s.Addr().Network(), s.Addr())
- go func() {
- resCh <- dialResult{
- cl.dialFromSocket(ctx, s, addr),
- s.LocalAddr().Network(),
- }
- }()
- }()
- return true
- })
- }()
+ resCh := make(chan DialResult, left)
+ for _, _s := range dialers {
+ left++
+ s := _s
+ go func() {
+ resCh <- DialResult{
+ dialFromSocket(ctx, s, addr),
+ s,
+ }
+ }()
+ }
// Wait for a successful connection.
func() {
defer perf.ScopeTimer()()
if res.Conn != nil {
go torrent.Add(fmt.Sprintf("network dialed first: %s", res.Conn.RemoteAddr().Network()), 1)
}
- //if res.Conn != nil {
- // cl.logger.Printf("first connection for %s from %s/%s", addr, res.Conn.LocalAddr().Network(), res.Conn.LocalAddr().String())
- //} else {
- // cl.logger.Printf("failed to dial %s", addr)
- //}
return res
}
-func (cl *Client) dialFromSocket(ctx context.Context, s Dialer, addr string) net.Conn {
+func dialFromSocket(ctx context.Context, s Dialer, addr string) net.Conn {
c, err := s.Dial(ctx, addr)
// This is a bit optimistic, but it looks non-trivial to thread this through the proxy code. Set
// it now in case we close the connection forthwith.
nc := dr.Conn
if nc == nil {
if dialCtx.Err() != nil {
- return nil, xerrors.Errorf("dialing: %w", dialCtx.Err())
+ return nil, fmt.Errorf("dialing: %w", dialCtx.Err())
}
return nil, errors.New("dial failed")
}
- c, err := cl.initiateProtocolHandshakes(context.Background(), nc, t, true, obfuscatedHeader, addr, dr.Network, regularNetConnPeerConnConnString(nc))
+ c, err := cl.initiateProtocolHandshakes(context.Background(), nc, t, true, obfuscatedHeader, addr, dr.Dialer.DialerNetwork(), regularNetConnPeerConnConnString(nc))
if err != nil {
nc.Close()
}
torrent.Add("initiated conn with preferred header obfuscation", 1)
return
}
- //cl.logger.Printf("error establishing connection to %s (obfuscatedHeader=%t): %v", addr, obfuscatedHeaderFirst, err)
+ // cl.logger.Printf("error establishing connection to %s (obfuscatedHeader=%t): %v", addr, obfuscatedHeaderFirst, err)
if cl.config.HeaderObfuscationPolicy.RequirePreferred {
// We should have just tried with the preferred header obfuscation. If it was required,
// there's nothing else to try.
if err == nil {
torrent.Add("initiated conn with fallback header obfuscation", 1)
}
- //cl.logger.Printf("error establishing fallback connection to %v: %v", addr, err)
+ // cl.logger.Printf("error establishing fallback connection to %v: %v", addr, err)
return
}
func (cl *Client) outgoingConnection(t *Torrent, addr PeerRemoteAddr, ps PeerSource, trusted bool) {
cl.dialRateLimiter.Wait(context.Background())
c, err := cl.establishOutgoingConn(t, addr)
+ if err == nil {
+ c.conn.SetWriteDeadline(time.Time{})
+ }
cl.lock()
defer cl.unlock()
// Don't release lock between here and addPeerConn, unless it's for
cl.noLongerHalfOpen(t, addr.String())
if err != nil {
if cl.config.Debug {
- cl.logger.Printf("error establishing outgoing connection to %v: %v", addr, err)
+ cl.logger.Levelf(log.Debug, "error establishing outgoing connection to %v: %v", addr, err)
}
return
}
)
c.setRW(rw)
if err != nil {
- return xerrors.Errorf("header obfuscation handshake: %w", err)
+ return fmt.Errorf("header obfuscation handshake: %w", err)
}
}
ih, err := cl.connBtHandshake(c, &t.infoHash)
if err != nil {
- return xerrors.Errorf("bittorrent protocol handshake: %w", err)
+ return fmt.Errorf("bittorrent protocol handshake: %w", err)
}
if ih != t.infoHash {
return errors.New("bittorrent protocol handshake: peer infohash didn't match")
}
ih, err := cl.connBtHandshake(c, nil)
if err != nil {
- err = xerrors.Errorf("during bt handshake: %w", err)
- return
+ return nil, fmt.Errorf("during bt handshake: %w", err)
}
cl.lock()
t = cl.torrents[ih]
return
}
+var successfulPeerWireProtocolHandshakePeerReservedBytes expvar.Map
+
+func init() {
+ torrent.Set(
+ "successful_peer_wire_protocol_handshake_peer_reserved_bytes",
+ &successfulPeerWireProtocolHandshakePeerReservedBytes)
+}
+
func (cl *Client) connBtHandshake(c *PeerConn, ih *metainfo.Hash) (ret metainfo.Hash, err error) {
res, err := pp.Handshake(c.rw(), ih, cl.peerID, cl.config.Extensions)
if err != nil {
return
}
+ successfulPeerWireProtocolHandshakePeerReservedBytes.Add(res.PeerExtensionBits.String(), 1)
ret = res.Hash
c.PeerExtensionBytes = res.PeerExtensionBits
c.PeerID = res.PeerID
}
t, err := cl.receiveHandshakes(c)
if err != nil {
- log.Fmsg(
- "error receiving handshakes on %v: %s", c, err,
- ).SetLevel(log.Debug).
- Add(
+ cl.logger.LazyLog(log.Debug, func() log.Msg {
+ return log.Fmsg(
+ "error receiving handshakes on %v: %s", c, err,
+ ).Add(
"network", c.Network,
- ).Log(cl.logger)
+ )
+ })
torrent.Add("error receiving handshake", 1)
cl.lock()
cl.onBadAccept(c.RemoteAddr)
}
if t == nil {
torrent.Add("received handshake for unloaded torrent", 1)
- log.Fmsg("received handshake for unloaded torrent").SetLevel(log.Debug).Log(cl.logger)
+ cl.logger.LazyLog(log.Debug, func() log.Msg {
+ return log.Fmsg("received handshake for unloaded torrent")
+ })
cl.lock()
cl.onBadAccept(c.RemoteAddr)
cl.unlock()
return
}
torrent.Add("received handshake for loaded torrent", 1)
+ c.conn.SetWriteDeadline(time.Time{})
cl.lock()
defer cl.unlock()
t.runHandshookConnLoggingErr(c)
// Client lock must be held before entering this.
func (cl *Client) runHandshookConn(c *PeerConn, t *Torrent) error {
c.setTorrent(t)
+ for i, b := range cl.config.MinPeerExtensions {
+ if c.PeerExtensionBytes[i]&b != b {
+ return fmt.Errorf("peer did not meet minimum peer extensions: %x", c.PeerExtensionBytes[:])
+ }
+ }
if c.PeerID == cl.peerID {
if c.outgoing {
connsToSelf.Add(1)
- addr := c.conn.RemoteAddr().String()
+ addr := c.RemoteAddr.String()
cl.dopplegangerAddrs[addr] = struct{}{}
- } else {
+ } /* else {
// Because the remote address is not necessarily the same as its client's torrent listen
// address, we won't record the remote address as a doppleganger. Instead, the initiator
// can record *us* as the doppleganger.
- }
- return errors.New("local and remote peer ids are the same")
+ } */
+ t.logger.Levelf(log.Debug, "local and remote peer ids are the same")
+ return nil
}
- c.conn.SetWriteDeadline(time.Time{})
c.r = deadlineReader{c.conn, c.r}
completedHandshakeConnectionFlags.Add(c.connectionFlags(), 1)
if connIsIpv6(c.conn) {
defer t.dropConnection(c)
c.startWriter()
cl.sendInitialMessages(c, t)
+ c.initUpdateRequestsTimer()
err := c.mainReadLoop()
if err != nil {
return fmt.Errorf("main read loop: %w", err)
return nil
}
+const check = false
+
+func (p *Peer) initUpdateRequestsTimer() {
+ if check {
+ if p.updateRequestsTimer != nil {
+ panic(p.updateRequestsTimer)
+ }
+ }
+ if enableUpdateRequestsTimer {
+ p.updateRequestsTimer = time.AfterFunc(math.MaxInt64, p.updateRequestsTimerFunc)
+ }
+}
+
+const peerUpdateRequestsTimerReason = "updateRequestsTimer"
+
+func (c *Peer) updateRequestsTimerFunc() {
+ c.locker().Lock()
+ defer c.locker().Unlock()
+ if c.closed.IsSet() {
+ return
+ }
+ if c.isLowOnRequests() {
+ // If there are no outstanding requests, then a request update should have already run.
+ return
+ }
+ if d := time.Since(c.lastRequestUpdate); d < updateRequestsTimerDuration {
+ // These should be benign, Timer.Stop doesn't guarantee that its function won't run if it's
+ // already been fired.
+ torrent.Add("spurious timer requests updates", 1)
+ return
+ }
+ c.updateRequests(peerUpdateRequestsTimerReason)
+}
+
// Maximum pending requests we allow peers to send us. If peer requests are buffered on read, this
// instructs the amount of memory that might be used to cache pending writes. Assuming 512KiB
// (1<<19) cached for sending, for 16KiB (1<<14) chunks.
}
func (cl *Client) dhtPort() (ret uint16) {
- cl.eachDhtServer(func(s DhtServer) {
- ret = uint16(missinggo.AddrPort(s.Addr()))
- })
- return
+ if len(cl.dhtServers) == 0 {
+ return
+ }
+ return uint16(missinggo.AddrPort(cl.dhtServers[len(cl.dhtServers)-1].Addr()))
}
-func (cl *Client) haveDhtServer() (ret bool) {
- cl.eachDhtServer(func(_ DhtServer) {
- ret = true
- })
- return
+func (cl *Client) haveDhtServer() bool {
+ return len(cl.dhtServers) > 0
}
// Process incoming ut_metadata message.
return false
}
+// Returns whether the IP address and port are considered "bad".
func (cl *Client) badPeerIPPort(ip net.IP, port int) bool {
- if port == 0 {
+ if port == 0 || ip == nil {
return true
}
if cl.dopplegangerAddr(net.JoinHostPort(ip.String(), strconv.FormatInt(int64(port), 10))) {
if _, ok := cl.ipBlockRange(ip); ok {
return true
}
- if _, ok := cl.badPeerIPs[ip.String()]; ok {
+ ipAddr, ok := netip.AddrFromSlice(ip)
+ if !ok {
+ panic(ip)
+ }
+ if _, ok := cl.badPeerIPs[ipAddr]; ok {
return true
}
return false
// Return a Torrent ready for insertion into a Client.
func (cl *Client) newTorrent(ih metainfo.Hash, specStorage storage.ClientImpl) (t *Torrent) {
+ return cl.newTorrentOpt(AddTorrentOpts{
+ InfoHash: ih,
+ Storage: specStorage,
+ })
+}
+
+// Return a Torrent ready for insertion into a Client.
+func (cl *Client) newTorrentOpt(opts AddTorrentOpts) (t *Torrent) {
// use provided storage, if provided
storageClient := cl.defaultStorage
- if specStorage != nil {
- storageClient = storage.NewClient(specStorage)
+ if opts.Storage != nil {
+ storageClient = storage.NewClient(opts.Storage)
}
t = &Torrent{
cl: cl,
- infoHash: ih,
+ infoHash: opts.InfoHash,
peers: prioritizedPeers{
- om: btree.New(32),
+ om: gbtree.New(32),
getPrio: func(p PeerInfo) peerPriority {
ipPort := p.addr()
return bep40PriorityIgnoreError(cl.publicAddr(ipPort.IP), ipPort)
},
conns: make(map[*PeerConn]struct{}, 2*cl.config.EstablishedConnsPerTorrent),
- halfOpen: make(map[string]PeerInfo),
- pieceStateChanges: pubsub.NewPubSub(),
+ halfOpen: make(map[string]PeerInfo),
storageOpener: storageClient,
maxEstablishedConns: cl.config.EstablishedConnsPerTorrent,
- networkingEnabled: true,
metadataChanged: sync.Cond{
L: cl.locker(),
},
- webSeeds: make(map[string]*Peer),
- }
- t._pendingPieces.NewSet = priorityBitmapStableNewSet
- t.logger = cl.logger.WithContextValue(t)
- t.setChunkSize(defaultChunkSize)
+ webSeeds: make(map[string]*Peer),
+ gotMetainfoC: make(chan struct{}),
+ }
+ t.smartBanCache.Hash = sha1.Sum
+ t.smartBanCache.Init()
+ t.networkingEnabled.Set()
+ t.logger = cl.logger.WithContextValue(t).WithNames("torrent", t.infoHash.HexString())
+ t.sourcesLogger = t.logger.WithNames("sources")
+ if opts.ChunkSize == 0 {
+ opts.ChunkSize = defaultChunkSize
+ }
+ t.setChunkSize(opts.ChunkSize)
return
}
return
}
+// Adds a torrent by InfoHash with a custom Storage implementation.
+// If the torrent already exists then this Storage is ignored and the
+// existing torrent returned with `new` set to `false`
+func (cl *Client) AddTorrentOpt(opts AddTorrentOpts) (t *Torrent, new bool) {
+ infoHash := opts.InfoHash
+ cl.lock()
+ defer cl.unlock()
+ t, ok := cl.torrents[infoHash]
+ if ok {
+ return
+ }
+ new = true
+
+ t = cl.newTorrentOpt(opts)
+ cl.eachDhtServer(func(s DhtServer) {
+ if cl.config.PeriodicallyAnnounceTorrentsToDht {
+ go t.dhtAnnouncer(s)
+ }
+ })
+ cl.torrents[infoHash] = t
+ cl.clearAcceptLimits()
+ t.updateWantPeersEvent()
+ // Tickle Client.waitAccept, new torrent may want conns.
+ cl.event.Broadcast()
+ return
+}
+
+type AddTorrentOpts struct {
+ InfoHash InfoHash
+ Storage storage.ClientImpl
+ ChunkSize pp.Integer
+}
+
// Add or merge a torrent spec. Returns new if the torrent wasn't already in the client. See also
// Torrent.MergeSpec.
func (cl *Client) AddTorrentSpec(spec *TorrentSpec) (t *Torrent, new bool, err error) {
- t, new = cl.AddTorrentInfoHashWithStorage(spec.InfoHash, spec.Storage)
- err = t.MergeSpec(spec)
+ t, new = cl.AddTorrentOpt(AddTorrentOpts{
+ InfoHash: spec.InfoHash,
+ Storage: spec.Storage,
+ ChunkSize: spec.ChunkSize,
+ })
+ modSpec := *spec
+ if new {
+ // ChunkSize was already applied by adding a new Torrent, and MergeSpec disallows changing
+ // it.
+ modSpec.ChunkSize = 0
+ }
+ err = t.MergeSpec(&modSpec)
if err != nil && new {
t.Drop()
}
}
cl := t.cl
cl.AddDhtNodes(spec.DhtNodes)
+ t.UseSources(spec.Sources)
cl.lock()
defer cl.unlock()
- useTorrentSources(spec.Sources, t)
+ t.initialPieceCheckDisabled = spec.DisableInitialPieceCheck
for _, url := range spec.Webseeds {
t.addWebSeed(url)
}
})
}
if spec.ChunkSize != 0 {
- t.setChunkSize(pp.Integer(spec.ChunkSize))
+ panic("chunk size cannot be changed for existing Torrent")
}
t.addTrackers(spec.Trackers)
t.maybeNewConns()
- t.dataDownloadDisallowed = spec.DisallowDataDownload
+ t.dataDownloadDisallowed.SetBool(spec.DisallowDataDownload)
t.dataUploadDisallowed = spec.DisallowDataUpload
return nil
}
-func useTorrentSources(sources []string, t *Torrent) {
- for _, s := range sources {
- go func(s string) {
- err := useTorrentSource(s, t)
- if err != nil {
- t.logger.WithDefaultLevel(log.Warning).Printf("using torrent source %q: %v", s, err)
- } else {
- t.logger.Printf("successfully used source %q", s)
- }
- }(s)
- }
-}
-
-func useTorrentSource(source string, t *Torrent) error {
- req, err := http.NewRequest(http.MethodGet, source, nil)
- if err != nil {
- panic(err)
- }
- ctx, cancel := context.WithCancel(context.Background())
- defer cancel()
- go func() {
- select {
- case <-t.GotInfo():
- case <-t.Closed():
- case <-ctx.Done():
- }
- cancel()
- }()
- req = req.WithContext(ctx)
- resp, err := http.DefaultClient.Do(req)
- if err != nil {
- return err
- }
- mi, err := metainfo.Load(resp.Body)
- if err != nil {
- if ctx.Err() != nil {
- return nil
- }
- return err
- }
- return t.MergeSpec(TorrentSpecFromMetaInfo(mi))
-}
-
-func (cl *Client) dropTorrent(infoHash metainfo.Hash) (err error) {
+func (cl *Client) dropTorrent(infoHash metainfo.Hash, wg *sync.WaitGroup) (err error) {
t, ok := cl.torrents[infoHash]
if !ok {
err = fmt.Errorf("no such torrent")
return
}
- err = t.close()
- if err != nil {
- panic(err)
- }
+ err = t.close(wg)
delete(cl.torrents, infoHash)
return
}
}
func (cl *Client) AddTorrent(mi *metainfo.MetaInfo) (T *Torrent, err error) {
- T, _, err = cl.AddTorrentSpec(TorrentSpecFromMetaInfo(mi))
+ ts, err := TorrentSpecFromMetaInfoErr(mi)
+ if err != nil {
+ return
+ }
+ T, _, err = cl.AddTorrentSpec(ts)
return
}
}
func (cl *Client) banPeerIP(ip net.IP) {
- cl.logger.Printf("banning ip %v", ip)
- if cl.badPeerIPs == nil {
- cl.badPeerIPs = make(map[string]struct{})
+ // We can't take this from string, because it will lose netip's v4on6. net.ParseIP parses v4
+ // addresses directly to v4on6, which doesn't compare equal with v4.
+ ipAddr, ok := netip.AddrFromSlice(ip)
+ if !ok {
+ panic(ip)
+ }
+ generics.MakeMapIfNilAndSet(&cl.badPeerIPs, ipAddr, struct{}{})
+ for _, t := range cl.torrents {
+ t.iterPeers(func(p *Peer) {
+ if p.remoteIp().Equal(ip) {
+ t.logger.Levelf(log.Warning, "dropping peer %v with banned ip %v", p, ip)
+ // Should this be a close?
+ p.drop()
+ }
+ })
}
- cl.badPeerIPs[ip.String()] = struct{}{}
}
func (cl *Client) newConnection(nc net.Conn, outgoing bool, remoteAddr PeerRemoteAddr, network, connString string) (c *PeerConn) {
connString: connString,
conn: nc,
}
+ c.initRequestState()
+ // TODO: Need to be much more explicit about this, including allowing non-IP bannable addresses.
+ if remoteAddr != nil {
+ netipAddrPort, err := netip.ParseAddrPort(remoteAddr.String())
+ if err == nil {
+ c.bannableAddr = Some(netipAddrPort.Addr())
+ }
+ }
c.peerImpl = c
c.logger = cl.logger.WithDefaultLevel(log.Warning).WithContextValue(c)
c.setRW(connStatsReadWriter{nc, c})
return nil
}
-func (cl *Client) eachDialer(f func(Dialer) bool) {
- for _, s := range cl.dialers {
- if !f(s) {
- break
- }
- }
-}
-
func (cl *Client) eachListener(f func(Listener) bool) {
for _, s := range cl.listeners {
if !f(s) {
}
func (cl *Client) findListener(f func(Listener) bool) (ret Listener) {
- cl.eachListener(func(l Listener) bool {
- ret = l
- return !f(l)
- })
- return
+ for i := 0; i < len(cl.listeners); i += 1 {
+ if ret = cl.listeners[i]; f(ret) {
+ return
+ }
+ }
+ return nil
}
func (cl *Client) publicIp(peer net.IP) net.IP {
// ListenAddrs addresses currently being listened to.
func (cl *Client) ListenAddrs() (ret []net.Addr) {
cl.lock()
- defer cl.unlock()
- cl.eachListener(func(l Listener) bool {
- ret = append(ret, l.Addr())
- return true
- })
+ ret = make([]net.Addr, len(cl.listeners))
+ for i := 0; i < len(cl.listeners); i += 1 {
+ ret[i] = cl.listeners[i].Addr()
+ }
+ cl.unlock()
return
}
func (cl *Client) acceptLimitClearer() {
for {
select {
- case <-cl.closed.LockedChan(cl.locker()):
+ case <-cl.closed.Done():
return
case <-time.After(15 * time.Minute):
cl.lock()