torrent

type Binder interface {
	// Bind to the given client if err is nil.
	Bind(cl *Client, err error) (*Client, error)
}

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

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"`

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

	// 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

	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

	// 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

	DisableIPv4Peers bool
	Logger           logger // standard logging for errors, defaults to stderr
	Warn             logger // warn logging
	Debug            logger // debug logging, defaults to discard

	// 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

	connections.Handshaker

	// OnQuery hook func
	DHTOnQuery      func(query *krpc.Msg, source net.Addr) (propagate bool)
	DHTAnnouncePeer func(ih metainfo.Hash, ip net.IP, port int, portOk bool)
	// contains filtered or unexported fields
}

type ClientConfigOption func(*ClientConfig)

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
}

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

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

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

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

type IpPort = missinggo.IpPort

type Metadata 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
	// The chunk size to use for outbound requests. Defaults to 16KiB if not
	// set.
	ChunkSize int
	Storage   storage.ClientImpl
}

type Option func(*Metadata)

type Peer struct {
	ID     [20]byte
	IP     net.IP
	Port   int
	Source peerSource
	// Peer is known to support encryption.
	SupportsEncryption bool
	btprotocol.PexPeerFlags
	// Whether we can ignore poor or bad behaviour from the peer.
	Trusted bool
}

type PeerExtensionBits = pp.ExtensionBits

type PeerID [20]byte

type Peers []Peer

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

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
}

type PieceStateChange struct {
	Index int
	PieceState
}

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

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

type Torrent interface {
	Metadata() Metadata
	Tune(...Tuner) error
	Name() string                // TODO: remove, should be pulled from Metadata()
	Metainfo() metainfo.MetaInfo // TODO: remove, should be pulled from Metadata()
	BytesCompleted() int64       // TODO: maybe should be pulled from torrent, it has a reference to the storage implementation. or maybe part of the Stats call?
	VerifyData()                 // TODO: maybe should be pulled from torrent, it has a reference to the storage implementation.
	NewReader() Reader           // TODO: maybe should be pulled from torrent, it has a reference to the storage implementation.
	Stats() TorrentStats         // TODO: rename TorrentStats, it stutters.
	Info() *metainfo.Info        // TODO: remove, this should be pulled from Metadata()
	GotInfo() <-chan struct{}    // TODO: remove, torrents should never be returned in they don't have the meta info.
	DownloadAll()                // TODO: rethink this. does it even need to exist or can it be rolled up into Start/Download.
	Files() []*File              // TODO: maybe should be pulled from Metadata(), it has a reference to the storage implementation.
	SubscribePieceStateChanges() *pubsub.Subscription
	PieceStateRuns() []PieceStateRun
}

type TorrentStats struct {
	// Aggregates stats over all connections past and present. Some values may
	// not have much meaning in the aggregate context.
	ConnStats

	// metrics marking the progress of the torrent
	// these are in chunks.
	Missing     int
	Outstanding int
	Unverified  int
	Completed   int

	// Ordered by expected descending quantities (if all is well).
	MaximumAllowedPeers int
	TotalPeers          int
	PendingPeers        int
	ActivePeers         int
	ConnectedSeeders    int
	HalfOpenPeers       int

	Seeding bool
}

type Tuner func(*torrent)