defer cl.unlock()
t.initialPieceCheckDisabled = spec.DisableInitialPieceCheck
for _, url := range spec.Webseeds {
- t.addWebSeed(url, spec.DefaultWebseedEscapePath)
+ t.addWebSeed(url)
}
for _, peerAddr := range spec.PeerAddrs {
t.addPeer(PeerInfo{
"github.com/anacrolix/torrent/metainfo"
pp "github.com/anacrolix/torrent/peer_protocol"
"github.com/anacrolix/torrent/storage"
- "github.com/anacrolix/torrent/webseed"
)
// Specifies a new torrent for adding to a client, or additions to an existing Torrent. There are
InfoBytes []byte
// The name to use if the Name field from the Info isn't available.
DisplayName string
- Webseeds []string
- DhtNodes []string
- PeerAddrs []string
+ // WebSeed URLs. For additional options add the URLs separately with Torrent.AddWebSeeds
+ // instead.
+ Webseeds []string
+ DhtNodes []string
+ PeerAddrs []string
// The combination of the "xs" and "as" fields in magnet links, for now.
Sources []string
// Whether to allow data download or upload
DisallowDataUpload bool
DisallowDataDownload bool
-
- // Custom encoder for webseed URLs
- // Leave nil to use the default (url.QueryEscape)
- DefaultWebseedEscapePath webseed.PathEscaper
}
func TorrentSpecFromMagnetUri(uri string) (spec *TorrentSpec, err error) {
return &t.cl.config.Callbacks
}
-type AddWebseedsOpt func() *AddWebseedOpts
+type AddWebSeedsOpt func(*webseed.Client)
-type AddWebseedOpts struct {
- // Custom encoder for webseed URLs
- // Leave nil to use the default (url.QueryEscape)
- PathEscaper webseed.PathEscaper
+// Sets the WebSeed trailing path escaper for a webseed.Client.
+func WebSeedPathEscaper(custom webseed.PathEscaper) AddWebSeedsOpt {
+ return func(c *webseed.Client) {
+ c.PathEscaper = custom
+ }
}
-
-// Add web seeds to the torrent.
-// If opt is not nil, only the first one is used.
-func (t *Torrent) AddWebSeeds(urls []string, opt ...AddWebseedsOpt) {
+func (t *Torrent) AddWebSeeds(urls []string, opts ...AddWebSeedsOpt) {
t.cl.lock()
defer t.cl.unlock()
for _, u := range urls {
- if opt == nil {
- t.addWebSeed(u, nil)
- } else {
- t.addWebSeed(u, opt[0]().PathEscaper)
- }
+ t.addWebSeed(u, opts...)
}
}
-func (t *Torrent) addWebSeed(url string, pathEscaper webseed.PathEscaper) {
+func (t *Torrent) addWebSeed(url string, opts ...AddWebSeedsOpt) {
if t.cl.config.DisableWebseeds {
return
}
r: r,
}
},
- PathEscaper: pathEscaper,
},
activeRequests: make(map[Request]webseed.Request, maxRequests),
maxRequests: maxRequests,
}
+ for _, opt := range opts {
+ opt(&ws.client)
+ }
ws.peer.initUpdateRequestsTimer()
ws.requesterCond.L = t.cl.locker()
for i := 0; i < maxRequests; i += 1 {
r.cancel()
}
-type Spec struct {
- Urls []string
- EncodeUrl func(string) string
-}
-
type Client struct {
HttpClient *http.Client
Url string
ctx, cancel := context.WithCancel(context.Background())
var requestParts []requestPart
if !ws.fileIndex.Locate(r, func(i int, e segments.Extent) bool {
- req, err := NewRequestWithOpts(
+ req, err := newRequest(
ws.Url, i, ws.info, e.Start, e.Length,
ws.PathEscaper,
)
// Escapes path name components suitable for appending to a webseed URL. This works for converting
// S3 object keys to URLs too.
//
-// Contrary to the name, this actually does a QueryEscape, rather than a
-// PathEscape. This works better with most S3 providers. You can use
-// EscapePathWithOpts for a custom encoding.
+// Contrary to the name, this actually does a QueryEscape, rather than a PathEscape. This works
+// better with most S3 providers.
func EscapePath(pathComps []string) string {
- return escapePath(pathComps, nil)
+ return defaultPathEscaper(pathComps)
}
-func EscapePathWithCustomEscaper(pathComps []string, pathEscaper PathEscaper) string {
- return escapePath(pathComps, pathEscaper)
-}
-
-func escapePath(pathComps []string, pathEscaper PathEscaper) string {
- if pathEscaper != nil {
- return pathEscaper(pathComps)
- }
-
+func defaultPathEscaper(pathComps []string) string {
var ret []string
for _, comp := range pathComps {
ret = append(ret, url.QueryEscape(comp))
fileComps []string,
pathEscaper PathEscaper,
) string {
- return escapePath(append([]string{infoName}, fileComps...), pathEscaper)
+ if pathEscaper == nil {
+ pathEscaper = defaultPathEscaper
+ }
+ return pathEscaper(append([]string{infoName}, fileComps...))
}
// Creates a request per BEP 19.
-func NewRequest(
- url_ string,
- fileIndex int, info *metainfo.Info,
- offset, length int64) (*http.Request, error) {
- return newRequest(url_, fileIndex, info, offset, length, nil)
-}
-
-func NewRequestWithOpts(
- url_ string, fileIndex int,
- info *metainfo.Info,
- offset, length int64,
- pathEscaper PathEscaper,
-) (*http.Request, error) {
- return newRequest(url_, fileIndex, info, offset, length, pathEscaper)
-}
-
func newRequest(
url_ string, fileIndex int,
info *metainfo.Info,
if strings.HasSuffix(url_, "/") {
// BEP specifies that we append the file path. We need to escape each component of the path
// for things like spaces and '#'.
- url_ += escapePath(append([]string{info.Name}, fileInfo.Path...), pathEscaper)
+ url_ += trailingPath(info.Name, fileInfo.Path, pathEscaper)
}
req, err := http.NewRequest(http.MethodGet, url_, nil)
if err != nil {
escaper PathEscaper,
unescaper func(string) (string, error),
) {
- unescaped, err := unescaper(escapePath(parts, escaper))
+ unescaped, err := unescaper(escaper(parts))
if !c.Check(err, qt.IsNil) {
return
}
test(
[]string{"a_b-c", "d + e.f"},
"a_b-c/d + e.f",
- nil,
+ defaultPathEscaper,
url.QueryUnescape,
)
test(
[]string{"a_1-b_c2", "d 3. (e, f).g"},
"a_1-b_c2/d 3. (e, f).g",
- nil,
+ defaultPathEscaper,
url.QueryUnescape,
)
}
func TestEscapePathForEmptyInfoName(t *testing.T) {
- qt.Check(t, escapePath([]string{`ノ┬─┬ノ ︵ ( \o°o)\`}, nil), qt.Equals, "%E3%83%8E%E2%94%AC%E2%94%80%E2%94%AC%E3%83%8E+%EF%B8%B5+%28+%5Co%C2%B0o%29%5C")
- qt.Check(t, escapePath([]string{"hello", "world"}, nil), qt.Equals, "hello/world")
- qt.Check(t, escapePath([]string{"war", "and", "peace"}, nil), qt.Equals, "war/and/peace")
+ qt.Check(t, defaultPathEscaper([]string{`ノ┬─┬ノ ︵ ( \o°o)\`}), qt.Equals, "%E3%83%8E%E2%94%AC%E2%94%80%E2%94%AC%E3%83%8E+%EF%B8%B5+%28+%5Co%C2%B0o%29%5C")
+ qt.Check(t, defaultPathEscaper([]string{"hello", "world"}), qt.Equals, "hello/world")
+ qt.Check(t, defaultPathEscaper([]string{"war", "and", "peace"}), qt.Equals, "war/and/peace")
}