metainfo/magnet.go

   1 package metainfo
   2
   3 import (
   4         "encoding/base32"
   5         "encoding/hex"
   6         "errors"
   7         "fmt"
   8         "net/url"
   9         "strings"
  10 )
  11
  12 // Magnet link components.
  13 type Magnet struct {
  14         InfoHash    Hash       // Expected in this implementation
  15         Trackers    []string   // "tr" values
  16         DisplayName string     // "dn" value, if not empty
  17         Params      url.Values // All other values, such as "x.pe", "as", "xs" etc.
  18 }
  19
  20 const xtPrefix = "urn:btih:"
  21
  22 func (m Magnet) String() string {
  23         // Deep-copy m.Params
  24         vs := make(url.Values, len(m.Params)+len(m.Trackers)+2)
  25         for k, v := range m.Params {
  26                 vs[k] = append([]string(nil), v...)
  27         }
  28
  29         for _, tr := range m.Trackers {
  30                 vs.Add("tr", tr)
  31         }
  32         if m.DisplayName != "" {
  33                 vs.Add("dn", m.DisplayName)
  34         }
  35
  36         // Transmission and Deluge both expect "urn:btih:" to be unescaped. Deluge wants it to be at the
  37         // start of the magnet link. The InfoHash field is expected to be BitTorrent in this
  38         // implementation.
  39         u := url.URL{
  40                 Scheme:   "magnet",
  41                 RawQuery: "xt=" + xtPrefix + m.InfoHash.HexString(),
  42         }
  43         if len(vs) != 0 {
  44                 u.RawQuery += "&" + vs.Encode()
  45         }
  46         return u.String()
  47 }
  48
  49 // ParseMagnetUri parses Magnet-formatted URIs into a Magnet instance
  50 func ParseMagnetUri(uri string) (m Magnet, err error) {
  51         u, err := url.Parse(uri)
  52         if err != nil {
  53                 err = fmt.Errorf("error parsing uri: %w", err)
  54                 return
  55         }
  56         if u.Scheme != "magnet" {
  57                 err = fmt.Errorf("unexpected scheme %q", u.Scheme)
  58                 return
  59         }
  60         q := u.Query()
  61         xt := q.Get("xt")
  62         m.InfoHash, err = parseInfohash(q.Get("xt"))
  63         if err != nil {
  64                 err = fmt.Errorf("error parsing infohash %q: %w", xt, err)
  65                 return
  66         }
  67         dropFirst(q, "xt")
  68         m.DisplayName = q.Get("dn")
  69         dropFirst(q, "dn")
  70         m.Trackers = q["tr"]
  71         delete(q, "tr")
  72         if len(q) == 0 {
  73                 q = nil
  74         }
  75         m.Params = q
  76         return
  77 }
  78
  79 func parseInfohash(xt string) (ih Hash, err error) {
  80         if !strings.HasPrefix(xt, xtPrefix) {
  81                 err = errors.New("bad xt parameter prefix")
  82                 return
  83         }
  84         encoded := xt[len(xtPrefix):]
  85         decode := func() func(dst, src []byte) (int, error) {
  86                 switch len(encoded) {
  87                 case 40:
  88                         return hex.Decode
  89                 case 32:
  90                         return base32.StdEncoding.Decode
  91                 }
  92                 return nil
  93         }()
  94         if decode == nil {
  95                 err = fmt.Errorf("unhandled xt parameter encoding (encoded length %d)", len(encoded))
  96                 return
  97         }
  98         n, err := decode(ih[:], []byte(encoded))
  99         if err != nil {
 100                 err = fmt.Errorf("error decoding xt: %w", err)
 101                 return
 102         }
 103         if n != 20 {
 104                 panic(n)
 105         }
 106         return
 107 }
 108
 109 func dropFirst(vs url.Values, key string) {
 110         sl := vs[key]
 111         switch len(sl) {
 112         case 0, 1:
 113                 vs.Del(key)
 114         default:
 115                 vs[key] = sl[1:]
 116         }
 117 }