"bufio"
"context"
"crypto/rand"
+ "crypto/sha1"
"encoding/binary"
"errors"
+ "expvar"
"fmt"
"io"
+ "math"
"net"
"net/http"
+ "net/netip"
"sort"
"strconv"
"strings"
"time"
+ "github.com/anacrolix/chansync"
+ "github.com/anacrolix/chansync/events"
"github.com/anacrolix/dht/v2"
"github.com/anacrolix/dht/v2/krpc"
+ . "github.com/anacrolix/generics"
+ g "github.com/anacrolix/generics"
"github.com/anacrolix/log"
"github.com/anacrolix/missinggo/perf"
- "github.com/anacrolix/missinggo/pubsub"
"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"
+ gbtree "github.com/google/btree"
"golang.org/x/time/rate"
- "github.com/anacrolix/chansync"
-
"github.com/anacrolix/torrent/bencode"
"github.com/anacrolix/torrent/internal/limiter"
"github.com/anacrolix/torrent/iplist"
"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"
+ "github.com/anacrolix/torrent/types/infohash"
)
// Clients contain zero or more Torrents. A Client manages a blocklist, the
// 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
numHalfOpen int
- websocketTrackers websocketTrackers
-
activeAnnounceLimiter limiter.Instance
-
- updateRequests chansync.BroadcastCond
+ httpClient *http.Client
}
type ipStr string
ips = make([]string, len(cl.badPeerIPs))
i := 0
for k := range cl.badPeerIPs {
- ips[i] = k
+ ips[i] = k.String()
i += 1
}
return
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)
}
// Initializes a bare minimum Client. *Client and *ClientConfig must not be nil.
func (cl *Client) init(cfg *ClientConfig) {
cl.config = cfg
- cl.dopplegangerAddrs = make(map[string]struct{})
+ g.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,
+ DialContext: cfg.HTTPDialContext,
+ // 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) {
}
}
- 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)
}
}
- cl.websocketTrackers = websocketTrackers{
- PeerId: cl.peerID,
- Logger: cl.logger,
- GetAnnounceRequest: func(event tracker.AnnounceEvent, infoHash [20]byte) (tracker.AnnounceRequest, error) {
- cl.lock()
- defer cl.unlock()
- t, ok := cl.torrents[infoHash]
- if !ok {
- return tracker.AnnounceRequest{}, errors.New("torrent not tracked by client")
- }
- return t.announceRequest(event), nil
- },
- OnConn: func(dc datachannel.ReadWriteCloser, dcc webtorrent.DataChannelContext) {
- cl.lock()
- defer cl.unlock()
- t, ok := cl.torrents[dcc.InfoHash]
- if !ok {
- cl.logger.WithDefaultLevel(log.Warning).Printf(
- "got webrtc conn for unloaded torrent with infohash %x",
- dcc.InfoHash,
- )
- dc.Close()
- return
- }
- go t.onWebRtcConn(dc, dcc)
- },
- }
-
- //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)
}
s, err = dht.NewServer(&cfg)
if err == nil {
- go func() {
- ts, err := s.Bootstrap()
- if err != nil {
- cl.logger.Printf("error bootstrapping dht: %s", err)
- }
- log.Fstr("%v completed bootstrap (%v)", s, ts).AddValues(s, ts).Log(cl.logger)
- }()
+ go s.TableMaintainer()
}
return
}
-func (cl *Client) Closed() chansync.Done {
+func (cl *Client) Closed() events.Done {
return cl.closed.Done()
}
}
}
-// Stops the client. All connections to peers are closed and all activity will
-// come to a halt.
-func (cl *Client) Close() {
- cl.closed.Set()
+// 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()
- cl.event.Broadcast()
for _, t := range cl.torrents {
- t.close(&closeGroup)
+ err := t.close(&closeGroup)
+ if err != nil {
+ errs = append(errs, err)
+ }
}
- cl.unlock()
- closeGroup.Wait() // defer is LIFO. We want to Wait() after cl.unlock()
- cl.lock()
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
}
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)
if tc, ok := nc.(*net.TCPConn); ok {
tc.SetLinger(0)
}
- c := cl.newConnection(nc, false, nc.RemoteAddr(), nc.RemoteAddr().Network(),
- regularNetConnPeerConnConnString(nc))
+ remoteAddr, _ := tryIpPortFromNetAddr(nc.RemoteAddr())
+ c := cl.newConnection(
+ nc,
+ newConnectionOpts{
+ outgoing: false,
+ remoteAddr: nc.RemoteAddr(),
+ localPublicAddr: cl.publicAddr(remoteAddr.IP),
+ network: nc.RemoteAddr().Network(),
+ connString: regularNetConnPeerConnConnString(nc),
+ })
defer func() {
cl.lock()
defer cl.unlock()
// Returns a handle to the given torrent, if it's present in the client.
func (cl *Client) Torrent(ih metainfo.Hash) (t *Torrent, ok bool) {
- cl.lock()
- defer cl.unlock()
+ cl.rLock()
+ defer cl.rUnlock()
t, ok = cl.torrents[ih]
return
}
}
}
-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
ctx context.Context,
nc net.Conn,
t *Torrent,
- outgoing, encryptHeader bool,
- remoteAddr PeerRemoteAddr,
- network, connString string,
+ encryptHeader bool,
+ newConnOpts newConnectionOpts,
) (
c *PeerConn, err error,
) {
- c = cl.newConnection(nc, outgoing, remoteAddr, network, connString)
+ c = cl.newConnection(nc, newConnOpts)
c.headerEncrypted = encryptHeader
ctx, cancel := context.WithTimeout(ctx, cl.config.HandshakesTimeout)
defer cancel()
}
return nil, errors.New("dial failed")
}
- c, err := cl.initiateProtocolHandshakes(context.Background(), nc, t, true, obfuscatedHeader, addr, dr.Dialer.DialerNetwork(), regularNetConnPeerConnConnString(nc))
+ addrIpPort, _ := tryIpPortFromNetAddr(addr)
+ c, err := cl.initiateProtocolHandshakes(context.Background(), nc, t, obfuscatedHeader, newConnectionOpts{
+ outgoing: true,
+ remoteAddr: addr,
+ // It would be possible to retrieve a public IP from the dialer used here?
+ localPublicAddr: cl.publicAddr(addrIpPort.IP),
+ network: dr.Dialer.DialerNetwork(),
+ connString: 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
}
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 {
// 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) {
return fmt.Errorf("adding connection: %w", err)
}
defer t.dropConnection(c)
- c.startWriter()
+ c.startMessageWriter()
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.
-const localClientReqq = 1 << 5
+const localClientReqq = 1024
// See the order given in Transmission's tr_peerMsgsNew.
func (cl *Client) sendInitialMessages(conn *PeerConn, torrent *Torrent) {
Encryption: cl.config.HeaderObfuscationPolicy.Preferred || !cl.config.HeaderObfuscationPolicy.RequirePreferred,
Port: cl.incomingPeerPort(),
MetadataSize: torrent.metadataSize(),
- // TODO: We can figured these out specific to the socket
- // used.
+ // TODO: We can figure these out specific to the socket used.
Ipv4: pp.CompactIp(cl.config.PublicIp4.To4()),
Ipv6: cl.config.PublicIp6.To16(),
}
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,
webSeeds: make(map[string]*Peer),
gotMetainfoC: make(chan struct{}),
}
+ t.smartBanCache.Hash = sha1.Sum
+ t.smartBanCache.Init()
t.networkingEnabled.Set()
- t._pendingPieces.NewSet = priorityBitmapStableNewSet
- t.logger = cl.logger.WithContextValue(t)
- t.setChunkSize(defaultChunkSize)
+ 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
+ t.setInfoBytesLocked(opts.InfoBytes)
+ cl.clearAcceptLimits()
+ t.updateWantPeersEvent()
+ // Tickle Client.waitAccept, new torrent may want conns.
+ cl.event.Broadcast()
+ return
+}
+
+type AddTorrentOpts struct {
+ InfoHash infohash.T
+ Storage storage.ClientImpl
+ ChunkSize pp.Integer
+ InfoBytes []byte
+}
+
// 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()
}
return
}
-type stringAddr string
-
-var _ net.Addr = stringAddr("")
-
-func (stringAddr) Network() string { return "" }
-func (me stringAddr) String() string { return string(me) }
-
// The trackers will be merged with the existing ones. If the Info isn't yet known, it will be set.
// spec.DisallowDataDownload/Upload will be read and applied
// The display name is replaced if the new spec provides one. Note that any `Storage` is ignored.
}
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)
}
for _, peerAddr := range spec.PeerAddrs {
t.addPeer(PeerInfo{
- Addr: stringAddr(peerAddr),
+ Addr: StringAddr(peerAddr),
Source: PeerSourceDirect,
Trusted: true,
})
}
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()
return nil
}
-func useTorrentSources(sources []string, t *Torrent) {
- // TODO: bind context to the lifetime of *Torrent so that it's cancelled if the torrent closes
- ctx := context.Background()
- for i := 0; i < len(sources); i += 1 {
- s := sources[i]
- go func() {
- if err := useTorrentSource(ctx, s, t); err != nil {
- t.logger.WithDefaultLevel(log.Warning).Printf("using torrent source %q: %v", s, err)
- } else {
- t.logger.Printf("successfully used source %q", s)
- }
- }()
- }
-}
-
-func useTorrentSource(ctx context.Context, source string, t *Torrent) (err error) {
- ctx, cancel := context.WithCancel(ctx)
- defer cancel()
- go func() {
- select {
- case <-t.GotInfo():
- case <-t.Closed():
- case <-ctx.Done():
- }
- cancel()
- }()
- var req *http.Request
- if req, err = http.NewRequestWithContext(ctx, http.MethodGet, source, nil); err != nil {
- panic(err)
- }
- var resp *http.Response
- if resp, err = http.DefaultClient.Do(req); err != nil {
- return
- }
- var mi metainfo.MetaInfo
- err = bencode.NewDecoder(resp.Body).Decode(&mi)
- resp.Body.Close()
- if err != nil {
- if ctx.Err() != nil {
- return nil
- }
- return
- }
- return t.MergeSpec(TorrentSpecFromMetaInfo(&mi))
-}
-
func (cl *Client) dropTorrent(infoHash metainfo.Hash, wg *sync.WaitGroup) (err error) {
t, ok := cl.torrents[infoHash]
if !ok {
return
}
err = t.close(wg)
- if err != nil {
- panic(err)
- }
delete(cl.torrents, infoHash)
return
}
// Returns handles to all the torrents loaded in the Client.
func (cl *Client) Torrents() []*Torrent {
- cl.lock()
- defer cl.unlock()
+ cl.rLock()
+ defer cl.rUnlock()
return cl.torrentsAsSlice()
}
}
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)
+ }
+ g.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) {
- if network == "" {
- panic(remoteAddr)
+type newConnectionOpts struct {
+ outgoing bool
+ remoteAddr PeerRemoteAddr
+ localPublicAddr peerLocalPublicAddr
+ network string
+ connString string
+}
+
+func (cl *Client) newConnection(nc net.Conn, opts newConnectionOpts) (c *PeerConn) {
+ if opts.network == "" {
+ panic(opts.remoteAddr)
}
c = &PeerConn{
Peer: Peer{
- outgoing: outgoing,
+ outgoing: opts.outgoing,
choking: true,
peerChoking: true,
PeerMaxRequests: 250,
- RemoteAddr: remoteAddr,
- Network: network,
- callbacks: &cl.config.Callbacks,
+ RemoteAddr: opts.remoteAddr,
+ localPublicAddr: opts.localPublicAddr,
+ Network: opts.network,
+ callbacks: &cl.config.Callbacks,
},
- connString: connString,
+ connString: opts.connString,
conn: nc,
}
+ c.peerRequestDataAllocLimiter.Max = cl.config.MaxAllocPeerRequestDataPerConn
+ c.initRequestState()
+ // TODO: Need to be much more explicit about this, including allowing non-IP bannable addresses.
+ if opts.remoteAddr != nil {
+ netipAddrPort, err := netip.ParseAddrPort(opts.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})
l: cl.config.DownloadRateLimiter,
r: c.r,
}
- c.logger.WithDefaultLevel(log.Debug).Printf("initialized with remote %v over network %v (outgoing=%t)", remoteAddr, network, outgoing)
+ c.logger.WithDefaultLevel(log.Debug).Printf("initialized with remote %v over network %v (outgoing=%t)", opts.remoteAddr, opts.network, opts.outgoing)
for _, f := range cl.config.Callbacks.NewPeer {
f(&c.Peer)
}
return
}
+func (cl *Client) PublicIPs() (ips []net.IP) {
+ if ip := cl.config.PublicIp4; ip != nil {
+ ips = append(ips, ip)
+ }
+ if ip := cl.config.PublicIp6; ip != nil {
+ ips = append(ips, ip)
+ }
+ return
+}
+
func (cl *Client) onBadAccept(addr PeerRemoteAddr) {
ipa, ok := tryIpPortFromNetAddr(addr)
if !ok {