Support scraping from HTTP trackers

[btrtrc.git] / tracker / udp.go

diff --git a/tracker/udp.go b/tracker/udp.go
index ac9f3e1c9416fcab59705857a11b3f313c608054..cf68188751d6c0bda395936a176f6cc38e17ebc9 100644 (file)
--- a/tracker/udp.go
+++ b/tracker/udp.go
@@ -1,72 +1,43 @@
 package tracker
 
 import (
-       "encoding"
+       "context"
        "encoding/binary"
-       "net"
-       "net/url"
 
-       "github.com/anacrolix/dht/v2/krpc"
-       "github.com/anacrolix/missinggo"
+       "github.com/anacrolix/generics"
+
        trHttp "github.com/anacrolix/torrent/tracker/http"
        "github.com/anacrolix/torrent/tracker/udp"
+       "github.com/anacrolix/torrent/types/infohash"
 )
 
-type udpAnnounce struct {
-       url url.URL
-       a   *Announce
+type udpClient struct {
+       cl         *udp.ConnClient
+       requestUri string
 }
 
-func (c *udpAnnounce) Close() error {
-       return nil
+func (c *udpClient) Scrape(ctx context.Context, ihs []infohash.T) (out udp.ScrapeResponse, err error) {
+       return c.cl.Client.Scrape(
+               ctx,
+               generics.SliceMap(ihs, func(from infohash.T) udp.InfoHash {
+                       return from
+               }),
+       )
 }
 
-func (c *udpAnnounce) ipv6(conn net.Conn) bool {
-       if c.a.UdpNetwork == "udp6" {
-               return true
-       }
-       rip := missinggo.AddrIP(conn.RemoteAddr())
-       return rip.To16() != nil && rip.To4() == nil
+func (c *udpClient) Close() error {
+       return c.cl.Close()
 }
 
-func (c *udpAnnounce) Do(req AnnounceRequest) (res AnnounceResponse, err error) {
-       conn, err := net.Dial(c.dialNetwork(), c.url.Host)
-       if err != nil {
-               return
-       }
-       defer conn.Close()
-       if c.ipv6(conn) {
-               // BEP 15
-               req.IPAddress = 0
-       } else if req.IPAddress == 0 && c.a.ClientIp4.IP != nil {
-               req.IPAddress = binary.BigEndian.Uint32(c.a.ClientIp4.IP.To4())
-       }
-       d := udp.Dispatcher{}
-       go func() {
-               for {
-                       b := make([]byte, 0x800)
-                       n, err := conn.Read(b)
-                       if err != nil {
-                               break
-                       }
-                       d.Dispatch(b[:n])
-               }
-       }()
-       cl := udp.Client{
-               Dispatcher: &d,
-               Writer:     conn,
+func (c *udpClient) Announce(ctx context.Context, req AnnounceRequest, opts trHttp.AnnounceOpt) (res AnnounceResponse, err error) {
+       if req.IPAddress == 0 && opts.ClientIp4 != nil {
+               // I think we're taking bytes in big-endian order (all IPs), and writing it to a natively
+               // ordered uint32. This will be correctly ordered when written back out by the UDP client
+               // later. I'm ignoring the fact that IPv6 announces shouldn't have an IP address, we have a
+               // perfectly good IPv4 address.
+               req.IPAddress = binary.BigEndian.Uint32(opts.ClientIp4.To4())
        }
-       nas := func() interface {
-               encoding.BinaryUnmarshaler
-               NodeAddrs() []krpc.NodeAddr
-       } {
-               if c.ipv6(conn) {
-                       return &krpc.CompactIPv6NodeAddrs{}
-               } else {
-                       return &krpc.CompactIPv4NodeAddrs{}
-               }
-       }()
-       h, err := cl.Announce(c.a.Context, req, nas, udp.Options{RequestUri: c.url.RequestURI()})
+       h, nas, err := c.cl.Announce(ctx, req, udp.Options{RequestUri: c.requestUri})
        if err != nil {
                return
        }
@@ -78,20 +49,3 @@ func (c *udpAnnounce) Do(req AnnounceRequest) (res AnnounceResponse, err error)
        }
        return
 }
-
-func (c *udpAnnounce) dialNetwork() string {
-       if c.a.UdpNetwork != "" {
-               return c.a.UdpNetwork
-       }
-       return "udp"
-}
-
-// TODO: Split on IPv6, as BEP 15 says response peer decoding depends on network in use.
-func announceUDP(opt Announce, _url *url.URL) (AnnounceResponse, error) {
-       ua := udpAnnounce{
-               url: *_url,
-               a:   &opt,
-       }
-       defer ua.Close()
-       return ua.Do(opt.Request)
-}