tracker/http/server/server.go

   1 package httpTrackerServer
   2
   3 import (
   4         "fmt"
   5         "net"
   6         "net/http"
   7         "net/netip"
   8         "net/url"
   9         "strconv"
  10
  11         "github.com/anacrolix/dht/v2/krpc"
  12         "github.com/anacrolix/generics"
  13         "github.com/anacrolix/log"
  14         trackerServer "github.com/anacrolix/torrent/tracker/server"
  15
  16         "github.com/anacrolix/torrent/bencode"
  17         "github.com/anacrolix/torrent/tracker"
  18         httpTracker "github.com/anacrolix/torrent/tracker/http"
  19 )
  20
  21 type Handler struct {
  22         Announce *trackerServer.AnnounceHandler
  23         // Called to derive an announcer's IP if non-nil. If not specified, the Request.RemoteAddr is
  24         // used. Necessary for instances running behind reverse proxies for example.
  25         RequestHost func(r *http.Request) (netip.Addr, error)
  26 }
  27
  28 func unmarshalQueryKeyToArray(w http.ResponseWriter, key string, query url.Values) (ret [20]byte, ok bool) {
  29         str := query.Get(key)
  30         if len(str) != len(ret) {
  31                 http.Error(w, fmt.Sprintf("%v has wrong length", key), http.StatusBadRequest)
  32                 return
  33         }
  34         copy(ret[:], str)
  35         ok = true
  36         return
  37 }
  38
  39 // Returns false if there was an error and it was served.
  40 func (me Handler) requestHostAddr(r *http.Request) (_ netip.Addr, err error) {
  41         if me.RequestHost != nil {
  42                 return me.RequestHost(r)
  43         }
  44         host, _, err := net.SplitHostPort(r.RemoteAddr)
  45         if err != nil {
  46                 return
  47         }
  48         return netip.ParseAddr(host)
  49 }
  50
  51 var requestHeadersLogger = log.Default.WithNames("request", "headers")
  52
  53 func (me Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  54         vs := r.URL.Query()
  55         var event tracker.AnnounceEvent
  56         err := event.UnmarshalText([]byte(vs.Get("event")))
  57         if err != nil {
  58                 http.Error(w, err.Error(), http.StatusBadRequest)
  59                 return
  60         }
  61         infoHash, ok := unmarshalQueryKeyToArray(w, "info_hash", vs)
  62         if !ok {
  63                 return
  64         }
  65         peerId, ok := unmarshalQueryKeyToArray(w, "peer_id", vs)
  66         if !ok {
  67                 return
  68         }
  69         requestHeadersLogger.Levelf(log.Debug, "request RemoteAddr=%q, header=%q", r.RemoteAddr, r.Header)
  70         addr, err := me.requestHostAddr(r)
  71         if err != nil {
  72                 log.Printf("error getting requester IP: %v", err)
  73                 http.Error(w, "error determining your IP", http.StatusBadGateway)
  74                 return
  75         }
  76         portU64, err := strconv.ParseUint(vs.Get("port"), 0, 16)
  77         addrPort := netip.AddrPortFrom(addr, uint16(portU64))
  78         res := me.Announce.Serve(
  79                 r.Context(),
  80                 tracker.AnnounceRequest{
  81                         InfoHash: infoHash,
  82                         PeerId:   peerId,
  83                         Event:    event,
  84                         Port:     addrPort.Port(),
  85                         NumWant:  -1,
  86                 },
  87                 addrPort,
  88                 trackerServer.GetPeersOpts{
  89                         MaxCount: generics.Some[uint](200),
  90                 },
  91         )
  92         err = res.Err
  93         if err != nil {
  94                 log.Printf("error serving announce: %v", err)
  95                 http.Error(w, "error handling announce", http.StatusInternalServerError)
  96                 return
  97         }
  98         var resp httpTracker.HttpResponse
  99         resp.Interval = res.Interval.UnwrapOr(5 * 60)
 100         resp.Peers.Compact = true
 101         for _, peer := range res.Peers {
 102                 if peer.Addr().Is4() {
 103                         resp.Peers.List = append(resp.Peers.List, tracker.Peer{
 104                                 IP:   peer.Addr().AsSlice(),
 105                                 Port: int(peer.Port()),
 106                         })
 107                 } else if peer.Addr().Is6() {
 108                         resp.Peers6 = append(resp.Peers6, krpc.NodeAddr{
 109                                 IP:   peer.Addr().AsSlice(),
 110                                 Port: int(peer.Port()),
 111                         })
 112                 }
 113         }
 114         err = bencode.NewEncoder(w).Encode(resp)
 115         if err != nil {
 116                 log.Printf("error encoding and writing response body: %v", err)
 117         }
 118 }