tracker/udp.go

   1 package tracker
   2
   3 import (
   4         "encoding"
   5         "encoding/binary"
   6         "net"
   7         "net/url"
   8
   9         "github.com/anacrolix/dht/v2/krpc"
  10         "github.com/anacrolix/missinggo"
  11         "github.com/anacrolix/torrent/tracker/udp"
  12 )
  13
  14 type udpAnnounce struct {
  15         url url.URL
  16         a   *Announce
  17 }
  18
  19 func (c *udpAnnounce) Close() error {
  20         return nil
  21 }
  22
  23 func (c *udpAnnounce) ipv6(conn net.Conn) bool {
  24         if c.a.UdpNetwork == "udp6" {
  25                 return true
  26         }
  27         rip := missinggo.AddrIP(conn.RemoteAddr())
  28         return rip.To16() != nil && rip.To4() == nil
  29 }
  30
  31 func (c *udpAnnounce) Do(req AnnounceRequest) (res AnnounceResponse, err error) {
  32         conn, err := net.Dial(c.dialNetwork(), c.url.Host)
  33         if err != nil {
  34                 return
  35         }
  36         defer conn.Close()
  37         if c.ipv6(conn) {
  38                 // BEP 15
  39                 req.IPAddress = 0
  40         } else if req.IPAddress == 0 && c.a.ClientIp4.IP != nil {
  41                 req.IPAddress = binary.BigEndian.Uint32(c.a.ClientIp4.IP.To4())
  42         }
  43         d := udp.Dispatcher{}
  44         go func() {
  45                 for {
  46                         b := make([]byte, 0x800)
  47                         n, err := conn.Read(b)
  48                         if err != nil {
  49                                 break
  50                         }
  51                         d.Dispatch(b[:n])
  52                 }
  53         }()
  54         cl := udp.Client{
  55                 Dispatcher: &d,
  56                 Writer:     conn,
  57         }
  58         nas := func() interface {
  59                 encoding.BinaryUnmarshaler
  60                 NodeAddrs() []krpc.NodeAddr
  61         } {
  62                 if c.ipv6(conn) {
  63                         return &krpc.CompactIPv6NodeAddrs{}
  64                 } else {
  65                         return &krpc.CompactIPv4NodeAddrs{}
  66                 }
  67         }()
  68         h, err := cl.Announce(c.a.Context, req, nas, udp.Options{RequestUri: c.url.RequestURI()})
  69         if err != nil {
  70                 return
  71         }
  72         res.Interval = h.Interval
  73         res.Leechers = h.Leechers
  74         res.Seeders = h.Seeders
  75         for _, cp := range nas.NodeAddrs() {
  76                 res.Peers = append(res.Peers, Peer{}.FromNodeAddr(cp))
  77         }
  78         return
  79 }
  80
  81 func (c *udpAnnounce) dialNetwork() string {
  82         if c.a.UdpNetwork != "" {
  83                 return c.a.UdpNetwork
  84         }
  85         return "udp"
  86 }
  87
  88 // TODO: Split on IPv6, as BEP 15 says response peer decoding depends on network in use.
  89 func announceUDP(opt Announce, _url *url.URL) (AnnounceResponse, error) {
  90         ua := udpAnnounce{
  91                 url: *_url,
  92                 a:   &opt,
  93         }
  94         defer ua.Close()
  95         return ua.Do(opt.Request)
  96 }