README

torrent

GoDoc CircleCI

This repository implements BitTorrent-related packages and command-line utilities in Go. The emphasis is on use as a library from other projects. It's been used 24/7 in production by downstream services since late 2014. The implementation was specifically created to explore Go's concurrency capabilities, and to include the ability to stream data directly from the BitTorrent network. To this end it supports seeking, readaheads and other features exposing torrents and their files with the various Go idiomatic io package interfaces. This is also demonstrated through torrentfs.

There is support for protocol encryption, DHT, PEX, uTP, and various extensions. There are several data storage backends provided: blob, file, bolt, and mmap, to name a few. You can write your own to store data for example on S3, or in a database.

Some noteworthy package dependencies that can be used for other purposes include:

Installation

Install the library package with go get github.com/anacrolix/torrent, or the provided cmds with go get github.com/anacrolix/torrent/cmd/....

Library examples

There are some small examples in the package documentation.

Downstream projects

There are several web-frontends and Android clients among the known public projects:

Help

Communication about the project is primarily through Gitter and the issue tracker.

Command packages

Here I'll describe what some of the packages in ./cmd do.

Note that the godo command which is invoked in the following examples builds and executes a Go import path, like go run. It's easier to use this convention than to spell out the install/invoke cycle for every single example.

torrent

Downloads torrents from the command-line. This first example does not use godo.

$ go get github.com/anacrolix/torrent/cmd/torrent
# Now 'torrent' should be in $GOPATH/bin, which should be in $PATH.
$ torrent 'magnet:?xt=urn:btih:KRWPCX3SJUM4IMM4YF5RPHL6ANPYTQPU'
ubuntu-14.04.2-desktop-amd64.iso [===================================================================>]  99% downloading (1.0 GB/1.0 GB)
2015/04/01 02:08:20 main.go:137: downloaded ALL the torrents
$ md5sum ubuntu-14.04.2-desktop-amd64.iso
1b305d585b1918f297164add46784116  ubuntu-14.04.2-desktop-amd64.iso
$ echo such amaze
wow
torrentfs

torrentfs mounts a FUSE filesystem at -mountDir. The contents are the torrents described by the torrent files and magnet links at -metainfoDir. Data for read requests is fetched only as required from the torrent network, and stored at -downloadDir.

$ mkdir mnt torrents
$ godo github.com/anacrolix/torrent/cmd/torrentfs -mountDir=mnt -metainfoDir=torrents &
$ cd torrents
$ wget http://releases.ubuntu.com/14.04.2/ubuntu-14.04.2-desktop-amd64.iso.torrent
$ cd ..
$ ls mnt
ubuntu-14.04.2-desktop-amd64.iso
$ pv mnt/ubuntu-14.04.2-desktop-amd64.iso | md5sum
996MB 0:04:40 [3.55MB/s] [========================================>] 100%
1b305d585b1918f297164add46784116  -
torrent-magnet

Creates a magnet link from a torrent file. Note the extracted trackers, display name, and info hash.

$ godo github.com/anacrolix/torrent/cmd/torrent-magnet < ubuntu-14.04.2-desktop-amd64.iso.torrent
magnet:?xt=urn:btih:546cf15f724d19c4319cc17b179d7e035f89c1f4&dn=ubuntu-14.04.2-desktop-amd64.iso&tr=http%3A%2F%2Ftorrent.ubuntu.com%3A6969%2Fannounce&tr=http%3A%2F%2Fipv6.torrent.ubuntu.com%3A6969%2Fannounce
Expand ▾ Collapse ▴

Documentation

Overview

    Package torrent implements a torrent client. Goals include:

    * Configurable data storage, such as file, mmap, and piece-based.
    * Downloading on demand: torrent.Reader will request only the data required to
      satisfy Reads, which is ideal for streaming and torrentfs.
    

    BitTorrent features implemented include:

    * Protocol obfuscation
    * DHT
    * uTP
    * PEX
    * Magnet links
    * IP Blocklists
    * Some IPv6
    * HTTP and UDP tracker clients
    * BEPs:
     -  3: Basic BitTorrent protocol
     -  5: DHT
     -  6: Fast Extension (have all/none only)
     -  7: IPv6 Tracker Extension
     -  9: ut_metadata
     - 10: Extension protocol
     - 11: PEX
     - 12: Multitracker metadata extension
     - 15: UDP Tracker Protocol
     - 20: Peer ID convention ("-GTnnnn-")
     - 23: Tracker Returns Compact Peer Lists
     - 27: Private torrents
     - 29: uTorrent transport protocol
     - 41: UDP Tracker Protocol Extensions
     - 42: DHT Security extension
     - 43: Read-only DHT Nodes
    
    Example
    Output:
    
    
    Example (FileReader)
    Output:
    
    

    Index

    Examples

    Constants

    View Source
    const (
    	PiecePriorityNone      piecePriority = iota // Not wanted. Must be the zero value.
    	PiecePriorityNormal                         // Wanted.
    	PiecePriorityHigh                           // Wanted a lot.
    	PiecePriorityReadahead                      // May be required soon.
    	// Succeeds a piece where a read occurred. Currently the same as Now,
    	// apparently due to issues with caching.
    	PiecePriorityNext
    	PiecePriorityNow // A Reader is reading in this piece. Highest urgency.
    )

    Variables

    View Source
    var DefaultHTTPUserAgent = "Go-Torrent/1.0"

    Functions

    func LoopbackListenHost

    func LoopbackListenHost(network string) string

    func NewUtpSocket

    func NewUtpSocket(network, addr string, fc firewallCallback) (utpSocket, error)

    Types

    type Client

    type Client struct {
    	// contains filtered or unexported fields
    }

      Clients contain zero or more Torrents. A Client manages a blocklist, the TCP/UDP protocol ports, and DHT as desired.

      func NewClient

      func NewClient(cfg *ClientConfig) (cl *Client, err error)

      func (*Client) AddDHTNodes

      func (cl *Client) AddDHTNodes(nodes []string)

      func (*Client) AddMagnet

      func (cl *Client) AddMagnet(uri string) (T *Torrent, err error)

      func (*Client) AddTorrent

      func (cl *Client) AddTorrent(mi *metainfo.MetaInfo) (T *Torrent, err error)

      func (*Client) AddTorrentFromFile

      func (cl *Client) AddTorrentFromFile(filename string) (T *Torrent, err error)

      func (*Client) AddTorrentInfoHash

      func (cl *Client) AddTorrentInfoHash(infoHash metainfo.Hash) (t *Torrent, new bool)

      func (*Client) AddTorrentInfoHashWithStorage

      func (cl *Client) AddTorrentInfoHashWithStorage(infoHash metainfo.Hash, specStorage storage.ClientImpl) (t *Torrent, new bool)

        Adds a torrent by InfoHash with a custom Storage implementation. If the torrent already exists then this Storage is ignored and the existing torrent returned with `new` set to `false`

        func (*Client) AddTorrentSpec

        func (cl *Client) AddTorrentSpec(spec *TorrentSpec) (t *Torrent, new bool, err error)

          Add or merge a torrent spec. If the torrent is already present, the trackers will be merged with the existing ones. If the Info isn't yet known, it will be set. The display name is replaced if the new spec provides one. Returns new if the torrent wasn't already in the client. Note that any `Storage` defined on the spec will be ignored if the torrent is already present (i.e. `new` return value is `true`)

          func (*Client) BadPeerIPs

          func (cl *Client) BadPeerIPs() []string

          func (*Client) Close

          func (cl *Client) Close()

            Stops the client. All connections to peers are closed and all activity will come to a halt.

            func (*Client) Closed

            func (cl *Client) Closed() <-chan struct{}

            func (*Client) DhtServers

            func (cl *Client) DhtServers() []*dht.Server

            func (*Client) ListenAddrs

            func (cl *Client) ListenAddrs() (ret []net.Addr)

            func (*Client) LocalPort

            func (cl *Client) LocalPort() (port int)

            func (*Client) PeerID

            func (cl *Client) PeerID() PeerID

            func (*Client) Torrent

            func (cl *Client) Torrent(ih metainfo.Hash) (t *Torrent, ok bool)

              Returns a handle to the given torrent, if it's present in the client.

              func (*Client) Torrents

              func (cl *Client) Torrents() []*Torrent

                Returns handles to all the torrents loaded in the Client.

                func (*Client) WaitAll

                func (cl *Client) WaitAll() bool

                  Returns true when all torrents are completely downloaded and false if the client is stopped before that.

                  func (*Client) WriteStatus

                  func (cl *Client) WriteStatus(_w io.Writer)

                    Writes out a human readable status of the client, such as for writing to a HTTP status page.

                    type ClientConfig

                    type ClientConfig struct {
                    	// Store torrent file data in this directory unless .DefaultStorage is
                    	// specified.
                    	DataDir string `long:"data-dir" description:"directory to store downloaded torrent data"`
                    	// The address to listen for new uTP and TCP bittorrent protocol
                    	// connections. DHT shares a UDP socket with uTP unless configured
                    	// otherwise.
                    	ListenHost              func(network string) string
                    	ListenPort              int
                    	NoDefaultPortForwarding bool
                    	// Don't announce to trackers. This only leaves DHT to discover peers.
                    	DisableTrackers bool `long:"disable-trackers"`
                    	DisablePEX      bool `long:"disable-pex"`
                    
                    	// Don't create a DHT.
                    	NoDHT            bool `long:"disable-dht"`
                    	DhtStartingNodes dht.StartingNodesGetter
                    	// Never send chunks to peers.
                    	NoUpload bool `long:"no-upload"`
                    	// Disable uploading even when it isn't fair.
                    	DisableAggressiveUpload bool `long:"disable-aggressive-upload"`
                    	// Upload even after there's nothing in it for us. By default uploading is
                    	// not altruistic, we'll only upload to encourage the peer to reciprocate.
                    	Seed bool `long:"seed"`
                    	// Only applies to chunks uploaded to peers, to maintain responsiveness
                    	// communicating local Client state to peers. Each limiter token
                    	// represents one byte. The Limiter's burst must be large enough to fit a
                    	// whole chunk, which is usually 16 KiB (see TorrentSpec.ChunkSize).
                    	UploadRateLimiter *rate.Limiter
                    	// Rate limits all reads from connections to peers. Each limiter token
                    	// represents one byte. The Limiter's burst must be bigger than the
                    	// largest Read performed on a the underlying rate-limiting io.Reader
                    	// minus one. This is likely to be the larger of the main read loop buffer
                    	// (~4096), and the requested chunk size (~16KiB, see
                    	// TorrentSpec.ChunkSize).
                    	DownloadRateLimiter *rate.Limiter
                    
                    	// User-provided Client peer ID. If not present, one is generated automatically.
                    	PeerID string
                    	// For the bittorrent protocol.
                    	DisableUTP bool
                    	// For the bittorrent protocol.
                    	DisableTCP bool `long:"disable-tcp"`
                    	// Called to instantiate storage for each added torrent. Builtin backends
                    	// are in the storage package. If not set, the "file" implementation is
                    	// used.
                    	DefaultStorage storage.ClientImpl
                    
                    	EncryptionPolicy
                    
                    	// Sets usage of Socks5 Proxy. Authentication should be included in the url if needed.
                    	// Examples: socks5://demo:demo@192.168.99.100:1080
                    	// 			 http://proxy.domain.com:3128
                    	ProxyURL string
                    
                    	IPBlocklist      iplist.Ranger
                    	DisableIPv6      bool `long:"disable-ipv6"`
                    	DisableIPv4      bool
                    	DisableIPv4Peers bool
                    	// Perform logging and any other behaviour that will help debug.
                    	Debug bool `help:"enable debugging"`
                    
                    	// HTTPProxy defines proxy for HTTP requests.
                    	// Format: func(*Request) (*url.URL, error),
                    	// or result of http.ProxyURL(HTTPProxy).
                    	// By default, it is composed from ClientConfig.ProxyURL,
                    	// if not set explicitly in ClientConfig struct
                    	HTTPProxy func(*http.Request) (*url.URL, error)
                    	// HTTPUserAgent changes default UserAgent for HTTP requests
                    	HTTPUserAgent string
                    	// Updated occasionally to when there's been some changes to client
                    	// behaviour in case other clients are assuming anything of us. See also
                    	// `bep20`.
                    	ExtendedHandshakeClientVersion string
                    	// Peer ID client identifier prefix. We'll update this occasionally to
                    	// reflect changes to client behaviour that other clients may depend on.
                    	// Also see `extendedHandshakeClientVersion`.
                    	Bep20 string
                    
                    	// Peer dial timeout to use when there are limited peers.
                    	NominalDialTimeout time.Duration
                    	// Minimum peer dial timeout to use (even if we have lots of peers).
                    	MinDialTimeout             time.Duration
                    	EstablishedConnsPerTorrent int
                    	HalfOpenConnsPerTorrent    int
                    	// Maximum number of peer addresses in reserve.
                    	TorrentPeersHighWater int
                    	// Minumum number of peers before effort is made to obtain more peers.
                    	TorrentPeersLowWater int
                    
                    	// Limit how long handshake can take. This is to reduce the lingering
                    	// impact of a few bad apples. 4s loses 1% of successful handshakes that
                    	// are obtained with 60s timeout, and 5% of unsuccessful handshakes.
                    	HandshakesTimeout time.Duration
                    
                    	// The IP addresses as our peers should see them. May differ from the
                    	// local interfaces due to NAT or other network configurations.
                    	PublicIp4 net.IP
                    	PublicIp6 net.IP
                    
                    	DisableAcceptRateLimiting bool
                    
                    	ConnTracker *conntrack.Instance
                    	// contains filtered or unexported fields
                    }

                      Probably not safe to modify this after it's given to a Client.

                      func NewDefaultClientConfig

                      func NewDefaultClientConfig() *ClientConfig

                      func (*ClientConfig) SetListenAddr

                      func (cfg *ClientConfig) SetListenAddr(addr string) *ClientConfig

                      type ConnStats

                      type ConnStats struct {
                      	// Total bytes on the wire. Includes handshakes and encryption.
                      	BytesWritten     Count
                      	BytesWrittenData Count
                      
                      	BytesRead           Count
                      	BytesReadData       Count
                      	BytesReadUsefulData Count
                      
                      	ChunksWritten Count
                      
                      	ChunksRead       Count
                      	ChunksReadUseful Count
                      	ChunksReadWasted Count
                      
                      	MetadataChunksRead Count
                      
                      	// Number of pieces data was written to, that subsequently passed verification.
                      	PiecesDirtiedGood Count
                      	// Number of pieces data was written to, that subsequently failed
                      	// verification. Note that a connection may not have been the sole dirtier
                      	// of a piece.
                      	PiecesDirtiedBad Count
                      }

                        Various connection-level metrics. At the Torrent level these are aggregates. Chunks are messages with data payloads. Data is actual torrent content without any overhead. Useful is something we needed locally. Unwanted is something we didn't ask for (but may still be useful). Written is things sent to the peer, and Read is stuff received from them.

                        func (*ConnStats) Copy

                        func (me *ConnStats) Copy() (ret ConnStats)

                        type Count

                        type Count struct {
                        	// contains filtered or unexported fields
                        }

                        func (*Count) Add

                        func (me *Count) Add(n int64)

                        func (*Count) Int64

                        func (me *Count) Int64() int64

                        func (*Count) String

                        func (me *Count) String() string

                        type EncryptionPolicy

                        type EncryptionPolicy struct {
                        	DisableEncryption  bool
                        	ForceEncryption    bool // Don't allow unobfuscated connections.
                        	PreferNoEncryption bool
                        }

                        type File

                        type File struct {
                        	// contains filtered or unexported fields
                        }

                          Provides access to regions of torrent data that correspond to its files.

                          func (*File) Cancel

                          func (f *File) Cancel()

                            Deprecated: Use File.SetPriority.

                            func (*File) DisplayPath

                            func (f *File) DisplayPath() string

                              The relative file path for a multi-file torrent, and the torrent name for a single-file torrent.

                              func (*File) Download

                              func (f *File) Download()

                                Requests that all pieces containing data in the file be downloaded.

                                func (File) FileInfo

                                func (f File) FileInfo() metainfo.FileInfo

                                  The FileInfo from the metainfo.Info to which this file corresponds.

                                  func (*File) Length

                                  func (f *File) Length() int64

                                    The file's length in bytes.

                                    func (*File) NewReader

                                    func (f *File) NewReader() Reader

                                    func (*File) Offset

                                    func (f *File) Offset() int64

                                      Data for this file begins this many bytes into the Torrent.

                                      func (File) Path

                                      func (f File) Path() string

                                        The file's path components joined by '/'.

                                        func (*File) Priority

                                        func (f *File) Priority() piecePriority

                                          Returns the priority per File.SetPriority.

                                          func (*File) SetPriority

                                          func (f *File) SetPriority(prio piecePriority)

                                            Sets the minimum priority for pieces in the File.

                                            func (*File) State

                                            func (f *File) State() (ret []FilePieceState)

                                              Returns the state of pieces in this file.

                                              func (*File) Torrent

                                              func (f *File) Torrent() *Torrent

                                              type FilePieceState

                                              type FilePieceState struct {
                                              	Bytes int64 // Bytes within the piece that are part of this File.
                                              	PieceState
                                              }

                                                The download status of a piece that comprises part of a File.

                                                type Handle

                                                type Handle interface {
                                                	io.Reader
                                                	io.Seeker
                                                	io.Closer
                                                	io.ReaderAt
                                                }

                                                  A file-like handle to some torrent data resource.

                                                  type InfoHash

                                                  type InfoHash = metainfo.Hash

                                                  type IpPort

                                                  type IpPort = missinggo.IpPort

                                                  type Peer

                                                  type Peer struct {
                                                  	Id     [20]byte
                                                  	IP     net.IP
                                                  	Port   int
                                                  	Source peerSource
                                                  	// Peer is known to support encryption.
                                                  	SupportsEncryption bool
                                                  	peer_protocol.PexPeerFlags
                                                  }

                                                  func (*Peer) FromPex

                                                  func (me *Peer) FromPex(na krpc.NodeAddr, fs peer_protocol.PexPeerFlags)

                                                  type PeerExtensionBits

                                                  type PeerExtensionBits = pp.PeerExtensionBits

                                                  type PeerID

                                                  type PeerID [20]byte

                                                    Peer client ID.

                                                    type Peers

                                                    type Peers []Peer

                                                    func (*Peers) AppendFromPex

                                                    func (me *Peers) AppendFromPex(nas []krpc.NodeAddr, fs []peer_protocol.PexPeerFlags)

                                                    func (Peers) AppendFromTracker

                                                    func (ret Peers) AppendFromTracker(ps []tracker.Peer) Peers

                                                    type Piece

                                                    type Piece struct {
                                                    	// contains filtered or unexported fields
                                                    }

                                                    func (*Piece) Info

                                                    func (p *Piece) Info() metainfo.Piece

                                                    func (*Piece) SetPriority

                                                    func (p *Piece) SetPriority(prio piecePriority)

                                                    func (*Piece) Storage

                                                    func (p *Piece) Storage() storage.Piece

                                                    func (*Piece) String

                                                    func (p *Piece) String() string

                                                    func (*Piece) VerifyData

                                                    func (p *Piece) VerifyData()

                                                    type PieceState

                                                    type PieceState struct {
                                                    	Priority piecePriority
                                                    	storage.Completion
                                                    	// The piece is being hashed, or is queued for hash.
                                                    	Checking bool
                                                    	// Some of the piece has been obtained.
                                                    	Partial bool
                                                    }

                                                      The current state of a piece.

                                                      type PieceStateChange

                                                      type PieceStateChange struct {
                                                      	Index int
                                                      	PieceState
                                                      }

                                                      type PieceStateRun

                                                      type PieceStateRun struct {
                                                      	PieceState
                                                      	Length int // How many consecutive pieces have this state.
                                                      }

                                                        Represents a series of consecutive pieces with the same state.

                                                        type Reader

                                                        type Reader interface {
                                                        	io.Reader
                                                        	io.Seeker
                                                        	io.Closer
                                                        	missinggo.ReadContexter
                                                        	SetReadahead(int64)
                                                        	SetResponsive()
                                                        }

                                                        type Torrent

                                                        type Torrent struct {
                                                        	// contains filtered or unexported fields
                                                        }

                                                          Maintains state of torrent within a Client.

                                                          func (*Torrent) AddClientPeer

                                                          func (t *Torrent) AddClientPeer(cl *Client)

                                                          func (*Torrent) AddPeers

                                                          func (t *Torrent) AddPeers(pp []Peer)

                                                          func (*Torrent) AddTrackers

                                                          func (t *Torrent) AddTrackers(announceList [][]string)

                                                          func (*Torrent) BytesCompleted

                                                          func (t *Torrent) BytesCompleted() int64

                                                            Number of bytes of the entire torrent we have completed. This is the sum of completed pieces, and dirtied chunks of incomplete pieces. Do not use this for download rate, as it can go down when pieces are lost or fail checks. Sample Torrent.Stats.DataBytesRead for actual file data download rate.

                                                            func (*Torrent) BytesMissing

                                                            func (t *Torrent) BytesMissing() int64

                                                            func (*Torrent) CancelPieces

                                                            func (t *Torrent) CancelPieces(begin, end pieceIndex)

                                                            func (*Torrent) Closed

                                                            func (t *Torrent) Closed() <-chan struct{}

                                                              Returns a channel that is closed when the Torrent is closed.

                                                              func (*Torrent) DownloadAll

                                                              func (t *Torrent) DownloadAll()

                                                                Marks the entire torrent for download. Requires the info first, see GotInfo. Sets piece priorities for historical reasons.

                                                                func (*Torrent) DownloadPieces

                                                                func (t *Torrent) DownloadPieces(begin, end pieceIndex)

                                                                  Raise the priorities of pieces in the range [begin, end) to at least Normal priority. Piece indexes are not the same as bytes. Requires that the info has been obtained, see Torrent.Info and Torrent.GotInfo.

                                                                  func (*Torrent) Drop

                                                                  func (t *Torrent) Drop()

                                                                    Drop the torrent from the client, and close it. It's always safe to do this. No data corruption can, or should occur to either the torrent's data, or connected peers.

                                                                    func (*Torrent) Files

                                                                    func (t *Torrent) Files() []*File

                                                                      Returns handles to the files in the torrent. This requires that the Info is available first.

                                                                      func (*Torrent) GotInfo

                                                                      func (t *Torrent) GotInfo() <-chan struct{}

                                                                        Returns a channel that is closed when the info (.Info()) for the torrent has become available.

                                                                        func (*Torrent) Info

                                                                        func (t *Torrent) Info() *metainfo.Info

                                                                          Returns the metainfo info dictionary, or nil if it's not yet available.

                                                                          func (*Torrent) InfoHash

                                                                          func (t *Torrent) InfoHash() metainfo.Hash

                                                                            The torrent's infohash. This is fixed and cannot change. It uniquely identifies a torrent.

                                                                            func (*Torrent) KnownSwarm

                                                                            func (t *Torrent) KnownSwarm() (ks []Peer)

                                                                              KnownSwarm returns the known subset of the peers in the Torrent's swarm, including active, pending, and half-open peers.

                                                                              func (*Torrent) Length

                                                                              func (t *Torrent) Length() int64

                                                                                The completed length of all the torrent data, in all its files. This is derived from the torrent info, when it is available.

                                                                                func (*Torrent) Metainfo

                                                                                func (t *Torrent) Metainfo() metainfo.MetaInfo

                                                                                  Returns a run-time generated metainfo for the torrent that includes the info bytes and announce-list as currently known to the client.

                                                                                  func (*Torrent) Name

                                                                                  func (t *Torrent) Name() string

                                                                                    The current working name for the torrent. Either the name in the info dict, or a display name given such as by the dn value in a magnet link, or "".

                                                                                    func (*Torrent) NewReader

                                                                                    func (t *Torrent) NewReader() Reader

                                                                                      Returns a Reader bound to the torrent's data. All read calls block until the data requested is actually available.

                                                                                      func (*Torrent) NumPieces

                                                                                      func (t *Torrent) NumPieces() pieceIndex

                                                                                        The number of pieces in the torrent. This requires that the info has been obtained first.

                                                                                        func (*Torrent) Piece

                                                                                        func (t *Torrent) Piece(i pieceIndex) *Piece

                                                                                        func (*Torrent) PieceBytesMissing

                                                                                        func (t *Torrent) PieceBytesMissing(piece int) int64

                                                                                          Get missing bytes count for specific piece.

                                                                                          func (*Torrent) PieceState

                                                                                          func (t *Torrent) PieceState(piece pieceIndex) PieceState

                                                                                          func (*Torrent) PieceStateRuns

                                                                                          func (t *Torrent) PieceStateRuns() []PieceStateRun

                                                                                            Returns the state of pieces of the torrent. They are grouped into runs of same state. The sum of the state run lengths is the number of pieces in the torrent.

                                                                                            func (*Torrent) Seeding

                                                                                            func (t *Torrent) Seeding() bool

                                                                                              Returns true if the torrent is currently being seeded. This occurs when the client is willing to upload without wanting anything in return.

                                                                                              func (*Torrent) SetDisplayName

                                                                                              func (t *Torrent) SetDisplayName(dn string)

                                                                                                Clobbers the torrent display name. The display name is used as the torrent name if the metainfo is not available.

                                                                                                func (*Torrent) SetInfoBytes

                                                                                                func (t *Torrent) SetInfoBytes(b []byte) (err error)

                                                                                                func (*Torrent) SetMaxEstablishedConns

                                                                                                func (t *Torrent) SetMaxEstablishedConns(max int) (oldMax int)

                                                                                                func (*Torrent) Stats

                                                                                                func (t *Torrent) Stats() TorrentStats

                                                                                                func (*Torrent) String

                                                                                                func (t *Torrent) String() string

                                                                                                func (*Torrent) SubscribePieceStateChanges

                                                                                                func (t *Torrent) SubscribePieceStateChanges() *pubsub.Subscription

                                                                                                  The subscription emits as (int) the index of pieces as their state changes. A state change is when the PieceState for a piece alters in value.

                                                                                                  func (*Torrent) VerifyData

                                                                                                  func (t *Torrent) VerifyData()

                                                                                                  type TorrentSpec

                                                                                                  type TorrentSpec struct {
                                                                                                  	// The tiered tracker URIs.
                                                                                                  	Trackers  [][]string
                                                                                                  	InfoHash  metainfo.Hash
                                                                                                  	InfoBytes []byte
                                                                                                  	// The name to use if the Name field from the Info isn't available.
                                                                                                  	DisplayName string
                                                                                                  	// The chunk size to use for outbound requests. Defaults to 16KiB if not
                                                                                                  	// set.
                                                                                                  	ChunkSize int
                                                                                                  	Storage   storage.ClientImpl
                                                                                                  }

                                                                                                    Specifies a new torrent for adding to a client. There are helpers for magnet URIs and torrent metainfo files.

                                                                                                    func TorrentSpecFromMagnetURI

                                                                                                    func TorrentSpecFromMagnetURI(uri string) (spec *TorrentSpec, err error)

                                                                                                    func TorrentSpecFromMetaInfo

                                                                                                    func TorrentSpecFromMetaInfo(mi *metainfo.MetaInfo) (spec *TorrentSpec)

                                                                                                    type TorrentStats

                                                                                                    type TorrentStats struct {
                                                                                                    	// Aggregates stats over all connections past and present. Some values may
                                                                                                    	// not have much meaning in the aggregate context.
                                                                                                    	ConnStats
                                                                                                    
                                                                                                    	// Ordered by expected descending quantities (if all is well).
                                                                                                    	TotalPeers       int
                                                                                                    	PendingPeers     int
                                                                                                    	ActivePeers      int
                                                                                                    	ConnectedSeeders int
                                                                                                    	HalfOpenPeers    int
                                                                                                    }

                                                                                                    Directories

                                                                                                    Path Synopsis
                                                                                                    cmd
                                                                                                    magnet-metainfo
                                                                                                    Converts magnet URIs and info hashes into torrent metainfo files.
                                                                                                    Converts magnet URIs and info hashes into torrent metainfo files.
                                                                                                    torrent
                                                                                                    Downloads torrents from the command-line.
                                                                                                    Downloads torrents from the command-line.
                                                                                                    torrent-pick
                                                                                                    Downloads torrents from the command-line.
                                                                                                    Downloads torrents from the command-line.
                                                                                                    torrentfs
                                                                                                    Mounts a FUSE filesystem backed by torrents and magnet links.
                                                                                                    Mounts a FUSE filesystem backed by torrents and magnet links.
                                                                                                    Package iplist handles the P2P Plaintext Format described by https://en.wikipedia.org/wiki/PeerGuardian#P2P_plaintext_format.
                                                                                                    Package iplist handles the P2P Plaintext Format described by https://en.wikipedia.org/wiki/PeerGuardian#P2P_plaintext_format.
                                                                                                    cmd/pack-blocklist
                                                                                                    Takes P2P blocklist text format in stdin, and outputs the packed format from the iplist package.
                                                                                                    Takes P2P blocklist text format in stdin, and outputs the packed format from the iplist package.
                                                                                                    Package logonce implements an io.Writer facade that only performs distinct writes.
                                                                                                    Package logonce implements an io.Writer facade that only performs distinct writes.
                                                                                                    Package storage implements storage backends for package torrent.
                                                                                                    Package storage implements storage backends for package torrent.
                                                                                                    util
                                                                                                    dirwatch
                                                                                                    Package dirwatch provides filesystem-notification based tracking of torrent info files and magnet URIs in a directory.
                                                                                                    Package dirwatch provides filesystem-notification based tracking of torrent info files and magnet URIs in a directory.
                                                                                                    internal