tracker_scraper.go

   1 package torrent
   2
   3 import (
   4         "bytes"
   5         "errors"
   6         "fmt"
   7         "net"
   8         "net/url"
   9         "time"
  10
  11         "github.com/anacrolix/dht/v2/krpc"
  12
  13         "github.com/anacrolix/torrent/tracker"
  14 )
  15
  16 // Announces a torrent to a tracker at regular intervals, when peers are
  17 // required.
  18 type trackerScraper struct {
  19         u            url.URL
  20         t            *Torrent
  21         lastAnnounce trackerAnnounceResult
  22 }
  23
  24 func (ts *trackerScraper) statusLine() string {
  25         var w bytes.Buffer
  26         fmt.Fprintf(&w, "%q\t%s\t%s",
  27                 ts.u.String(),
  28                 func() string {
  29                         na := time.Until(ts.lastAnnounce.Completed.Add(ts.lastAnnounce.Interval))
  30                         if na > 0 {
  31                                 na /= time.Second
  32                                 na *= time.Second
  33                                 return na.String()
  34                         } else {
  35                                 return "anytime"
  36                         }
  37                 }(),
  38                 func() string {
  39                         if ts.lastAnnounce.Err != nil {
  40                                 return ts.lastAnnounce.Err.Error()
  41                         }
  42                         if ts.lastAnnounce.Completed.IsZero() {
  43                                 return "never"
  44                         }
  45                         return fmt.Sprintf("%d peers", ts.lastAnnounce.NumPeers)
  46                 }(),
  47         )
  48         return w.String()
  49 }
  50
  51 type trackerAnnounceResult struct {
  52         Err       error
  53         NumPeers  int
  54         Interval  time.Duration
  55         Completed time.Time
  56 }
  57
  58 func (me *trackerScraper) getIp() (ip net.IP, err error) {
  59         ips, err := net.LookupIP(me.u.Hostname())
  60         if err != nil {
  61                 return
  62         }
  63         if len(ips) == 0 {
  64                 err = errors.New("no ips")
  65                 return
  66         }
  67         for _, ip = range ips {
  68                 if me.t.cl.ipIsBlocked(ip) {
  69                         continue
  70                 }
  71                 switch me.u.Scheme {
  72                 case "udp4":
  73                         if ip.To4() == nil {
  74                                 continue
  75                         }
  76                 case "udp6":
  77                         if ip.To4() != nil {
  78                                 continue
  79                         }
  80                 }
  81                 return
  82         }
  83         err = errors.New("no acceptable ips")
  84         return
  85 }
  86
  87 func (me *trackerScraper) trackerUrl(ip net.IP) string {
  88         u := me.u
  89         if u.Port() != "" {
  90                 u.Host = net.JoinHostPort(ip.String(), u.Port())
  91         }
  92         return u.String()
  93 }
  94
  95 // Return how long to wait before trying again. For most errors, we return 5
  96 // minutes, a relatively quick turn around for DNS changes.
  97 func (me *trackerScraper) announce(event tracker.AnnounceEvent) (ret trackerAnnounceResult) {
  98         defer func() {
  99                 ret.Completed = time.Now()
 100         }()
 101         ret.Interval = time.Minute
 102         ip, err := me.getIp()
 103         if err != nil {
 104                 ret.Err = fmt.Errorf("error getting ip: %s", err)
 105                 return
 106         }
 107         me.t.cl.lock()
 108         req := me.t.announceRequest(event)
 109         me.t.cl.unlock()
 110         //log.Printf("announcing %s %s to %q", me.t, req.Event, me.u.String())
 111         res, err := tracker.Announce{
 112                 HTTPProxy:  me.t.cl.config.HTTPProxy,
 113                 UserAgent:  me.t.cl.config.HTTPUserAgent,
 114                 TrackerUrl: me.trackerUrl(ip),
 115                 Request:    req,
 116                 HostHeader: me.u.Host,
 117                 ServerName: me.u.Hostname(),
 118                 UdpNetwork: me.u.Scheme,
 119                 ClientIp4:  krpc.NodeAddr{IP: me.t.cl.config.PublicIp4},
 120                 ClientIp6:  krpc.NodeAddr{IP: me.t.cl.config.PublicIp6},
 121         }.Do()
 122         if err != nil {
 123                 ret.Err = fmt.Errorf("error announcing: %s", err)
 124                 return
 125         }
 126         me.t.AddPeers(Peers(nil).AppendFromTracker(res.Peers))
 127         ret.NumPeers = len(res.Peers)
 128         ret.Interval = time.Duration(res.Interval) * time.Second
 129         return
 130 }
 131
 132 func (me *trackerScraper) Run() {
 133         defer me.announceStopped()
 134         // make sure first announce is a "started"
 135         e := tracker.Started
 136         for {
 137                 ar := me.announce(e)
 138                 // after first announce, get back to regular "none"
 139                 e = tracker.None
 140                 me.t.cl.lock()
 141                 me.lastAnnounce = ar
 142                 me.t.cl.unlock()
 143
 144         wait:
 145                 interval := ar.Interval
 146                 if interval < time.Minute {
 147                         interval = time.Minute
 148                 }
 149                 wantPeers := me.t.wantPeersEvent.LockedChan(me.t.cl.locker())
 150                 select {
 151                 case <-wantPeers:
 152                         if interval > time.Minute {
 153                                 interval = time.Minute
 154                         }
 155                         wantPeers = nil
 156                 default:
 157                 }
 158
 159                 select {
 160                 case <-me.t.closed.LockedChan(me.t.cl.locker()):
 161                         return
 162                 case <-wantPeers:
 163                         goto wait
 164                 case <-time.After(time.Until(ar.Completed.Add(interval))):
 165                 }
 166         }
 167 }
 168
 169 func (me *trackerScraper) announceStopped() {
 170         me.announce(tracker.Stopped)
 171 }