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 // Deprecated: Use ParseMagnetUri.
  50 var ParseMagnetURI = ParseMagnetUri
  51
  52 // ParseMagnetUri parses Magnet-formatted URIs into a Magnet instance
  53 func ParseMagnetUri(uri string) (m Magnet, err error) {
  54         u, err := url.Parse(uri)
  55         if err != nil {
  56                 err = fmt.Errorf("error parsing uri: %w", err)
  57                 return
  58         }
  59         if u.Scheme != "magnet" {
  60                 err = fmt.Errorf("unexpected scheme %q", u.Scheme)
  61                 return
  62         }
  63         q := u.Query()
  64         xt := q.Get("xt")
  65         m.InfoHash, err = parseInfohash(q.Get("xt"))
  66         if err != nil {
  67                 err = fmt.Errorf("error parsing infohash %q: %w", xt, err)
  68                 return
  69         }
  70         dropFirst(q, "xt")
  71         m.DisplayName = q.Get("dn")
  72         dropFirst(q, "dn")
  73         m.Trackers = q["tr"]
  74         delete(q, "tr")
  75         if len(q) == 0 {
  76                 q = nil
  77         }
  78         m.Params = q
  79         return
  80 }
  81
  82 func parseInfohash(xt string) (ih Hash, err error) {
  83         if !strings.HasPrefix(xt, xtPrefix) {
  84                 err = errors.New("bad xt parameter prefix")
  85                 return
  86         }
  87         encoded := xt[len(xtPrefix):]
  88         decode := func() func(dst, src []byte) (int, error) {
  89                 switch len(encoded) {
  90                 case 40:
  91                         return hex.Decode
  92                 case 32:
  93                         return base32.StdEncoding.Decode
  94                 }
  95                 return nil
  96         }()
  97         if decode == nil {
  98                 err = fmt.Errorf("unhandled xt parameter encoding (encoded length %d)", len(encoded))
  99                 return
 100         }
 101         n, err := decode(ih[:], []byte(encoded))
 102         if err != nil {
 103                 err = fmt.Errorf("error decoding xt: %w", err)
 104                 return
 105         }
 106         if n != 20 {
 107                 panic(n)
 108         }
 109         return
 110 }
 111
 112 func dropFirst(vs url.Values, key string) {
 113         sl := vs[key]
 114         switch len(sl) {
 115         case 0, 1:
 116                 vs.Del(key)
 117         default:
 118                 vs[key] = sl[1:]
 119         }
 120 }