CircleCI Astronomer Rating GitHub Release PkgGoDev

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, mmap, and sqlite, 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:


Install the library package with go get, or the provided cmds with go get

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:


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

Command packages

Here I'll describe what some of the packages in ./cmd do. Install them with go get


Downloads torrents from the command-line.

$ torrent download 'magnet:?xt=urn:btih:KRWPCX3SJUM4IMM4YF5RPHL6ANPYTQPU'
... lots of jibba jabber ...
downloading "ubuntu-14.04.2-desktop-amd64.iso": 1.0 GB/1.0 GB, 1989/1992 pieces completed (1 partial)
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

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
$ torrentfs -mountDir=mnt -metainfoDir=torrents &
$ cd torrents
$ wget
$ cd ..
$ ls mnt
$ pv mnt/ubuntu-14.04.2-desktop-amd64.iso | md5sum
996MB 0:04:40 [3.55MB/s] [========================================>] 100%
1b305d585b1918f297164add46784116  -

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

$ torrent-magnet < torrents/ubuntu-14.04.2-desktop-amd64.iso.torrent



    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
     - 29: uTorrent transport protocol
     - 41: UDP Tracker Protocol Extensions
     - 42: DHT Security extension
     - 43: Read-only DHT Nodes
    Example (FileReader)




    View Source
    const (
    	PeerSourceTracker         = "Tr"
    	PeerSourceIncoming        = "I"
    	PeerSourceDhtGetPeers     = "Hg" // Peers we found by searching a DHT.
    	PeerSourceDhtAnnouncePeer = "Ha" // Peers that were announced to us by a DHT.
    	PeerSourcePex             = "X"
    	// The peer was given directly, such as through a magnet link.
    	PeerSourceDirect = "M"
    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.
    	PiecePriorityNow // A Reader is reading in this piece. Highest urgency.
    View Source
    const UpnpDiscoverLogTag = "upnp-discover"


    View Source
    var WebseedHttpClient = &http.Client{
    	Transport: &http.Transport{
    		MaxConnsPerHost: 10,


    func LoopbackListenHost

    func LoopbackListenHost(network string) string

    func NewUtpSocket

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

    func RequestStrategyDuplicateRequestTimeout

    func RequestStrategyDuplicateRequestTimeout(duplicateRequestTimeout time.Duration) requestStrategyMaker

      Requests are strictly by piece priority, and not duplicated until duplicateRequestTimeout is reached.

      func RequestStrategyFastest

      func RequestStrategyFastest() requestStrategyMaker

        The fastest connection downloads strictly in order of priority, while all others adhere to their piece inclinations.

        func RequestStrategyFuzzing

        func RequestStrategyFuzzing() requestStrategyMaker

          Favour higher priority pieces with some fuzzing to reduce overlaps and wastage across connections.


          type Callbacks

          type Callbacks struct {
          	// Called after a peer connection completes the BitTorrent handshake. The Client lock is not
          	// held.
          	CompletedHandshake    func(*PeerConn, InfoHash)
          	ReadMessage           func(*PeerConn, *pp.Message)
          	ReadExtendedHandshake func(*PeerConn, *pp.ExtendedHandshakeMessage)
          	PeerConnClosed        func(*PeerConn)
          	// Provides secret keys to be tried against incoming encrypted connections.
          	ReceiveEncryptedHandshakeSkeys mse.SecretKeyIter
          	ReceivedUsefulData []func(ReceivedUsefulDataEvent)
          	ReceivedRequested  []func(PeerMessageEvent)
          	DeletedRequest     []func(PeerRequestEvent)
          	SentRequest        []func(PeerRequestEvent)
          	PeerClosed         []func(*Peer)
          	NewPeer            []func(*Peer)

            These are called synchronously, and do not pass ownership of arguments (do not expect to retain data after returning from the callback). The Client and other locks may still be held. nil functions are not called.

            type ChunkSpec

            type ChunkSpec struct {
            	Begin, Length pp.Integer

            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) AddDhtServer

              func (cl *Client) AddDhtServer(d DhtServer)

              func (*Client) AddDialer

              func (cl *Client) AddDialer(d Dialer)

                Adds a Dialer for outgoing connections. All Dialers are used when attempting to connect to a given address for any Torrent.

                func (*Client) AddListener

                func (cl *Client) AddListener(l Listener)

                  Registers a Listener, and starts Accepting on it. You must Close Listeners provided this way yourself.

                  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. Returns new if the torrent wasn't already in the client. See also Torrent.MergeSpec.

                      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) ConnStats

                        func (cl *Client) ConnStats() ConnStats

                          Returns connection-level aggregate stats at the Client level. See the comment on TorrentStats.ConnStats.

                          func (*Client) DhtServers

                          func (cl *Client) DhtServers() []DhtServer

                          func (*Client) ListenAddrs

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

                            ListenAddrs addresses currently being listened to.

                            func (*Client) LocalPort

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

                              Returns the port number for the first listener that has one. No longer assumes that all port numbers are the same, due to support for custom listeners. Returns zero if no port number is found.

                              func (*Client) PeerID

                              func (cl *Client) PeerID() PeerID

                              func (*Client) String

                              func (cl *Client) String() string

                              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
                                      	UpnpID                  string
                                      	// 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 func(network string) dht.StartingNodesGetter
                                      	// Called for each anacrolix/dht Server created for the Client.
                                      	ConfigureAnacrolixDhtServer func(*dht.ServerConfig)
                                      	// 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 (and Closed when the Client is Closed).
                                      	DefaultStorage storage.ClientImpl
                                      	HeaderObfuscationPolicy HeaderObfuscationPolicy
                                      	// The crypto methods to offer when initiating connections with header obfuscation.
                                      	CryptoProvides mse.CryptoMethod
                                      	// Chooses the crypto method to use when receiving connections with header obfuscation.
                                      	CryptoSelector mse.CryptoSelector
                                      	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"`
                                      	Logger log.Logger
                                      	// Defines proxy for HTTP requests, such as for trackers. It's commonly set from the result of
                                      	// "net/http".ProxyURL(HTTPProxy).
                                      	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
                                      	TotalHalfOpenConns         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
                                      	// Accept rate limiting affects excessive connection attempts from IPs that fail during
                                      	// handshakes or request torrents that we don't have.
                                      	DisableAcceptRateLimiting bool
                                      	// Don't add connections that have the same peer ID as an existing
                                      	// connection for a given Torrent.
                                      	DropDuplicatePeerIds bool
                                      	// Drop peers that are complete if we are also complete and have no use for the peer. This is a
                                      	// bit of a special case, since a peer could also be useless if they're just not interested, or
                                      	// we don't intend to obtain all of a torrent's data.
                                      	DropMutuallyCompletePeers bool
                                      	ConnTracker *conntrack.Instance
                                      	// OnQuery hook func
                                      	DHTOnQuery func(query *krpc.Msg, source net.Addr) (propagate bool)
                                      	DefaultRequestStrategy requestStrategyMaker
                                      	Extensions PeerExtensionBits
                                      	DisableWebtorrent bool
                                      	DisableWebseeds   bool
                                      	Callbacks Callbacks

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

                                        func NewDefaultClientConfig

                                        func NewDefaultClientConfig() *ClientConfig

                                        func TestingConfig

                                        func TestingConfig(t testing.TB) *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. Due to the implementation of Count, must be aligned on some platforms: See

                                          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) MarshalJSON

                                          func (me *Count) MarshalJSON() ([]byte, error)

                                          func (*Count) String

                                          func (me *Count) String() string

                                          type DhtAnnounce

                                          type DhtAnnounce interface {
                                          	Peers() <-chan dht.PeersValues

                                          type DhtServer

                                          type DhtServer interface {
                                          	Stats() interface{}
                                          	ID() [20]byte
                                          	Addr() net.Addr
                                          	AddNode(ni krpc.NodeInfo) error
                                          	Ping(addr *net.UDPAddr)
                                          	Announce(hash [20]byte, port int, impliedPort bool) (DhtAnnounce, error)

                                          type Dialer

                                          type Dialer interface {
                                          	// The network is implied by the instance.
                                          	Dial(_ context.Context, addr string) (net.Conn, error)
                                          	// This is required for registering with the connection tracker (router connection table
                                          	// emulating rate-limiter) before dialing. TODO: What about connections that wouldn't infringe
                                          	// on routers, like localhost or unix sockets.
                                          	LocalAddr() net.Addr

                                          type File

                                          type File struct {
                                          	// contains filtered or unexported fields

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

                                            func (*File) BytesCompleted

                                            func (f *File) BytesCompleted() int64

                                              Number of bytes of the entire file we have completed. This is the sum of completed pieces, and dirtied chunks of incomplete pieces.

                                              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.

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

                                                                    type Handle

                                                                    type Handle interface {

                                                                      A file-like handle to some torrent data resource.

                                                                      type HeaderObfuscationPolicy

                                                                      type HeaderObfuscationPolicy struct {
                                                                      	RequirePreferred bool // Whether the value of Preferred is a strict requirement.
                                                                      	Preferred        bool // Whether header obfuscation is preferred.

                                                                      type InfoHash

                                                                      type InfoHash = metainfo.Hash

                                                                      type IpPort

                                                                      type IpPort = missinggo.IpPort

                                                                      type Listener

                                                                      type Listener interface {
                                                                      	// Accept waits for and returns the next connection to the listener.
                                                                      	Accept() (net.Conn, error)
                                                                      	// Addr returns the listener's network address.
                                                                      	Addr() net.Addr

                                                                      type NetDialer

                                                                      type NetDialer struct {
                                                                      	Network string
                                                                      	Dialer  net.Dialer

                                                                      func (NetDialer) Dial

                                                                      func (me NetDialer) Dial(ctx context.Context, addr string) (_ net.Conn, err error)

                                                                      func (NetDialer) LocalAddr

                                                                      func (me NetDialer) LocalAddr() net.Addr

                                                                      type Peer

                                                                      type Peer struct {
                                                                      	Network    string
                                                                      	RemoteAddr PeerRemoteAddr
                                                                      	Discovery PeerSource
                                                                      	PeerPrefersEncryption bool // as indicated by 'e' field in extension handshake
                                                                      	PeerListenPort        int
                                                                      	PeerMaxRequests  int // Maximum pending requests the peer allows.
                                                                      	PeerExtensionIDs map[pp.ExtensionName]pp.ExtensionNumber
                                                                      	PeerClientName   string
                                                                      	// contains filtered or unexported fields

                                                                      func (*Peer) TryAsPeerConn

                                                                      func (p *Peer) TryAsPeerConn() (*PeerConn, bool)

                                                                      type PeerConn

                                                                      type PeerConn struct {
                                                                      	// See BEP 3 etc.
                                                                      	PeerID             PeerID
                                                                      	PeerExtensionBytes pp.PeerExtensionBits
                                                                      	// contains filtered or unexported fields

                                                                        Maintains the state of a BitTorrent-protocol based connection with a peer.

                                                                        func (*PeerConn) PeerPieces

                                                                        func (cn *PeerConn) PeerPieces() bitmap.Bitmap

                                                                          Returns the pieces the peer has claimed to have.

                                                                          func (*PeerConn) String

                                                                          func (c *PeerConn) String() string

                                                                          type PeerExtensionBits

                                                                          type PeerExtensionBits = pp.PeerExtensionBits

                                                                          type PeerID

                                                                          type PeerID [20]byte

                                                                            Peer client ID.

                                                                            type PeerInfo

                                                                            type PeerInfo struct {
                                                                            	Id     [20]byte
                                                                            	Addr   PeerRemoteAddr
                                                                            	Source PeerSource
                                                                            	// Peer is known to support encryption.
                                                                            	SupportsEncryption bool
                                                                            	// Whether we can ignore poor or bad behaviour from the peer.
                                                                            	Trusted bool

                                                                              Peer connection info, handed about publicly.

                                                                              func (*PeerInfo) FromPex

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

                                                                                Generate PeerInfo from peer exchange

                                                                                type PeerMessageEvent

                                                                                type PeerMessageEvent struct {
                                                                                	Peer    *Peer
                                                                                	Message *pp.Message

                                                                                type PeerRemoteAddr

                                                                                type PeerRemoteAddr interface {
                                                                                	String() string

                                                                                type PeerRequestEvent

                                                                                type PeerRequestEvent struct {
                                                                                	Peer *Peer

                                                                                type PeerSource

                                                                                type PeerSource string

                                                                                type PeerStorer

                                                                                type PeerStorer interface {
                                                                                	PeerStore() peer_store.Interface

                                                                                  Optional interface for DhtServer's that can expose their peer store (if any).

                                                                                  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) State

                                                                                  func (p *Piece) State() PieceState

                                                                                  func (*Piece) Storage

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

                                                                                  func (*Piece) String

                                                                                  func (p *Piece) String() string

                                                                                  func (*Piece) UpdateCompletion

                                                                                  func (p *Piece) UpdateCompletion()

                                                                                    Tells the Client to refetch the completion status from storage, updating priority etc. if necessary. Might be useful if you know the state of the piece data has changed externally.

                                                                                    func (*Piece) VerifyData

                                                                                    func (p *Piece) VerifyData()

                                                                                      Forces the piece data to be rehashed.

                                                                                      type PieceState

                                                                                      type PieceState struct {
                                                                                      	Priority piecePriority
                                                                                      	// The piece is being hashed, or is queued for hash. Deprecated: Use those fields instead.
                                                                                      	Checking bool
                                                                                      	Hashing       bool
                                                                                      	QueuedForHash bool
                                                                                      	// The piece state is being marked in the storage.
                                                                                      	Marking bool
                                                                                      	// Some of the piece has been obtained.
                                                                                      	Partial bool

                                                                                        The current state of a piece.

                                                                                        type PieceStateChange

                                                                                        type PieceStateChange struct {
                                                                                        	Index int

                                                                                        type PieceStateRun

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

                                                                                          Represents a series of consecutive pieces with the same state.

                                                                                          func (PieceStateRun) String

                                                                                          func (psr PieceStateRun) String() (ret string)

                                                                                            Produces a small string representing a PieceStateRun.

                                                                                            type PieceStateRuns

                                                                                            type PieceStateRuns []PieceStateRun

                                                                                            func (PieceStateRuns) String

                                                                                            func (me PieceStateRuns) String() string

                                                                                            type Reader

                                                                                            type Reader interface {
                                                                                            	// Configure the number of bytes ahead of a read that should also be prioritized in preparation
                                                                                            	// for further reads.
                                                                                            	// Don't wait for pieces to complete and be verified. Read calls return as soon as they can when
                                                                                            	// the underlying chunks become available.

                                                                                              Accesses Torrent data via a Client. Reads block until the data is available. Seeks and readahead also drive Client behaviour.

                                                                                              type ReceivedUsefulDataEvent

                                                                                              type ReceivedUsefulDataEvent = PeerMessageEvent

                                                                                              type Request

                                                                                              type Request struct {
                                                                                              	Index pp.Integer

                                                                                              func (Request) ToMsg

                                                                                              func (r Request) ToMsg(mt pp.MessageType) pp.Message

                                                                                              type Torrent

                                                                                              type Torrent struct {
                                                                                              	// contains filtered or unexported fields

                                                                                                Maintains state of torrent within a Client. Many methods should not be called before the info is available, see .Info and .GotInfo.

                                                                                                func (*Torrent) AddClientPeer

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

                                                                                                  Adds a trusted, pending peer for each of the given Client's addresses. Typically used in tests to quickly make one Client visible to the Torrent of another Client.

                                                                                                  func (*Torrent) AddPeers

                                                                                                  func (t *Torrent) AddPeers(pp []PeerInfo) int

                                                                                                  func (*Torrent) AddTrackers

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

                                                                                                  func (*Torrent) AllowDataDownload

                                                                                                  func (t *Torrent) AllowDataDownload()

                                                                                                  func (*Torrent) AllowDataUpload

                                                                                                  func (t *Torrent) AllowDataUpload()

                                                                                                    Enables uploading data, if it was disabled.

                                                                                                    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) DisallowDataDownload

                                                                                                        func (t *Torrent) DisallowDataDownload()

                                                                                                        func (*Torrent) DisallowDataUpload

                                                                                                        func (t *Torrent) DisallowDataUpload()

                                                                                                          Disables uploading data, if it was enabled.

                                                                                                          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 []PeerInfo)

                                                                                                                          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) MergeSpec

                                                                                                                            func (t *Torrent) MergeSpec(spec *TorrentSpec) error

                                                                                                                              The trackers will be merged with the existing ones. If the Info isn't yet known, it will be set. spec.DisallowDataDownload/Upload will be read and applied The display name is replaced if the new spec provides one. Note that any `Storage` is ignored.

                                                                                                                              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. Note that you probably want to ensure the Torrent Info is available first.

                                                                                                                                    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) PeerConns

                                                                                                                                      func (t *Torrent) PeerConns() []*PeerConn

                                                                                                                                      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() PieceStateRuns

                                                                                                                                          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) SetOnWriteChunkError

                                                                                                                                              func (t *Torrent) SetOnWriteChunkError(f func(error))

                                                                                                                                                Sets a handler that is called if there's an error writing a chunk to local storage. By default, or if nil, a critical message is logged, and data download is disabled.

                                                                                                                                                func (*Torrent) Stats

                                                                                                                                                func (t *Torrent) Stats() TorrentStats

                                                                                                                                                  The returned TorrentStats may require alignment in memory. See

                                                                                                                                                  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()

                                                                                                                                                      Forces all the pieces to be re-hashed. See also Piece.VerifyData. This should not be called before the Info is available.

                                                                                                                                                      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
                                                                                                                                                      	Webseeds    []string
                                                                                                                                                      	DhtNodes    []string
                                                                                                                                                      	PeerAddrs   []string
                                                                                                                                                      	// The combination of the "xs" and "as" fields in magnet links, for now.
                                                                                                                                                      	Sources []string
                                                                                                                                                      	// The chunk size to use for outbound requests. Defaults to 16KiB if not set.
                                                                                                                                                      	ChunkSize int
                                                                                                                                                      	Storage   storage.ClientImpl
                                                                                                                                                      	// Whether to allow data download or upload
                                                                                                                                                      	DisallowDataUpload   bool
                                                                                                                                                      	DisallowDataDownload bool

                                                                                                                                                        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) *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.
                                                                                                                                                        	// Ordered by expected descending quantities (if all is well).
                                                                                                                                                        	TotalPeers       int
                                                                                                                                                        	PendingPeers     int
                                                                                                                                                        	ActivePeers      int
                                                                                                                                                        	ConnectedSeeders int
                                                                                                                                                        	HalfOpenPeers    int

                                                                                                                                                          Due to ConnStats, may require special alignment on some platforms. See


                                                                                                                                                          Path Synopsis
                                                                                                                                                          Converts magnet URIs and info hashes into torrent metainfo files.
                                                                                                                                                          Converts magnet URIs and info hashes into torrent metainfo files.
                                                                                                                                                          Downloads torrents from the command-line.
                                                                                                                                                          Downloads torrents from the command-line.
                                                                                                                                                          Downloads torrents from the command-line.
                                                                                                                                                          Downloads torrents from the command-line.
                                                                                                                                                          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
                                                                                                                                                          Package iplist handles the P2P Plaintext Format described by
                                                                                                                                                          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.
                                                                                                                                                          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.