"github.com/dustin/go-humanize"
gbtree "github.com/google/btree"
"github.com/pion/datachannel"
- "golang.org/x/time/rate"
"github.com/anacrolix/torrent/bencode"
"github.com/anacrolix/torrent/internal/check"
torrents map[InfoHash]*Torrent
pieceRequestOrder map[interface{}]*request_strategy.PieceRequestOrder
- acceptLimiter map[ipStr]int
- dialRateLimiter *rate.Limiter
- numHalfOpen int
+ acceptLimiter map[ipStr]int
+ numHalfOpen int
websocketTrackers websocketTrackers
cl.config = cfg
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{
+ Transport: cfg.WebTransport,
+ }
+ if cl.httpClient.Transport == nil {
+ cl.httpClient.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,
- },
+ }
}
}
},
Proxy: cl.config.HTTPProxy,
WebsocketTrackerHttpHeader: cl.config.WebsocketTrackerHttpHeader,
+ ICEServers: cl.config.ICEServers,
DialContext: cl.config.TrackerDialContext,
OnConn: func(dc datachannel.ReadWriteCloser, dcc webtorrent.DataChannelContext) {
cl.lock()
for {
conn, err := l.Accept()
torrent.Add("client listener accepts", 1)
+ if err == nil {
+ holepunchAddr, holepunchErr := addrPortFromPeerRemoteAddr(conn.RemoteAddr())
+ if holepunchErr == nil {
+ cl.lock()
+ if g.MapContains(cl.undialableWithoutHolepunch, holepunchAddr) {
+ setAdd(&cl.accepted, holepunchAddr)
+ }
+ if g.MapContains(
+ cl.undialableWithoutHolepunchDialedAfterHolepunchConnect,
+ holepunchAddr,
+ ) {
+ setAdd(&cl.probablyOnlyConnectedDueToHolepunch, holepunchAddr)
+ }
+ cl.unlock()
+ }
+ }
conn = pproffd.WrapNetConn(conn)
cl.rLock()
closed := cl.closed.IsSet()
log.Fmsg("error accepting connection: %s", err).LogLevel(log.Debug, cl.logger)
continue
}
- {
- holepunchAddr, holepunchErr := addrPortFromPeerRemoteAddr(conn.RemoteAddr())
- if holepunchErr == nil {
- cl.lock()
- if g.MapContains(
- cl.undialableWithoutHolepunchDialedAfterHolepunchConnect,
- holepunchAddr,
- ) {
- g.MakeMapIfNil(&cl.probablyOnlyConnectedDueToHolepunch)
- g.MapInsert(cl.probablyOnlyConnectedDueToHolepunch, holepunchAddr, struct{}{})
- }
- cl.unlock()
- }
- }
go func() {
if reject != nil {
torrent.Add("rejected accepted connections", 1)
// Returns nil connection and nil error if no connection could be established for valid reasons.
func (cl *Client) dialAndCompleteHandshake(opts outgoingConnOpts) (c *PeerConn, err error) {
+ // It would be better if dial rate limiting could be tested when considering to open connections
+ // instead. Doing it here means if the limit is low, and the half-open limit is high, we could
+ // end up with lots of outgoing connection attempts pending that were initiated on stale data.
+ {
+ dialReservation := cl.config.DialRateLimiter.Reserve()
+ if !opts.receivedHolepunchConnect {
+ if !dialReservation.OK() {
+ err = errors.New("can't make dial limit reservation")
+ return
+ }
+ time.Sleep(dialReservation.Delay())
+ }
+ }
torrent.Add("establish outgoing connection", 1)
addr := opts.peerInfo.Addr
dialPool := dialPool{
}
}
holepunchAddr, holepunchAddrErr := addrPortFromPeerRemoteAddr(addr)
- if holepunchAddrErr == nil && opts.receivedHolepunchConnect {
- cl.lock()
- if g.MapContains(cl.undialableWithoutHolepunch, holepunchAddr) {
- g.MakeMapIfNilAndSet(
- &cl.undialableWithoutHolepunchDialedAfterHolepunchConnect,
- holepunchAddr,
- struct{}{},
- )
- }
- cl.unlock()
- }
headerObfuscationPolicy := opts.HeaderObfuscationPolicy
obfuscatedHeaderFirst := headerObfuscationPolicy.Preferred
firstDialResult := dialPool.getFirst()
if !opts.receivedHolepunchConnect {
g.MakeMapIfNilAndSet(&cl.undialableWithoutHolepunch, holepunchAddr, struct{}{})
}
- opts.t.startHolepunchRendezvous(holepunchAddr)
+ if !opts.skipHolepunchRendezvous {
+ opts.t.trySendHolepunchRendezvous(holepunchAddr)
+ }
cl.unlock()
}
err = fmt.Errorf("all initial dials failed")
torrent.Add("initiated conn with preferred header obfuscation", 1)
return
}
+ c.logger.Levelf(
+ log.Debug,
+ "error doing protocol handshake with header obfuscation %v",
+ obfuscatedHeaderFirst,
+ )
+ firstDialResult.Conn.Close()
// We should have just tried with the preferred header obfuscation. If it was required, there's nothing else to try.
if headerObfuscationPolicy.RequirePreferred {
return
torrent.Add("initiated conn with fallback header obfuscation", 1)
return
}
+ c.logger.Levelf(
+ log.Debug,
+ "error doing protocol handshake with header obfuscation %v",
+ !obfuscatedHeaderFirst,
+ )
+ secondDialResult.Conn.Close()
return
}
opts outgoingConnOpts,
attemptKey outgoingConnAttemptKey,
) {
- cl.dialRateLimiter.Wait(context.Background())
c, err := cl.dialAndCompleteHandshake(opts)
if err == nil {
c.conn.SetWriteDeadline(time.Time{})
t.smartBanCache.Hash = sha1.Sum
t.smartBanCache.Init()
t.networkingEnabled.Set()
- t.logger = cl.logger.WithContextValue(t).WithNames("torrent", t.infoHash.HexString()).WithDefaultLevel(log.Debug)
+ t.logger = cl.logger.WithDefaultLevel(log.Debug)
t.sourcesLogger = t.logger.WithNames("sources")
if opts.ChunkSize == 0 {
opts.ChunkSize = defaultChunkSize
}
c.peerImpl = c
c.logger = cl.logger.WithDefaultLevel(log.Warning)
+ c.logger = c.logger.WithContextText(fmt.Sprintf("%T %p", c, c))
c.setRW(connStatsReadWriter{nc, c})
c.r = &rateLimitedReader{
l: cl.config.DownloadRateLimiter,
}
c.logger.Levelf(
log.Debug,
- "new PeerConn %p [Client %p remoteAddr %v network %v outgoing %t]",
- c, cl, opts.remoteAddr, opts.network, opts.outgoing,
+ "inited with remoteAddr %v network %v outgoing %t",
+ opts.remoteAddr, opts.network, opts.outgoing,
)
for _, f := range cl.config.Callbacks.NewPeer {
f(&c.Peer)