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
  15         Trackers    []string
  16         DisplayName string
  17         Params      url.Values
  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         vs.Add("xt", xtPrefix+m.InfoHash.HexString())
  30         for _, tr := range m.Trackers {
  31                 vs.Add("tr", tr)
  32         }
  33         if m.DisplayName != "" {
  34                 vs.Add("dn", m.DisplayName)
  35         }
  36
  37         return (&url.URL{
  38                 Scheme:   "magnet",
  39                 RawQuery: vs.Encode(),
  40         }).String()
  41 }
  42
  43 // ParseMagnetURI parses Magnet-formatted URIs into a Magnet instance
  44 func ParseMagnetURI(uri string) (m Magnet, err error) {
  45         u, err := url.Parse(uri)
  46         if err != nil {
  47                 err = fmt.Errorf("error parsing uri: %w", err)
  48                 return
  49         }
  50         if u.Scheme != "magnet" {
  51                 err = fmt.Errorf("unexpected scheme %q", u.Scheme)
  52                 return
  53         }
  54         q := u.Query()
  55         xt := q.Get("xt")
  56         m.InfoHash, err = parseInfohash(q.Get("xt"))
  57         if err != nil {
  58                 err = fmt.Errorf("error parsing infohash %q: %w", xt, err)
  59                 return
  60         }
  61         dropFirst(q, "xt")
  62         m.DisplayName = q.Get("dn")
  63         dropFirst(q, "dn")
  64         m.Trackers = q["tr"]
  65         delete(q, "tr")
  66         if len(q) == 0 {
  67                 q = nil
  68         }
  69         m.Params = q
  70         return
  71 }
  72
  73 func parseInfohash(xt string) (ih Hash, err error) {
  74         if !strings.HasPrefix(xt, xtPrefix) {
  75                 err = errors.New("bad xt parameter prefix")
  76                 return
  77         }
  78         encoded := xt[len(xtPrefix):]
  79         decode := func() func(dst, src []byte) (int, error) {
  80                 switch len(encoded) {
  81                 case 40:
  82                         return hex.Decode
  83                 case 32:
  84                         return base32.StdEncoding.Decode
  85                 }
  86                 return nil
  87         }()
  88         if decode == nil {
  89                 err = fmt.Errorf("unhandled xt parameter encoding (encoded length %d)", len(encoded))
  90                 return
  91         }
  92         n, err := decode(ih[:], []byte(encoded))
  93         if err != nil {
  94                 err = fmt.Errorf("error decoding xt: %w", err)
  95                 return
  96         }
  97         if n != 20 {
  98                 panic(n)
  99         }
 100         return
 101 }
 102
 103 func dropFirst(vs url.Values, key string) {
 104         sl := vs[key]
 105         switch len(sl) {
 106         case 0, 1:
 107                 vs.Del(key)
 108         default:
 109                 vs[key] = sl[1:]
 110         }
 111 }